spring源码-bean的生命周期

灰太狼 2022-12-15 14:05 155阅读 0赞

### 目录 ###

*  架构图
 *  bean的生命周期
 *  源码解析
 *   *  1.实例化之前
     *   *  注册BeanDefinition
         *  bea工厂后置处理器 BeanFactoryPostProcessor
     *  2.Bean的建立：
     *  3. 属性注入：
     *  4.BeanNameAware的setBeanName()：
     *  5. BeanFactoryAware的setBeanFactory()：
     *  6. BeanPostProcessors的ProcessBeforeInitialization()
     *  7.initializingBean的afterPropertiesSet()：
     *  8. 如果BeanDefinition中的属性定义init-method：
     *  9.BeanPostProcessors的ProcessaAfterInitialization()
     *  10.DisposableBean的destroy()

# 架构图 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppbmlhbjIwMTY_size_16_color_FFFFFF_t_70_pic_center]

# bean的生命周期 #

1.  Bean建立  
    将类加载到spring容器中，如@Component
2.  生成BeanDefinition  
    当bean 加载到spring容器中时， 会生成一个对应的BeanDefinition,用于存储该bean的信息，包括：  
    beanClass，scope，abstractFlag，lazyInit，autowireMode，dependencyCheck，dependsOn，autowireCandidate，primary，qualifiers，instanceSupplier，nonPublicAccessAllowed，lenientConstructorResolution，factoryBeanName，factoryMethodName …
3.  组建BeanFactory（DefaultListableBeanFactory;）  
    该beanFactory中：
    
     *  beanDefinitionMap：存储beanDefinition（DefaultListableBeanFactory;）
    
        private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap(256);
    
     *  singletonObjects: 存储加载的bean(DefaultSingletonBeanRegistry)
    
        private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
    
     *  beanDefinitionNames :存储beanDefinition的名字列表(DefaultListableBeanFactory)
    
        private volatile List<String> beanDefinitionNames = new ArrayList(256);
    
     *  factoryBeaObjectCache
     *  aliasMap
     *  BeanPostProcessor
4.  创建bean对象
    
     *  实例化
     *  推断构造方法
     *  AOP
     *  依赖注入
     *  PostConstruct
     *  Aware
     *  InitializingBean
5.  存储到单例池中（Map<BeanName,对象>）

# 源码解析 #

org.springframework.context.support.AbstractApplicationContext.refresh()的源码：

@Override
    	public void refresh() throws BeansException, IllegalStateException { 
    		synchronized (this.startupShutdownMonitor) { 
    			// 准备上下文的刷新.
    			prepareRefresh();
    
    			// 刷新并获取bean工厂
    			ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
    
    			//准备beanFactory
    			prepareBeanFactory(beanFactory);
    
    			try { 
    				// beanFacory 后置处理器.供子类实现
    				postProcessBeanFactory(beanFactory);
    
    				// 调用上下文中注册为bean的工厂后置处理器
    				invokeBeanFactoryPostProcessors(beanFactory);
    
    				// 注册Bean后置处理器
    				registerBeanPostProcessors(beanFactory);
    
    				// Initialize message source for this context.
    				initMessageSource();
    
    				// Initialize event multicaster for this context.
    				initApplicationEventMulticaster();
    
    				// 初始化特定上下文子类中的其他特殊bean
    				onRefresh();
    
    				// 注册监听器
    				registerListeners();
    
    				// 例化所有剩余的（非延迟初始化）单例.
    				finishBeanFactoryInitialization(beanFactory);
    
    				// 发布相应事件，完成刷新
    				finishRefresh();
    			}
    
    			catch (BeansException ex) { 
    				if (logger.isWarnEnabled()) { 
    					logger.warn("Exception encountered during context initialization - " +
    							"cancelling refresh attempt: " + ex);
    				}
    
    				// 发生异常，则销毁已经实例化的bean
    				destroyBeans();
    
    				// 重置active标识
    				cancelRefresh(ex);
    
    				// Propagate exception to caller.
    				throw ex;
    			}
    
    			finally { 
    				// Reset common introspection caches in Spring's core, since we
    				// might not ever need metadata for singleton beans anymore...
    				resetCommonCaches();
    			}
    		}

## 1.实例化之前 ##

### 注册BeanDefinition ###

1.  ImportBeanDefinitionRegistrar

public class MyBeanDefinitionRegistrar implements ImportBeanDefinitionRegistrar { 
        /** */
        @Override
        public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry, BeanNameGenerator importBeanNameGenerator) { 
    
            Map<String, Object> annotationAttributes = importingClassMetadata.getAnnotationAttributes(MyAnnotationScan.class.getName());
    
            //拿到包
            Object value = annotationAttributes.get("value");
            //掃描
            System.out.println(value);
            List<Class> mappers = new ArrayList<>();
            mappers.add(UserMapper.class);
            mappers.add(OrderMapper.class);
    
            for (Class mapper : mappers) { 
                //生成一个空的beanDefinition
                BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition();
                AbstractBeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();
                beanDefinition.setBeanClass(MyFactoryBean.class);
                beanDefinition.getConstructorArgumentValues().addGenericArgumentValue(mapper);
                registry.registerBeanDefinition(mapper.getSimpleName(),beanDefinition);
            }
        }
    }

### bea工厂后置处理器 BeanFactoryPostProcessor ###

@Component
    public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor { 
        @Override
        public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException { 
    
    
            GenericBeanDefinition bd = (GenericBeanDefinition) beanFactory.getBeanDefinition("userService");
            Class<?> beanClass = bd.getBeanClass();
            Object userService = beanFactory.getBean("userService");
          /* System.out.println(beanClass); bd.setBeanClass(UserEntity.class);*/
        }
    }

## 2.Bean的建立： ##

容器寻找Bean的定义信息并将其实例化。

## 3. 属性注入： ##

使用依赖注入(IOC)，Spring按照Bean定义信息配置Bean所有属性

## 4.BeanNameAware的setBeanName()： ##

如果Bean类有实现org.springframework.beans.BeanNameAware接口，工厂调用Bean的setBeanName()方法传递Bean的ID。

/** * @author XingShuaiJiang * 可设置beanName的值 */
    @Component
    public class MyBeanNameAware implements BeanNameAware { 
        @Override
        public void setBeanName(String s) { 
    
        }
    }

## 5. BeanFactoryAware的setBeanFactory()： ##

如果Bean类有实现org.springframework.beans.factory.BeanFactoryAware接口，工厂调用setBeanFactory()方法传入工厂自身。

/** * @author * 可设置beanFactory */
    @Component
    public class MyBeanFactoryAware implements BeanFactoryAware { 
        @Override
        public void setBeanFactory(BeanFactory beanFactory) throws BeansException { 
            
        }
    }

## 6. BeanPostProcessors的ProcessBeforeInitialization() ##

如果有org.springframework.beans.factory.config.BeanPostProcessors和Bean关联，那么其postProcessBeforeInitialization()方法将被将被调用。

/** * bean创建成功后的 后置处理器 * 经常被用作是Bean内容的更改，并且由于这个是在Bean初始化结束时调用那个的方法，也可以被应用于内存或缓存技术； */
     @Component
    public class MyBeanPostProcessor implements BeanPostProcessor { 
        /** * @param bean * @param beanName * @return * @throws BeansException * 在实例化bean之前调用 */
        @Override
        public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException { 
            return null;
        }
    
        /** * @param bean * @param beanName * @return * @throws BeansException * 在实例化bean之后调用 */
        @Override
        public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException { 
            return null;
        }
    }

## 7.initializingBean的afterPropertiesSet()： ##

如果Bean类已实现org.springframework.beans.factory.InitializingBean接口，则执行他的afterProPertiesSet()方法

/** * 初始化bean */
    @Component
    class MyInitializingBean implements InitializingBean { 
        @Override
        public void afterPropertiesSet() throws Exception { 
    
        }
    }

## 8. 如果BeanDefinition中的属性定义init-method： ##

可以在Bean定义文件中使用"init-method"属性设定方法名称例如：

如果有以上设置的话，则执行到这个阶段，就会执行initBean()方法

## 9.BeanPostProcessors的ProcessaAfterInitialization() ##

如果有任何的BeanPostProcessors实例与Bean实例关联，则执行BeanPostProcessors实例的ProcessaAfterInitialization()方法

## 10.DisposableBean的destroy() ##

在容器关闭时，如果Bean类实现了org.springframework.beans.factory.DisposableBean接口，则执行它的destroy()方法。

/** * 销毁bean */
    @Component
    public class MyDisposableBean implements DisposableBean { 
        @Override
        public void destroy() throws Exception { 
    
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2ppbmlhbjIwMTY_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/8c89cc5712974b18a74fd614de84e437.png