spring源码-bean的生命周期

最新推荐文章于 2022-04-30 08:48:46 发布

身披品如

最新推荐文章于 2022-04-30 08:48:46 发布

阅读量151

点赞数

文章标签： spring java

本文链接：https://blog.csdn.net/jinian2016/article/details/109132340

版权

架构图

在这里插入图片描述

bean的生命周期

Bean建立
将类加载到spring容器中，如@Component
生成BeanDefinition
当bean 加载到spring容器中时，会生成一个对应的BeanDefinition,用于存储该bean的信息，包括：
beanClass，scope，abstractFlag，lazyInit，autowireMode，dependencyCheck，dependsOn，autowireCandidate，primary，qualifiers，instanceSupplier，nonPublicAccessAllowed，lenientConstructorResolution，factoryBeanName，factoryMethodName …
组建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
创建bean对象
- 实例化
- 推断构造方法
- AOP
- 依赖注入
- PostConstruct
- Aware
- InitializingBean
存储到单例池中（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

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()方法

/**
 * 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;
    }
}

10.DisposableBean的destroy()

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


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

    }
}

身披品如

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
spring源码-bean的生命周期

目录bean的生命周期源码解析三级目录bean的生命周期class --> BeanDefinition --> BeanFactory组件完成 --> BeanFactoryPostProcessor --> new User() --> 填充属性 --> Aware回调 --> 初始化 --> AOP --> 单例池（Map<BeanName,对象>）首先要生成一个class根据class 生成BeanDefinition
复制链接

扫一扫