Spring 手动注册bean

不念不忘少年蓝@ 2021-09-21 07:18 370阅读 0赞

一般情况下，我们Spring应用中的bean都是通过注解或者xml注入到容器中的，有些情况下我们可能想手动往容器中注入bean，即编程方式注入bean。

本文所使用源码包版本：spring-beans-5.0.5.RELEASE.

## 如何注册？ ##

Spring 中用BeanDefinition接口描述一个bean，Spring容器中用Map<String, BeanDefinition> beanDefinitionMap

存储beanName和BeanDefinition对象的映射关系【beanDefinitionMap 可参考DefaultListableBeanFactory】。Spring在实例化一个bean，都是先从 beanDefinitionMap 中获取beanDefinition对象，进而构造出对应的bean。因此，我们手动注册bean的问题，就演化为如何往这个 beanDefinitionMap 放入我们要注册bean对应的 BeanDefinition 对象。

Spring 提供了 BeanDefinitionRegistry 接口来操作底层beanFactory实现的beanDefinitionMap。

**【2020-08-17】备注：推荐通过实现 BeanDefinitionRegistryPostProcessor 接口操作 BeanDefinitionRegistry：**

public interface BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor {
    
    	/**
    	 * Modify the application context's internal bean definition registry after its
    	 * standard initialization. All regular bean definitions will have been loaded,
    	 * but no beans will have been instantiated yet. This allows for adding further
    	 * bean definitions before the next post-processing phase kicks in.
    	 * @param registry the bean definition registry used by the application context
    	 * @throws org.springframework.beans.BeansException in case of errors
    	 */
    	void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException;
    
    }

## 测试示例： ##

我们有个类 H，把它手动添加到Spring 容器中成为一个bean：

public class H {
    
        private String s ;
    
        public void test(){
            System.out.println("hello world!");
        }
    
        public void setS(String s) {
            this.s = s;
        }
    }

主程序：

@EnableAspectJAutoProxy
    @ComponentScan("com.dxc.opentalk.springtest")
    public class BootStrap {
    
        public static void main(String[] args) {
            AnnotationConfigApplicationContext applicationContext
                   = new AnnotationConfigApplicationContext(BootStrap.class);
            DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) applicationContext.getBeanFactory();
            GenericBeanDefinition beanDefinition = new GenericBeanDefinition();
            beanDefinition.setBeanClass(H.class);
            beanFactory.registerBeanDefinition("h", beanDefinition);
            H h = (H) applicationContext.getBean("h");
            h.test();
        }
    }

程序运行结果：

hello world!

从容器中获取到了名称为“h”的bean，并且正确打印了方法调用结果。另外，在类H中，可以使用@Autowired注入其他已有的bean的，bean的依赖关系也是支持的。如下：

public class H {
    
        private String s ;
    
        @Autowired
        Y y;
    
        public void test(){
            y.test();
            System.out.println("hello world!");
        }
    
        public void setS(String s) {
            this.s = s;
        }
    }

H类依赖一个已有的bean Y：

@Component
    public class Y {
    
        public Y() {
            System.out.println("Construct Y");
        }
    
        public void test(){
            System.out.println("y.test()...");
        }
    }

上述测试代码输出结果：

Construct Y
    y.test()...
    hello world!

## 涉及源码： ##

### BeanDefinition 接口： ###

BeanDefinition描述了一个bean实例，该实例具有属性值，构造函数参数值以及具体实现所提供的更多信息。类图如下，主要三个实现类：RootBeanDefinition、ChildBeanDefinition 和 GenericBeanDefinition。Bean的属性，比如对应Java类的Class、作用域scope、是否延迟加载lazyInit等，都可以通过BeanDefinition控制。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMDc2MzQ1_size_16_color_FFFFFF_t_70][]

RootBeanDefinition 可以在配置阶段用于注册各个Bean定义，上面的测试用例 BeanDefinition 也可以使用 RootBeanDefinition 实现。 但是官方推荐，从Spring 2.5开始，以编程方式注册Bean定义的首选方法是\{@link GenericBeanDefinition\}类。

### BeanDefinitionRegistry 接口： ###

包含BeanDefinition的注册表的接口，例如 RootBeanDefinition 和 ChildBeanDefinition 实例。 通常由内部使用AbstractBeanDefinition层次结构的 BeanFactory 实现。

/**
    	 * Register a new bean definition with this registry.
    	 * Must support RootBeanDefinition and ChildBeanDefinition.
    	 * @param beanName the name of the bean instance to register
    	 * @param beanDefinition definition of the bean instance to register
    	 * @throws BeanDefinitionStoreException if the BeanDefinition is invalid
    	 * or if there is already a BeanDefinition for the specified bean name
    	 * (and we are not allowed to override it)
    	 * @see RootBeanDefinition
    	 * @see ChildBeanDefinition
    	 */
    	void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
    			throws BeanDefinitionStoreException;

注意用到的 registerBeanDefinition 方法，如果构造的 BeanDefinition 无效，或者指定的bean名称已经存在BeanDefinition（如果不允许覆盖它）会抛出 BeanDefinitionStoreException 异常。BeanDefinitionRegistry 还有其他的方法，比如根据bean名称移除beanDefinition的方法 removeDefinition(String beanName)等。

### DefaultListableBeanFactory 类： ###

DefaultListableBeanFactory中用Map<String,BeanDefinition> beanDefinitionMap 保存beanName和BeanDefinition对象的映射关系，同时实现了BeanDefinitionRegistry接口，用来操作beanDefinitionMap，其中 registerBeanDefinition 方法：

@Override
    	public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
    			throws BeanDefinitionStoreException {
    
    		Assert.hasText(beanName, "Bean name must not be empty");
    		Assert.notNull(beanDefinition, "BeanDefinition must not be null");
    
    		if (beanDefinition instanceof AbstractBeanDefinition) {
    			try {
                    //校验传入beanDefinition的正确性
    				((AbstractBeanDefinition) beanDefinition).validate();
    			}
    			catch (BeanDefinitionValidationException ex) {
    				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
    						"Validation of bean definition failed", ex);
    			}
    		}
    
    		BeanDefinition oldBeanDefinition;
    
    		oldBeanDefinition = this.beanDefinitionMap.get(beanName);
    		if (oldBeanDefinition != null) {
                //如果已存在该bean名称的beanDefinition，并且不允许覆盖，则抛异常
    			if (!isAllowBeanDefinitionOverriding()) {
    				throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
    						"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +
    						"': There is already [" + oldBeanDefinition + "] bound.");
    			}
    			else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
    				// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
    				if (this.logger.isWarnEnabled()) {
    					this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +
    							"' with a framework-generated bean definition: replacing [" +
    							oldBeanDefinition + "] with [" + beanDefinition + "]");
    				}
    			}
    			else if (!beanDefinition.equals(oldBeanDefinition)) {
    				if (this.logger.isInfoEnabled()) {
    					this.logger.info("Overriding bean definition for bean '" + beanName +
    							"' with a different definition: replacing [" + oldBeanDefinition +
    							"] with [" + beanDefinition + "]");
    				}
    			}
    			else {
    				if (this.logger.isDebugEnabled()) {
    					this.logger.debug("Overriding bean definition for bean '" + beanName +
    							"' with an equivalent definition: replacing [" + oldBeanDefinition +
    							"] with [" + beanDefinition + "]");
    				}
    			}
    			this.beanDefinitionMap.put(beanName, beanDefinition);
    		}
    		else {
                //检查beanFactory的bean创建阶段是否已开始,可以理解为容器是否已经初始化过了
    			if (hasBeanCreationStarted()) {
    				// Cannot modify startup-time collection elements anymore (for stable iteration)
    				synchronized (this.beanDefinitionMap) {
                        //把新加入的beanName-beanDefinition映射加入beanDefinitionMap
                        //把beanName加入的维护的beanDefinitionName列表（ArrayList）中
    					this.beanDefinitionMap.put(beanName, beanDefinition);
    					List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
    					updatedDefinitions.addAll(this.beanDefinitionNames);
    					updatedDefinitions.add(beanName);
    					this.beanDefinitionNames = updatedDefinitions;
                        //如果手动注册的单例bean名称包含了beanName，需要移除
                        //这个地方默认构造的beanDefinition对象作用域也是“”，等价于单例，但是却没有把 beanName加入到manualSingletonNames集合（LinkedHashSet）中
                        //最终beanName对应的bean实例化后，manualSingletonNames还是没有这个beanName，略奇怪。。。
    					if (this.manualSingletonNames.contains(beanName)) {
    						Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames);
    						updatedSingletons.remove(beanName);
    						this.manualSingletonNames = updatedSingletons;
    					}
    				}
    			}
    			else {
    				// Still in startup registration phase
    				this.beanDefinitionMap.put(beanName, beanDefinition);
    				this.beanDefinitionNames.add(beanName);
    				this.manualSingletonNames.remove(beanName);
    			}
    			this.frozenBeanDefinitionNames = null;
    		}
            //如果oldBeanDefinition不为null，且单例池缓存中已经有beanName对应的bean，则重置给定bean的所有bean定义缓存，包括从其派生的bean的缓存。
    		if (oldBeanDefinition != null || containsSingleton(beanName)) {
    			resetBeanDefinition(beanName);
    		}
    	}

### SingletonBeanRegistry 接口： ###

SingletonBeanRegister接口，是单例bean的管理接口，也可以用来注册单例bean，方法：

void registerSingleton(String beanName, Object singletonObject);

DefaultListableBeanFactory类也实现了该接口，我们可以将上面的测试代码修改下，也可以达到注册一个单例bean的目的：

@EnableAspectJAutoProxy
    @ComponentScan("com.dxc.opentalk.springtest")
    public class BootStrap {
    
        public static void main(String[] args) {
            AnnotationConfigApplicationContext applicationContext
                   = new AnnotationConfigApplicationContext(BootStrap.class);
            DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory) applicationContext.getBeanFactory();
            beanFactory.registerSingleton("h", new H());
            H h = (H) applicationContext.getBean("h");
            h.test();
        }
    }

实现起来简单，但是有限制：一是bean依赖项不好处理；二是待注入的实例应该被完全初始化，注册表不会执行任何初始化回调方法，比如InitializingBean的\{@code afterPropertiesSet\}方法等；。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIyMDc2MzQ1_size_16_color_FFFFFF_t_70]: /images/20210920/a21855ab1b4540dcbc013ba5e2167d66.png