Spring动态注入泛型集合Bean

为什么80%的码农都做不了架构师？>>>   

我们在使用Spring框架的时候，常常需要注入相关的Bean，如果需要注入有相同类型的Bean的时候，会比较麻烦，需要一个一个注入，并且相对来说扩展性不是很好。

因此提供一种策略模式下获取Bean的方式。

public interface FactoryList<E extends MatchingBean<K>, K> extends List<E> {
    E getBean(K factor);
    List<E> getBeanList(K factor);
}

public interface MatchingBean<K> {
    boolean matching(K factor);
}

public class FactoryListEditor extends CustomCollectionEditor {
    public FactoryListEditor() {
        super(FactoryArrayList.class);
        this.addPropertyChangeListener(new InitializingBeanListener());
    }
    private class InitializingBeanListener implements PropertyChangeListener {
        public void propertyChange(PropertyChangeEvent evt) {
            Object value = ((FactoryListEditor) evt.getSource()).getValue();
            if (value instanceof InitializingBean) {
                try {
                    ((InitializingBean) value).afterPropertiesSet();
                } catch (Exception e) {
                    throw new RuntimeException("初始化bean afterPropertiesSet异常", e);
                }
            }
        }
    }
}

public class FactoryArrayList<E extends MatchingBean<K>, K> extends ArrayList<E>
        implements FactoryList<E, K>, InitializingBean, Serializable {
    public FactoryArrayList() {
        super();
    }
    public FactoryArrayList(int size) {
        super(size);
    }
    public E getBean(K factor) {
        Iterator<E> itr = iterator();
        while (itr.hasNext()) {
            E beanMatch = itr.next();
            if (beanMatch.matching(factor)) {
                return beanMatch;
            }
        }
        return null;
    }
    public List<E> getBeanList(K factor) {
        Iterator<E> itr = iterator();
        while (itr.hasNext()) {
            E beanMatch = itr.next();
            if (!beanMatch.matching(factor)) {
                itr.remove();
            }
        }
        return this;
    }
    public void afterPropertiesSet() throws Exception {
        if (!isEmpty()) {
            Object[] a = toArray();
            OrderComparator.sort(a);
            ListIterator i = listIterator();
            for (int j = 0; j < a.length; j++) {
                i.next();
                i.set(a[j]);
            }
        }
    }
}

使用场景

public interface IProcessor<F> extends MatchingBean<F> {
    public boolean go();
    public InterfaceEnum getFunction();
}

public abstract class AbstractProcessor implements IProcessor<InterfaceEnum> {
    @Override
    public boolean matching(InterfaceEnum func) {
        return this.getFunction() == func;
    }
}

@Service
public class ChildProcessor extends AbstractProcessor {
    @Override
    public boolean go() {
       XX
    }
    @Override
    public InterfaceEnum getFunction() {
        return InterfaceEnum.XXX;
    }
}

最终使用

 @Resource
    private FactoryList<IProcessor<InterfaceEnum>, InterfaceEnum> processors;

private IProcessor getProcessor(InterfaceEnum enum) {
        IProcessor p = processors.getBean(enum); //没有则返回null
        return p;
    }

此处可用作适配器，用来串联起整个标准化的接口业务

也可用Map<String,Interface> beanMap 来自动加载interface的Bean，不过要注意的是beanMap中的key是BeanName

转载于:https://my.oschina.net/guanhe/blog/1821060