SpringBoot基础篇Bean之动态注册

最新推荐文章于 2024-02-16 13:07:34 发布
最新推荐文章于 2024-02-16 13:07:34 发布
阅读量1.9k 收藏 4
点赞数 2
文章标签： java 测试 python
原文链接：https://my.oschina.net/u/566591/blog/2245517
版权

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

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

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

  • 如何向Spring容器注册Bean
  • 如何引用主动注册的Bean
  • 注册的Bean中，如果依赖其他的Bean，怎么操作

<!-- more -->

I. 手动注册Bean方式

1. 核心实现类

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

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

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，并不是塞入容器之中就完结了，塞进去之后，是为了后续的使用，自然而然的就会有下面几种情形

a. 无其他Bean依赖

即不依赖其他的Bean, 单纯的供其他地方使用，这种情况下，主要需要测试的就是别人可以通过什么方式来使用它

@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也注入进去呢？

定义一个测试Bean

@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. 源码

1. 一灰灰Blog

一灰灰的个人博客，记录所有学习和工作中的博文，欢迎大家前去逛逛

2. 声明

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

3. 扫描关注

一灰灰blog

QrCode

知识星球

goals

转载于:https://my.oschina.net/u/566591/blog/2245517

weixin_34197488
关注
SpringBoot基础篇之重名Bean的解决与多实例选择
weixin_34218890的博客
10-22 2545
更多Spring文章，欢迎点击 一灰灰Blog-Spring专题 当通过接口的方式注入Bean时，如果有多个子类的bean存在时，具体哪个bean会被注入呢？系统中能否存在两个重名的bean呢？如果可以，那么怎么选择引入呢？如果不行的话又该怎么避免上面的问题呢？ I. 多实例Bean的选择 这个场景可以说是比较常见的，现在提倡面向接口编程嘛，当一个接口有多个实例时，怎么注入和引用就需要我们额外...
SpringBoot基础篇Bean之条件注入@Condition使用姿势
刘成
10-25 2150
前面几篇关于Bean的基础博文中，主要集中在Bean的定义和使用，但实际的情况中有没有一些场景是不加载我定义的bean，或者只有满足某些前提条件的时候才加载我定义的Bean呢？ 本篇博文将主要介绍bean的加载中，条件注解@Conditional的相关使用 I. @Conditional注解 这个注解在Spring4中引入，其主要作用就是判断条件是否满足，从而决定是否初始化并向容器注册Bea...
Spring Boot动态注册/删除http资源路径的方法
猥琐的刚的博客
08-11 970
springboot 动态注册与删除URL
Spring-Boot-Bean之动态注册
最新发布
Java程序员的知识博客
02-16 1861
Spring中的Bean除了前面提到的几种JavaConfig或者@Component等注解标识之外，也是可以动态的向Spring容器注册的，本篇博文将主要介绍。
SpringBoot如何手动注册Bean
weixin_43535259的博客
06-26 5675
如何手动注册Bean 技术介绍BeanDefinitionRegistryPostProcessor部分上文所述实体类TestBeanTestFactory extends FactoryBean注册所用接口 TestService 技术介绍 BeanDefinitionRegistryPostProcessor部分 BeanDefinitionRegistryPostProcessor是springboot手动注册bean 的组件之一，于其相似的还有importBeanDefinitionRegistra
spring 动态注册bean实现记录
qq_40270466的博客
09-08 497
通过这种方式注入，发现进行包路径扫描时，这个路径不方便通过配置文件applicaiton.yml/properties进行配置，通过查看spring 源码发现，在调用registerBeanDefinitions 方法时，这时，获取不到配置文件中的配置信息，无法读取配置信息，还有方式就是自己定义注解时传入扫描包路径，由于想要实现自动装配，只想要在yml或properties文件中配置下包路径，即可自动去扫描查找，这种方式不符合预期；
springboot项目注册Bean的多种方法总结
sttttttuttering的博客
12-30 6958
springboot项目注册bean的几种方法总结，简单易懂~
SpringBoot基础篇--黑马
06-22
"SpringBoot基础篇--黑马" 本资源主要介绍了SpringBoot基础篇的课程大纲，旨在帮助学习者快速掌握SpringBoot技术。课程主要分为三个阶段：基础篇、应用篇和原理篇。 基础篇主要介绍了SpringBoot的基础知识，包括...
spring之动态注册bean
weixin_41979002的博客
08-06 7673
前言 一般而言，我们都知道，在启动一个spring/springboot项目时，随着ioc容器的加载，会向容器中注册许多我们在程序中已经定义好的bean，我们平时注册bean的方式如下： xml方式： <beans>//Bean定义的开始和结束 <import resource=“resource1.xml” />//导入其他配置文件Bean的定义 <import resource=“resource2.xml” /> <bean id=
Spring注册bean的几种常用方法总结
qq_43653951的博客
11-02 3074
spring中注册bean对象大概有一下几种方法: @compont,@service,@controller,@repository等 @Bean @Import @FactoryBean 第一种方式不用多说，用过spring的大概都用过，那么第二种方式应该是比较常用的。其他第三方框架与spring整合的时候一般来说少不了这个注解。@Bean功能等效于配置文件中的<bean></bean>标签 重点看一下第三个 @Import @Import，被称为springboo
SpringBoot -登录注册
热门推荐
hufiveeee的博客
04-03 1万+
SpringBoot -登录注册在前面的学习中我们学会简单创建一个springboot项目，那么现在就开始学习如何做注册登录了工具springboot +maven +hibernate+mysql 参考了https://blog.csdn.net/coder_py/article/details/781255891、项目结构  html 分为主页面index、注册register、登录login...
springboot中创建bean的7种方式
xxxzzzqqq_的博客
04-28 1619
Spring 是一款广泛应用于企业级应用程序开发的 Java 框架，其 IOC 和 DI 特性可以有效地管理应用程序中的对象，提高了应用程序的可维护性和可扩展性。那你知道spring有哪些方式将bean放入容器嘛？今天就给大家总结一下。
SpringBoot动态创建Bean
weixin_34290352的博客
01-16 559
2019独角兽企业重金招聘Python工程师标准>>> ...
由浅入深了解SpringBoot框架中的Bean注册
nextStation12138的博客
12-26 947
1.新建一个注解，组合@Import注解2.把主启动类的@Import注解替换成自定义注解，测试获取第三方实体，可以成功获取在我们引入自定义的jar过程中，一步一步优化第三方（自定义）的Bean注册方式。经历了一系列的优化，最后的bean注册方式，其实也是SpringBoot框架内部整合第三方时，用到的bean注册方式。理解了本文的Bean扫描和注册，就能理解SpringBoot的自动配置原理。下一篇文章，我将分析SpringBoot的源码，讲解SpringBoot自动配置的过程。
spring bean 的动态注册
pdw2009的专栏
10-31 592
spring bean 的动态注册
Spring 是如何造出一个 Bean 的
Meldoy_mgh的博客
10-08 380
前言 使用 Java 作为第一开发语言的朋友们，相信大家或多或少的都使用过 Spring 这个开发框架，可以说 Spring 框架真是我们 Java 程序员的春天，在 Spring 中 Bean 是其中最重要的概念之一，是学习其它高级知识的基础，Bean 说白了其实就是一个被 Spring 框架管理的对象，今天我们来看看 Bean 在 Spring 中是如何被造出来的。 1. Bean 要如何定义 假如你有如下这样的一个 Programmer 类，这个程序员类有三个属性： 姓名(name)、年龄(age)、
BeanDefinition构建示例
Leon_Jinhai_Sun的博客
11-08 438
public class BeanDefinitionCreationDemo { public static void main(String[] args) { // 1.通过 BeanDefinitionBuilder 构建 BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(User.class); // 通过属.
spring 动态创建 Bean
听雪
04-25 373
BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.rootBeanDefinition("需要创建的类"); beanDefinitionBuilder.addConstructorArgValue("构造参数"); beanFactory.registerBeanDefinition("Bean 名称",beanDefinitionBuilder.getBeanDefinition()); ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值