工厂模式

接口

public interface MyInterface {

    void method();

    Integer getType();
}

枚举类

public enum MyInterfaceType {

    A(1, "MyClassA"),

    B(2, "MyClassB"),

    private Integer type;

    private String desc;

    MyInterfaceType(Integer type, String desc) {
        this.type = type;
        this.desc = desc;
    }

    public Integer getType() {
        return type;
    }

    public void setType(Integer type) {
        this.type = type;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }
}

实现接口的实体类

public class MyClassA implements MyInterface {

    @Override
    void method() {
        //do something;
    }

    @Override
    Integer getType() {
        return MyInterfaceType.A.getType();
    }
}

public class MyClassB implements MyInterface {

    @Override
    void method() {
        //do something;
    }

    @Override
    Integer getType() {
        return MyInterfaceType.B.getType();
    }
}

SpringLocator

public class SpringLocator implements ApplicationContextAware{

    private static ApplicationContext applicationContext;
    
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) {
        return (T) applicationContext.getBean(name);
    }
    
    @SuppressWarnings("unchecked")
    public static <T> T getBean(Class<T> clazz) {
        return (T) BeanFactoryUtils.beanOfType(applicationContext, clazz);
    }
    
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException{
        SpringLocator.applicationContext = applicationContext;
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }
    
    public static TaskExecutor getDefaultTaskExecutor() {
        return getBean(BeanNameSpace.DEFAULT_TASK_EXECUTOR);
    }
    
}

工厂

public class MyFactory {

    private Map<Integer, MyInterface> myInterfaceMap = new ConcurrentHashMap<Integer, MyInterface>();

    private AtomicBoolean isInit = new AtomicBoolean(false);

    private MyFactory() {

    }

    public boolean isInit() {
        return isInit.get();
    }

    public void init() {
        Map<String, MyInterface> myInterfaceBeanMap = SpringLocator.getApplicationContext().getBeansOfType(MyInterface.class);
        if (MapUtils.isNotEmpty(myInterfaceBeanMap)) {
            for (MyInterface myInterface : myInterfaceBeanMap.values()) {
                myInterfaceMap.put(myInterface.getType(), myInterface);
            }
        }
        isInit.compareAndSet(false, true);
    }

    private static class SingleHolder {

        private static MyFactory myFactory = new MyFactory();

        private SingleHolder() {}

        public static MyFactory getInstance() {
            if (!myFactory.isInit()) {
                myFactory.init();
            }
            return myFactory;
         }
    }

    private static MyFactory getInstance() {
        return SingleHolder.getInstance();
    }

    public static MyInterface getMyInterface(Integer type) {
        MyInterface myInterface = getInstance().myInterfaceMap.get(type);
        Validate.notNull(myInterface, "myInterface is null");
        return myInterface;
    }
}