关于如何动态手动注入Spring容器中bean对象（代码实现）

末蓝、 2021-10-09 07:46 324阅读 0赞

### **一、需求产生原因：** ###

通过修改Spring容器中对象中某个属性，该对象被spring其他服务调用，可以动态实现调用方实现不同的业务逻辑。

### **二、涉及spring相关对象：** ###

1.  DefaultListableBeanFactory：IOC容器始祖

默认实现了ListableBeanFactory和BeanDefinitionRegistry接口，基于bean definition对象，是一个成熟的bean factroy。

最典型的应用是：在访问bean前，先注册所有的definition（可能从bean definition配置文件中）。使用预先建立的bean定义元数据对象，从本地的bean definition表中查询bean definition因而将不会花费太多成本。

DefaultListableBeanFactory既可以作为一个单独的beanFactory，也可以作为自定义beanFactory的父类。

### **三、关于其部分内部方法：** ###

1.getBean()：获取容器中对象

public Object getBean(String name) throws BeansException {
            return this.doGetBean(name, (Class)null, (Object[])null, false);
        }
    
        public <T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException {
            return this.doGetBean(name, requiredType, (Object[])null, false);
        }
    
        public Object getBean(String name, Object... args) throws BeansException {
            return this.doGetBean(name, (Class)null, args, false);
        }
    
        public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args) throws BeansException {
            return this.doGetBean(name, requiredType, args, false);
        }

2. removeBeanDereference()：删除bean对象定义

public void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
            Assert.hasText(beanName, "'beanName' must not be empty");
            BeanDefinition bd = (BeanDefinition)this.beanDefinitionMap.remove(beanName);
            if (bd == null) {
                if (this.logger.isTraceEnabled()) {
                    this.logger.trace("No bean named '" + beanName + "' found in " + this);
                }
    
                throw new NoSuchBeanDefinitionException(beanName);
            } else {
                if (this.hasBeanCreationStarted()) {
                    synchronized(this.beanDefinitionMap) {
                        List<String> updatedDefinitions = new ArrayList(this.beanDefinitionNames);
                        updatedDefinitions.remove(beanName);
                        this.beanDefinitionNames = updatedDefinitions;
                    }
                } else {
                    this.beanDefinitionNames.remove(beanName);
                }
    
                this.frozenBeanDefinitionNames = null;
                this.resetBeanDefinition(beanName);
            }
        }

3.registerBeanDefinition()：重新注册bean定义

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 {
                    ((AbstractBeanDefinition)beanDefinition).validate();
                } catch (BeanDefinitionValidationException var9) {
                    throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", var9);
                }
            }
    
            BeanDefinition oldBeanDefinition = (BeanDefinition)this.beanDefinitionMap.get(beanName);
            if (oldBeanDefinition != null) {
                if (!this.isAllowBeanDefinitionOverriding()) {
                    throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName + "': There is already [" + oldBeanDefinition + "] bound.");
                }
    
                if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {
                    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 {
                if (this.hasBeanCreationStarted()) {
                    synchronized(this.beanDefinitionMap) {
                        this.beanDefinitionMap.put(beanName, beanDefinition);
                        List<String> updatedDefinitions = new ArrayList(this.beanDefinitionNames.size() + 1);
                        updatedDefinitions.addAll(this.beanDefinitionNames);
                        updatedDefinitions.add(beanName);
                        this.beanDefinitionNames = updatedDefinitions;
                        if (this.manualSingletonNames.contains(beanName)) {
                            Set<String> updatedSingletons = new LinkedHashSet(this.manualSingletonNames);
                            updatedSingletons.remove(beanName);
                            this.manualSingletonNames = updatedSingletons;
                        }
                    }
                } else {
                    this.beanDefinitionMap.put(beanName, beanDefinition);
                    this.beanDefinitionNames.add(beanName);
                    this.manualSingletonNames.remove(beanName);
                }
    
                this.frozenBeanDefinitionNames = null;
            }
    
            if (oldBeanDefinition != null || this.containsSingleton(beanName)) {
                this.resetBeanDefinition(beanName);
            }
    
        }

### **四、主要实现方法** ###

方法解读

1.  先判断容器中是否包含该对象
2.  包含则删除该对象
3.  生成Bean定义生成器（BeanDefinitionBuilder），此处会默认调用该对象的无参构造方法，用于注入该实例。
4.  通过生成器生成BeadDefinition；
5.  然后设定部分BeadDefinition部分属性参数，其他默认
6.  通过方法重写初始化注入该对象
7.  工具方法

/**
         * 动态注入对象
         * @param beanName bean对象名称
         * @param beanClass bean对象class类型
         */
        private void dynamicInjectionObj(String beanName, Class<?> beanClass) {
            boolean containsBean = defaultListableBeanFactory.containsBean(beanName);
            if (containsBean) {
                defaultListableBeanFactory.removeBeanDefinition(beanName);
            }
    
            //默认使用对象的无参构造方法：此对象已经重写无参构造（此处会重新实例化一个新对象）
            BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(beanClass);
            //构造注入对象参数
            AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();
            beanDefinition.setAutowireMode(2);
            beanDefinition.setPrimary(true);
            beanDefinition.setSynthetic(true);
    //        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
            beanDefinition.setScope("singleton");
            beanDefinition.setRole(0);
    
            defaultListableBeanFactory.registerBeanDefinition(beanName, beanDefinition);
    
        }