SpringBoot基础篇Bean之动态注册

时间 2019-11-06

标签 springboot 基础 bean 动态注册栏目 Spring 繁體版

原文原文链接

更多Spring文章，欢迎点击一灰灰Blog-Spring专题java

Spring中的Bean除了前面提到的几种JavaConfig或者@Component等注解标识以外，也是能够动态的向Spring容器注册的，本篇博文将主要介绍git

如何向Spring容器注册Bean
如何引用主动注册的Bean
注册的Bean中，若是依赖其余的Bean，怎么操做

github

I. 手动注册Bean方式

1. 核心实现类

之前也写过关于动态注册Bean的博文，如 180804-Spring之动态注册beanspring

咱们的实现方式和上面也没什么区别，依然是借助BeanDefinition来建立Bean定义并注册到BeanFactory中，具体实现的核心代码以下app

public class ManualRegistBeanUtil {

     /**
     * 主动向Spring容器中注册bean
     *
     * @param applicationContext Spring容器
     * @param name               BeanName
     * @param clazz              注册的bean的类性
     * @param args               构造方法的必要参数，顺序和类型要求和clazz中定义的一致
     * @param <T>
     * @return 返回注册到容器中的bean对象
     */
    public static <T> T registerBean(ConfigurableApplicationContext applicationContext, String name, Class<T> clazz,
            Object... args) {
        if(applicationContext.containsBean(name)) {
            Object bean = applicationContext.getBean(name);
            if (bean.getClass().isAssignableFrom(clazz)) {
                return (T) bean;
            } else {
                throw new RuntimeException("BeanName 重复 " + name);
            }
        }


        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(clazz);
        for (Object arg : args) {
            beanDefinitionBuilder.addConstructorArgValue(arg);
        }
        BeanDefinition beanDefinition = beanDefinitionBuilder.getRawBeanDefinition();

        BeanDefinitionRegistry beanFactory = (BeanDefinitionRegistry) applicationContext.getBeanFactory();
        beanFactory.registerBeanDefinition(name, beanDefinition);
        return applicationContext.getBean(name, clazz);
    }
}

上面惟一的方法中，接收四个参数，源码中也有说明，稍微须要注意下的是Spring容器中不容许出现同名的Bean框架

2. 测试用例

动态建立Bean，并非塞入容器之中就完结了，塞进去以后，是为了后续的使用，天然而然的就会有下面几种情形dom

a. 无其余Bean依赖

即不依赖其余的Bean, 单纯的供其余地方使用，这种状况下，主要须要测试的就是别人能够经过什么方式来使用它ide

@Slf4j
public class ManualBean {

    private int id;

    public ManualBean() {
        Random random = new Random();
        id = random.nextInt(100);
    }

    public String print(String msg) {
        return "[ManualBean] print : " + msg + " id: " + id;
    }
}

b. 依赖其余Bean

和前面一个不一样，这个Bean内部须要注入其余的Bean，所以咱们主动注册Bean时，可否将依赖的Bean也注入进去呢？spring-boot

定义一个测试Beanpost

@Slf4j
public class ManualDIBean {

    private int id;

    @Autowired
    private OriginBean originBean;

    private String name;

    public ManualDIBean(String name) {
        Random random = new Random();
        this.id = random.nextInt(100);
        this.name = name;
    }

    public String print(String msg) {
        String o = originBean.print(" call by ManualDIBean! ");
        return "[ManualDIBean] print: " + msg + " id: " + id + " name: " + name + " originBean print:" + o;
    }
}

其依赖的普通Bean定义以下

@Slf4j
@Component
public class OriginBean {

    private LocalDateTime time;

    public OriginBean() {
        time = LocalDateTime.now();
    }

    public String print(String msg) {
        return "[OriginBean] print msg: " + msg + ", time: " + time;
    }
}

c. 普通Bean依赖主动注册的Bean

这个其实就是使用case了，主动注册的Bean也是被人使用的，那能够怎么使用呢？传统的Autowired能否？

@Slf4j
@Component
public class AnoOriginBean {
    // 但愿能够注入 主动注册的Bean
    @Autowired
    private ManualBean manualBean;

    public AnoOriginBean() {
        System.out.println("AnoOriginBean init: " + System.currentTimeMillis());
    }

    public String print() {
        return "[AnoOriginBean] print！！！ manualBean == null ? " + (manualBean == null);
    }
}

d. Bean注册实现

前面定义了两个须要手动注册的bean，因此就须要选择一个合适的地方来处理主动注册的逻辑，咱们把这段逻辑放在AutoConfig中，用于测试演示

@Configuration
public class BeanRegisterAutoConf {

    public BeanRegisterAutoConf(ApplicationContext applicationContext) {
        System.out.println("BeanRegisterAutoConf init: " + System.currentTimeMillis());
        registerManualBean((ConfigurableApplicationContext) applicationContext);
    }

    /**
     * 手动注册自定义地bean
     * @param applicationContext
     */
    private void registerManualBean(ConfigurableApplicationContext applicationContext) {
        // 主动注册一个没什么依赖的Bean
        ManualBean manualBean = ManualRegistBeanUtil.registerBean(applicationContext, "manualBean", ManualBean.class);
        manualBean.print("test print manualBean");

        // manualDIBean 内部，依赖由Spring容器建立的OriginBean
        ManualDIBean manualDIBean = ManualRegistBeanUtil.registerBean(applicationContext, "manualDIBean",
                ManualDIBean.class, "依赖OriginBean的自定义Bean");
        manualDIBean.print("test print manualDIBean");
    }
}

3. 实测演示

前面的测试case都准备好了，接着就须要实际的跑一下看看效果了，选择Rest服务来演示，建立一个简单的Controller

@RestController
public class ShowController {

    @Autowired
    private ManualBean manualBean;
    @Autowired
    private ManualDIBean manualDIBean;
    @Autowired
    private AnoOriginBean anoOriginBean;

    public ShowController() {
        System.out.println("ShowController init: " + System.currentTimeMillis());
    }

    @GetMapping(path = "show")
    public String show(String msg) {
        Map<String, String> result = new HashMap<>(8);
        result.put("manualBean", manualBean == null ? "null" : manualBean.print(msg));
        result.put("manualDIBean", manualDIBean == null ? "null" : manualDIBean.print(msg));
        result.put("anoOriginBean",anoOriginBean.print());
        return JSONObject.toJSONString(result);
    }
}

上面就使用了三个Bean，两个主动注册的外加一个依赖了主动注册Bean的anoOriginBean (其实Controller自己也是一个使用主动注册Bean的Bean）

先预测一下结果：

若是 manualBean, manualDIBean 为空，表示不能直接经过 @Autowired 注解的方式引入手动注册的Bean；此时会抛npe
若是没有npe，且 AnoOriginBean内部依赖的manualBean也不是null，则表示直接用@Autowired来注入没啥毛病（是否绝对呢？）
manualDIBean 内部依赖了originBean，也是经过注解方式注入，若是正常返回，表示手动注册的也能够这么引用其余的Bean；不然不行

执行结果如上图，简单来讲，就是手动注册的Bean，和咱们通常使用的Bean也没什么两样，原来能够怎么用，如今依然能够这么用

II. BeanDefinitionRegistryPostProcessor扩展方式

前面这种手动注入的方式有个很差的地方就是主动注册的这个逻辑，感受写在什么地方都不太优雅，在Spring项目的源码中经过实现BeanDefinitionRegistryPostProcessor扩展方式接口的方式比较多，好比org.springframework.cloud.autoconfigure.RefreshAutoConfiguration

依葫芦画瓢实现一个

1. 实现类

@Slf4j
@Configuration
public class AutoBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {
    @Override
    public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
        // 注册Bean定义，容器根据定义返回bean

        //构造bean定义
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder
                .genericBeanDefinition(AutoBean.class);
        BeanDefinition beanDefinition = beanDefinitionBuilder.getRawBeanDefinition();
        //注册bean定义
        registry.registerBeanDefinition("autoBean", beanDefinition);


        // AutoDIBean 的注入方式
        beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(AutoDIBean.class);
        beanDefinitionBuilder.addConstructorArgValue("自动注入依赖Bean");
        beanDefinition = beanDefinitionBuilder.getBeanDefinition();
        registry.registerBeanDefinition("autoDiBean", beanDefinition);
    }

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory factory) throws BeansException {
        // 注册Bean实例，使用supply接口, 能够建立一个实例，并主动注入一些依赖的Bean；当这个实例对象是经过动态代理这种框架生成时，就比较有用了

        BeanDefinitionBuilder builder = BeanDefinitionBuilder.genericBeanDefinition(AutoFacDIBean.class, () -> {
            AutoFacDIBean autoFacDIBean = new AutoFacDIBean("autoFac");
            autoFacDIBean.setAutoBean(factory.getBean("autoBean", AutoBean.class));
            autoFacDIBean.setOriginBean(factory.getBean("originBean", OriginBean.class));
            return autoFacDIBean;
        });
        BeanDefinition beanDefinition = builder.getRawBeanDefinition();
        ((DefaultListableBeanFactory) factory).registerBeanDefinition("autoFacDIBean", beanDefinition);
    }
}

接口的实现中，Bean的注册方式和前面的实际上是同样的，这个接口提供了两个方法，一般实现第一个方法来作Bean的注册；二者从根本上也没太大的区别，上面只是给出了一种使用演示

2. 测试用例

测试的思路基本上和前面同样，定义了三个须要咱们注册的Bean，一个没有外部依赖的AutoBean

public class AutoBean {

    public String print() {
        return "[AutoBean] " + System.currentTimeMillis();
    }
}

一个依赖外部Bean的AutoDIBean

public class AutoDIBean {

    private String name;

    @Autowired
    private OriginBean originBean;

    public AutoDIBean(String name) {
        this.name = name;
    }

    public String print() {
        return "[AutoDIBean] " + name + " originBean == null ? " + (originBean == null);
    }

}

一个用于主动建立和设置依赖的AutoFacDIBean （用于前面的实现类中的第二个方法的注册方式）

public class AutoFacDIBean {
    private String name;

    @Setter
    private OriginBean originBean;

    @Setter
    private AutoBean autoBean;

    public AutoFacDIBean(String name) {
        this.name = name;
    }

    public String print() {
        return "[AutoDIBean] " + name + " originBean == null ? " + (originBean == null) + " | autoBean==null ? " +
                (autoBean == null);
    }

}

一个依赖了主动注册AutoBean的 AnoAutoOriginBean

@Component
public class AnoAutoOriginBean {
    @Autowired
    private AutoBean autoBean;

    public AnoAutoOriginBean() {
        System.out.println("AnoAutoOriginBean init: " + System.currentTimeMillis());
    }

    public String print() {
        return "[AnoAutoOriginBean] print！！！ autoBean == null ? " + (autoBean == null);
    }
}

3. 实测演示

一样写一个RestApi进行演示，经过实际的演示结果发现和前面没什么太大的区别

@Autowired
private AutoBean autoBean;
@Autowired
private AutoDIBean autoDIBean;
@Autowired
private AutoFacDIBean autoFacDIBean;
@Autowired
private AnoAutoOriginBean anoAutoOriginBean;
@GetMapping(path = "auto")
public String autoShow() {
    Map<String, String> result = new HashMap<>(8);
    result.put("autoBean", autoBean == null ? "null" : autoBean.print());
    result.put("manualDIBean", autoDIBean == null ? "null" : autoDIBean.print());
    result.put("autoFacDIBean",autoFacDIBean == null ? "null" : autoFacDIBean.print());
    result.put("anoAutoOriginBean",anoAutoOriginBean.print());
    return JSONObject.toJSONString(result);
}

III. 其余

0. 相关

a. 文档

b. 源码

工程：spring-boot-demo
model: 006-dynamicbean

1. 一灰灰Blog

一灰灰Blog我的博客 https://blog.hhui.top
一灰灰Blog-Spring专题博客 http://spring.hhui.top

一灰灰的我的博客，记录全部学习和工做中的博文，欢迎你们前去逛逛

2. 声明

尽信书则不如，以上内容，纯属一家之言，因我的能力有限，不免有疏漏和错误之处，如发现bug或者有更好的建议，欢迎批评指正，不吝感激

微博地址: 小灰灰Blog
QQ：一灰灰/3302797840

3. 扫描关注

一灰灰blog

知识星球