使用Spring工廠模式管理多個類實現同一個接口

最近小白在看 Spring IOC 和 AOP 源碼時發現 Spring 中有不少類都實現了同一個接口，像下面這種

public interface AopProxy {
    Object getProxy();
    Object getProxy(@Nullable ClassLoader classLoader);
}
複製代碼

final class JdkDynamicAopProxy implements AopProxy, InvocationHandler, Serializable {
    private static final long serialVersionUID = 5531744639992436476L;
    // 略...
}
複製代碼

@SuppressWarnings("serial")
class CglibAopProxy implements AopProxy, Serializable {
    // 略...
}
複製代碼

此種方式是如何實現的小白還不清楚，但確定知道是 Spring 框架搞的鬼；因此小白就在網上找到了一圈、本身能看懂的一段代碼，而後照着網上的寫法，本身寫了一個關於排序算法的調用，以供參考：

1、枚舉排序類型

/** * @author zhugu * @version 1.0 * @Date 2019/4/17 14:51 * @Description 排序類型 */
public enum SortType {
    SELECTION,
    BUBBLE,
    INSERT,
}
複製代碼

2、編寫一個排序接口，調用入口

/** * @author zhugu * @version 1.0 * @Date 2019/4/17 14:15 * @Description 排序 */
public interface Sort {
    SortType getSortType();
    int[] sorting(int[] sourceArray);
}
複製代碼

3、編寫幾個常見的排序算法
（1）、冒泡排序

/** * @author zhugu * @version 1.0 * @Date 2019/4/17 14:15 * @Description 冒泡排序 */
@Component
public class BubbleSort implements Sort {
    @Override
    public SortType getSortType() {
        return SortType.BUBBLE;
    }

    @Override
    public int[] sorting(int[] sourceArray) {
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        for (int i = 0; i < arr.length; i++) {
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[i] > arr[j]) {
                    int temp = arr[i];
                    arr[i] = arr[j];
                    arr[j] = temp;
                }
            }
        }

        return arr;
    }
}
複製代碼

（2）、插入排序

/** * @author zhugu * @version 1.0 * @Date 2019/4/17 14:17 * @Description 插入排序 */
@Component
public class InsertSort implements Sort {
    @Override
    public SortType getSortType() {
        return SortType.INSERT;
    }

    @Override
    public int[] sorting(int[] sourceArray) {
        // 7, 2, 4, 6, 3, 9, 1
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        printArr(arr);

        // 從下標爲1的元素開始選擇合適的位置插入，由於下標爲0的只有一個元素，默認是有序的
        for (int i = 1; i < arr.length; i++) {
            // 記錄要插入的數據
            int temp = arr[i], j = i;
            // 從已經排序的序列最右邊的開始比較，找到比其小的數
            while (j > 0 && temp < arr[j - 1]) {
                arr[j] = arr[j - 1];
                j--;
            }

            // 存在比其小的數，插入
            if (j != i) {
                arr[j] = temp;
            }

            printArr(arr);
        }

        return arr;
    }

    private void printArr(int[] arr) {
        for (int x = 0; x < arr.length; x++) {
            if (x != arr.length - 1) {
                System.out.print(arr[x] + ", ");
            } else {
                System.out.println(arr[x]);
            }
        }
    }
}
複製代碼

（3）、選擇排序

/** * @author zhugu * @version 1.0 * @Date 2019/4/17 14:16 * @Description 選擇排序 */
@Component
public class SelectionSort implements Sort {
    @Override
    public SortType getSortType() {
        return SortType.SELECTION;
    }

    @Override
    public int[] sorting(int[] sourceArray) {
        int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);

        // 總共要通過 N-1 輪比較
        for (int i = 0; i < arr.length - 1; i++) {
            int min = i;

            // 每輪須要比較的次數 N-i
            for (int j = i + 1; j < arr.length; j++) {
                if (arr[j] < arr[min]) {
                    // 記錄目前能找到的最小值元素的下標
                    min = j;
                }
            }

            // 將找到的最小值和i位置所在的值進行交換
            if (i != min) {
                int temp = arr[i];
                arr[i] = arr[min];
                arr[min] = temp;
            }
        }

        return arr;
    }
}
複製代碼

4、排序工廠，實現 ApplicationContextAware 接口

/** * @author zhugu * @version 1.0 * @Date 2019/4/17 14:56 * @Description 排序工廠 */
@Component
public class SortFactory implements ApplicationContextAware {
    private static Map<SortType, Sort> sortBeanMap = new ConcurrentHashMap<>(16);
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, Sort> map = applicationContext.getBeansOfType(Sort.class);
        map.forEach((key, value) -> sortBeanMap.put(value.getSortType(), value));
    }

    public int[] sorting(SortType sortType, int[] sourceArray) {
        Sort sort = sortBeanMap.get(sortType);
        return sort.sorting(sourceArray);
    }
}
複製代碼

5、測試

@RestController
public class SortController {

    private final SortFactory sortFactory;

    public SortController(SortFactory sortFactory) {
        this.sortFactory = sortFactory;
    }

    @PostMapping(value = "factory/sort")
    public Object sortFactory(SortType sortType, int[] sourceArr) {
        return sortFactory.sorting(sortType, sourceArr);
    }
}
複製代碼

響應參數：

[
    1,
    4,
    6,
    6,
    46,
    46,
    54,
    54,
    65,
    65,
    74,
    85,
    465,
    879,
    9874
]
複製代碼