咨询热线 ：
028-86922220
×
01
关于我们

公司简介

发展历程

02
服务项目

高端网站建设

微信开发

APP开发

网络营销服务

电商网站定制

生物医药网站建设

外贸网站建设

教育培训网站建设

03
小程序开发

小程序开发

功能应用

客户案例

04
案例展示

网站建设案例

小程序案例

电商平台案例

APP案例

系统平台案例

05
建站动态

网站建设

网站设计

网站营销

小程序

06
联系我们

公司地址

人才招聘

地址：成都市太升南路288号锦天国际A幢1002号

电话：028-86922220

028-86922220

大橙子网站建设，新征程启航

为企业提供网站建设、域名注册、服务器等服务

Spring初始化Bean的使用方法

本篇内容主要讲解“Spring初始化Bean的使用方法”，感兴趣的朋友不妨来看看。本文介绍的方法操作简单快捷，实用性强。下面就让小编来带大家学习“Spring初始化Bean的使用方法”吧!

创新互联主要从事成都网站建设、成都网站制作、网页设计、企业做网站、公司建网站等业务。立足成都服务长子,十余年网站建设经验,价格优惠、服务专业,欢迎来电咨询建站服务:18980820575

1、记录创建bean的ObjectFactory，目的是为了解决循环依赖

if (instanceWrapper == null) {
   //上一篇bean的加载后部分主要分析了bean的创建,此步骤完成之后bean已经创建完成,但属性还没有赋值,Spring
   //解决循环依赖的关键步骤就在此步骤完成之后,bean已创建但还没有属性赋值,如下图
   instanceWrapper = createBeanInstance(beanName, mbd, args);
}
如下图,以最简单的AB循环依赖为例,A中有属性类B,B中又有属性类A,那么初始化beanA的过程如下图.

Spring初始化Bean的使用方法

//上图中addSingletonFactory逻辑,只有是单例的,允许循环依赖且该bean正在创建中(创建时会记录该属性,创建完成会移除该属性),
//只有三个条件都满足才会addSingletonFactory
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences
                                                    && isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
   //为避免后期循环依赖,可以在bean初始化后属性赋值之前将创建实例的ObjectFactory加入工厂
   addSingletonFactory(beanName, new ObjectFactory() {
      public Object getObject() throws BeansException {
         return getEarlyBeanReference(beanName, mbd, bean);
      }
   });
}
protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory) {
   Assert.notNull(singletonFactory, "Singleton factory must not be null");
   synchronized (this.singletonObjects) {
      if (!this.singletonObjects.containsKey(beanName)) {
         //放入map中
         this.singletonFactories.put(beanName, singletonFactory);
         //目的是检测循环引用,移除
         this.earlySingletonObjects.remove(beanName);
         this.registeredSingletons.add(beanName);
      }
   }
}
//我们熟知的AOP就是在这里将advice动态织如bean中,若没有则直接返回bean
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
   Object exposedObject = bean;
   if (bean != null && !mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
            SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
            exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
            if (exposedObject == null) {
               return exposedObject;
            }
         }
      }
   }
   return exposedObject;
}
2、属性注入
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
   BeanWrapper instanceWrapper = null;
 
   if (instanceWrapper == null) {
   //1.创建bean,但还没有属性赋值
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }
   //2.条件满足的话讲ObjectFactory放入map中,为了解决循环依赖
   addSingletonFactory(beanName, new ObjectFactory() {
         public Object getObject() throws BeansException {
            return getEarlyBeanReference(beanName, mbd, bean);
         }
   });
   
   Object exposedObject = bean;
   try {
      //3.属性赋值
      populateBean(beanName, mbd, instanceWrapper);
      if (exposedObject != null) {
      //4.调用一系列初始化方法
         exposedObject = initializeBean(beanName, exposedObject, mbd);
      }
   }

   return exposedObject;
}
//之前已经分析了步骤1创建bean和步骤2添加ObjectFactory，现在来分析属性赋值populateBean。
protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {
   //读取配置文件,解析标签之后,此处的pvs已经有值了,就是配置文件中配置的lwh sayHello
   PropertyValues pvs = mbd.getPropertyValues();

   if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
         mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
      MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

      //根据名称自动注入
      if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
         autowireByName(beanName, mbd, bw, newPvs);
      }
      
      //根据类型自动注入
      if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
         autowireByType(beanName, mbd, bw, newPvs);
      }

      pvs = newPvs;
   }
   
   //属性赋值
   applyPropertyValues(beanName, mbd, bw, pvs);
}
protected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

   //寻找bw中需要依赖注入的属性,若是配置文件中配置了person属性,则此处查出来的propertyNames为空
   //因为配置文件中配置了name为person的bean,此处查找出来的propertyNames封装的就是person,若是将配置文
   //件中autowire改为byType程序也可以正常运行;若将配置的person的id改为其他的,则byName不能正常运行,而
   //byType可以正常运行
   String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
   for (String propertyName : propertyNames) {
      if (containsBean(propertyName)) {
         //递归初始化相关的bean,此处为person
         Object bean = getBean(propertyName);
         //加到pvs属性中
         pvs.add(propertyName, bean);
         registerDependentBean(propertyName, beanName);
      }
   }
}
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {

   MutablePropertyValues mpvs = null;
   List original;

   if (pvs instanceof MutablePropertyValues) {
      mpvs = (MutablePropertyValues) pvs;
      if (mpvs.isConverted()) {
         try {
            bw.setPropertyValues(mpvs);
            return;
         }
      }
      original = mpvs.getPropertyValueList();
   }
   else {
      original = Arrays.asList(pvs.getPropertyValues());
   }
   TypeConverter converter = getCustomTypeConverter();
   if (converter == null) {
      converter = bw;
   }
   BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

   List deepCopy = new ArrayList(original.size());
   boolean resolveNecessary = false;
   for (PropertyValue pv : original) {
      if (pv.isConverted()) {
         deepCopy.add(pv);
      }
      else {
         String propertyName = pv.getName();
         Object originalValue = pv.getValue();
         Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
         Object convertedValue = resolvedValue;
         boolean convertible = bw.isWritableProperty(propertyName) &&
               !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
         if (convertible) {
            convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
         }
        
         if (resolvedValue == originalValue) {
            if (convertible) {
               pv.setConvertedValue(convertedValue);
            }
            deepCopy.add(pv);
         }
         else if (convertible && originalValue instanceof TypedStringValue &&
               !((TypedStringValue) originalValue).isDynamic() &&
               !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
            pv.setConvertedValue(convertedValue);
            deepCopy.add(pv);
         }
         else {
            resolveNecessary = true;
            deepCopy.add(new PropertyValue(pv, convertedValue));
         }
      }
   }
   if (mpvs != null && !resolveNecessary) {
      mpvs.setConverted();
   }
   try {
      //赋值核心代码,此步骤完成之后,bean中的属性就被赋值了
      bw.setPropertyValues(new MutablePropertyValues(deepCopy));
   }
}
3、调用一系列初始化方法
//分析完了属性赋值populateBean方法,然后分析一系列初始化方法
//属性赋值
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
   //调用初始化方法
   exposedObject = initializeBean(beanName, exposedObject, mbd);
}

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
    //1.激活Aware方法
   invokeAwareMethods(beanName, bean);

   Object wrappedBean = bean;
   if (mbd == null || !mbd.isSynthetic()) {
      //2.执行BeanPostProcessor的before方法
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
   }
   try {
      //3.激活用户定义的初始化方法,包括接口InitializingBean中的初始化方法和用户配置的init-method
      invokeInitMethods(beanName, wrappedBean, mbd);
   }
   if (mbd == null || !mbd.isSynthetic()) {
      //4.执行BeanPostProcessor的after方法
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
   }
   return wrappedBean;
}
步骤1：激活Aware方法
private void invokeAwareMethods(final String beanName, final Object bean) {
   if (bean instanceof Aware) {
      if (bean instanceof BeanNameAware) {
         ((BeanNameAware) bean).setBeanName(beanName);
      }
      if (bean instanceof BeanClassLoaderAware) {
         ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
      }
      if (bean instanceof BeanFactoryAware) {
         //附录1中的类实现了BeanFactoryAware接口,因此会调用该方法,输出注入容器BeanFactroy
         ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
      }
   }
}
步骤2：执行BeanPostProcessor的before方法
ConfigurableBeanFactory bf = new XmlBeanFactory(new ClassPathResource("beanFactory.xml"));
//BeanFactory要手动注册BeanPostProcessor,而ApplicationContext会手动检测
bf.addBeanPostProcessor(new MyTestBean());
bf.getBean("myTestBean", MyTestBean.class);
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName){

   Object result = existingBean;
   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
      //调用这边会输出我是MyTestBean的postProcessBeforeInitialization方法
      result = beanProcessor.postProcessBeforeInitialization(result, beanName);
      if (result == null) {
         return result;
      }
   }
   return result;
}
步骤3：激活用户的初始化方法
protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd){

   boolean isInitializingBean = (bean instanceof InitializingBean);
   //删去了部分代码
   if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
       //调用InitializingBean接口中定义的初始化方法
      ((InitializingBean) bean).afterPropertiesSet();
   }
   if (mbd != null) {
      //配置文件init-method中配置的初始化方法
      String initMethodName = mbd.getInitMethodName();
      if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
            !mbd.isExternallyManagedInitMethod(initMethodName)) {
         //底层使用反射调用初始化方法
         invokeCustomInitMethod(beanName, bean, mbd);
      }
   }
}
步骤4：执行BeanPostProcessor的after方法
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName){

   Object result = existingBean;
   for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
      result = beanProcessor.postProcessAfterInitialization(result, beanName);
      if (result == null) {
         return result;
      }
   }
   return result;
}
附录
1、根据名称注入例子
public class MyTestBean implements BeanFactoryAware, BeanPostProcessor, InitializingBean, 
                                                                        DestructionAwareBeanPostProcessor{

    private BeanFactory beanFactory;

    private Person person;

    public Person getPerson() {
        return person;
    }

    public void setPerson(Person person) {
        this.person = person;
    }

    private String testStr = "xbx";

    public String getTestStr() {
        return testStr;
    }

    public void setTestStr(String testStr) {
        this.testStr = testStr;
    }

    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        System.out.println("注入容器BeanFactory");
        this.beanFactory = beanFactory;
    }

    public void init(){
        System.out.println("我是MyTestBean的初始化方法");
    }

    public void destroy(){
        System.out.println("我是MyTestBean的销毁方法");
    }

    public Object postProcessBeforeInitialization(Object bean, String beanName){
        System.out.println("我是MyTestBean的postProcessBeforeInitialization方法");
        return null;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName){
        System.out.println("我是MyTestBean的postProcessAfterInitialization方法");
        return null;
    }

    public void afterPropertiesSet() throws Exception {
        System.out.println("我是MyTestBean的自定义的初始化方法");
    }

    public void postProcessBeforeDestruction(Object bean, String beanName){
        System.out.println("我是MyTestBean的自定义的销毁方法");
    }
}
//配置文件中只配置了testStr属性，并没有配置person属性

    



到此，相信大家对“Spring初始化Bean的使用方法”有了更深的了解，不妨来实际操作一番吧！这里是创新互联网站，更多相关内容可以进入相关频道进行查询，关注我们，继续学习！
            
            
                            

                网站标题：Spring初始化Bean的使用方法                

                文章出自：http://dzwzjz.com/article/geoeoo.html
            
        
        

            
其他资讯

            

                
            

        

    




    

        

            

                

                

                    
分享至：

                    

                        
                        
                        
                        
                    

                    
                

            

            

                

                    
关于我们

                    

                        公司简介
                        发展历程
                    

                

                

                    
服务项目

                    

                        高端网站建设
                        小程序开发
                        APP开发
                        网络营销
                    

                

                

                    
建站知识

                    

                        行业新闻
                        建站学堂
                        常见问题
                    

                

                

                    
联系我们

                    

                        公司地址
                        人才招聘
                    

                

            

            

                

                    成都
                    达州
                

                

                    

                        

                            

                            
电话：028-86922220

                        

                        

                            

                            
地址：成都市太升南路288号锦天国际A幢1002号

                        

                    

                    

                        

                            

                            
电话：028-86922220

                        

                        

                            

                            
地址：达州市南岸区弹子石腾龙大道58号2栋21-6

                        

                    

                

            

        

        

            友情链接：
            重庆网站建设   西部信息中心   成都商城网站开发   成都西云机房   成都网站设计   营销型网站   成都云服务器   小谭网创广告   手机网站制作   南充主机托管           

    

    
版权所有：青羊区大橙子信息咨询工作室
        蜀ICP备2022028542号-14
    







    
        

            

            
在线咨询

        

    
    
        

            

            
服务热线

        

        
服务热线：028-86922220

    
    
        

            

            
TOP