applicationContext.getBeansOfType 获取一个接口下所有实现类 执行方法或者获取实现类对象等 操作应用场景学习总结

使用前提

当前类首先要获取spring 的 applicationContext 对象(环境需要是 springframework 框架)，然后在项目启动时执行 applicationContext.getBeansOfType 以获取我们目标接口下的所有实现类，然后执行我们后续的其他操作。

大的框架需要如下搭建

参考代码

@Component
public class MyHandlerFactory implements ApplicationContextAware, InitializingBean {
    
    private ApplicationContext applicationContext;
    
    private List<WorkflowHandler> handlerList;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @Override
    public void afterPropertiesSet() {
        Map<String, MyHandler> beansOfType = applicationContext.getBeansOfType(MyHandler.class);
        // 这里的结果返回 即为多个实现的子类可以继续如下转为集合 然后执行集合操作
        Collection<MyHandler> values = beansOfType.values();
        // 之后可以转为List  或者 加入 Map
        // 加入 List 则可以如下
        handlerList = new ArrayList<>(values);
    }

	// 下面可以继续定义其他方法，例如上方既然获取到了MyHandler 接口的所有实现类，那么如果要调用  直接从 handlerList 中遍历执行每个子类重写的对应某一方法即可
	

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

以上重写方法 数据在项目初始化时即可完成 即上方两个方法以及属性其实在项目初始化时已经执行完成，下方继续加入其他在项目中实际调用的方法的即可

MyHandler 即一般的接口我这里类似如下定义
这里简写如下

import com.alibaba.fastjson.JSONObject;

public interface MyHandler {

    Long start(String str1, JSONObject jsonObject);

    void doSomeThing();

    Long end(Long id);

    String getHandlerType();
}
1
2
3
4
5
6
7
8
9
10
11
12

则其他实现类可以添加 @Component 后直接实现上面接口重新对应的方法即可
注意 子类 @Component 一定要有

@Component
public class MyHandlerImpl1 implements MyHandler{
    @Override
    public Long start(String str1, JSONObject jsonObject) {
        // 业务 MyHandlerImpl1 处理
        return null;
    }

    @Override
    public void doSomeThing() {
        // 业务 MyHandlerImpl1 处理
    }

    @Override
    public Long end(Long id) {
        // 业务 MyHandlerImpl1 处理
        return null;
    }

    @Override
    public String getHandlerType() {
        return "MyHandlerImpl1";
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

类似 HandlerImpl1 可以定义 HandlerImpl2 ，HandlerImpl3等等，举个一两个列子

举例与自己的理解

例如我可以定义一个告警类的接口，然后定义多个告警的实现类，实现不同的告警方式，例如 通知告警，信息告警，邮件告警或者短信告警，应用内部机器人告警等等实现的子类。
当需要时，可以直接在最上方 Factory类中定义执行的方法，既然 applicationContext.getBeansOfType 获取到了所有子类，那么接下来只要依次调用不同子类的
doSomeThing() 方法即可执行不同的告警方法，需要指定执行时通过 getHandlerType() 或者其他方式，可以将子类的类型和 子类放到一个Map 中 通过不同的类型获取不同的子类，然后执行指定或者全部子类的某些方法。

再例如可以定义一个工作流程的接口，然后不同的子类内部我可以通过定义不同的 常量，数字，或者枚举，字符串等等方式区别当前子类的类型。

关键点示例

1. 加载接口下的所有实现子类 Map方式存储子类
   以下 Myhandler 为接口

这里的整体思路为 setApplicationContext() afterPropertiesSet() 两个接口初始化时将对应 Myhandler 接口下的所有实现类 添加到 FLOW_HANDLER_MAP Map 中，key 为 不同实现类中自己返回的一个 枚举的名字（字符串）

MyType 为自定义的枚举类型
外部通过 FlowHandlerFactory 的 getHandler 方法获取Map 中的实现子类，从而得到对应的子类，此时外部以父类定义对象， 即

@Resource
public MyHandlerFactory myHandlerFactory;

Myhandler myhandler = myHandlerFactory.getHandler("myType1");
1
2
3
4

得到对应的子类对象后将可以通过这种方式直接进入到不同实现子类的代码中执行 重写方法，即实现了 多态

是不是很眼熟，Java基础和面试题基础讲的就是这个东西，此时一看瞬间感觉豁然开朗

@Component
public class MyHandlerFactory implements ApplicationContextAware, InitializingBean {
    private static final Map<String, Myhandler> FLOW_HANDLER_MAP = new HashMap<>(16);
    private ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    @Override
    public void afterPropertiesSet() {
        applicationContext.getBeansOfType(Myhandler.class).values()
                .forEach(flowHandler -> FLOW_HANDLER_MAP.put(flowHandler.getType().name(), flowHandler));
    }


    public Myhandler getHandler(String typeName) throws MyException {
        MyType myType = MyType.findByName(typeName);
        Myhandler myHandler = FLOW_HANDLER_MAP.get(myType.name());
        if (myHandler == null) {
            throw new MyException(ExceptionType.ERROR_TYPE_NOT_SUPPORT);
        }
        return myHandler;
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

MyType 枚举定义
当然，这里我写的并不规范 参考即可，这里没有添加多余的属性，也没有做保护，实战中这些可能都是需要的，

public enum MyType {
    myType1,
    myType2,
    myType3;

    public static MyType findByName(String name){
        return MyType.valueOf(name);
    }
}
1
2
3
4
5
6
7
8
9

其他子类类似如下定义

@Component
public class MyHandlerImpl1 implements Myhandler {

........ 重写的其他方法

// 父类中一定定义了这个方法  用来区别子类的类型 当然也可以不用枚举，数字  字符传  等等都可以 只要可区分不同的键值对应不同的子类即可
@Override
public MyType getType() {
    return MyType.myType1;
}

}
1
2
3
4
5
6
7
8
9
10
11
12

总结

总体上来说利用了
implements ApplicationContextAware, InitializingBean 在完成了类的初始化加载动作
这个可以见我另一篇文章
contextAware

然后使用Map 的方式或者List 方式存储了 接口下所有子类，之后即按自己的场景，用这些子类执行某些方法之类的了

整体依旧是 多态 的利用，通过这种方式其实避免了 手动 new 实现类的过程，例如

Map map = new HashMap();
Map map1 = new Hashtable();
1
2

以上我们都通过 new 子实现类，声明依旧使用父类

实际上上方案例的使用我们可以再看下

myHandlerFactory 依旧获取的是子类，前方也依旧是父类声明 整体依旧是多态的体现