Spring 容器的 refresh()[创建刷新]
1,prepareRefresh() 刷新前的预处理
1),initPropertySources() 初始化一些属性设置; 子类自定义个性化的属性设置方法;
2),getEnvironment().validateRequiredProperties(); 检验属性的合法等
3),earlyApplicationEvents= new LinkedHashSet<ApplicationEvent>(); 保存容器中的一些早期的事件;
2,obtainFreshBeanFactory(); 获取 BeanFactory;
1),refreshBeanFactory(); 刷新 [创建] BeanFactory;
创建了一个 this.beanFactory = new DefaultListableBeanFactory(); 设置 id;
2),getBeanFactory(); 返回刚才 GenericApplicationContext 创建的 BeanFactory 对象;
3), 将创建的 BeanFactory[DefaultListableBeanFactory] 返回;
3,prepareBeanFactory(beanFactory);BeanFactory 的预准备工作 (BeanFactory 进行一些设置);
1), 设置 BeanFactory 的类加载器, 支持表达式解析器...
2), 添加部分 BeanPostProcessor[ApplicationContextAwareProcessor]
3), 设置忽略的自动装配的接口 EnvironmentAware,EmbeddedValueResolverAware,xxx;
4), 注册可以解析的自动装配; 我们能直接在任何组件中自动注入: BeanFactory,ResourceLoader,ApplicationEventPublisher,ApplicationContext
5), 添加 BeanPostProcessor[ApplicationListenerDetector]
6), 添加编译时的 AspectJ;
7), 给 BeanFactory 中注册一些能用的组件;
- environment[ConfigurableEnvironment] ,systemProperties[Map<String, Object>] ,systemEnvironment[Map<String, Object>]
- 4,postProcessBeanFactory(beanFactory)
BeanFactory 准备工作完成后进行的后置处理工作;
1), 子类通过重写这个方法来在 BeanFactory 创建并预准备完成以后做进一步的设置
====================== 以上是 BeanFactory 的创建及预准备工作 ==================================
5,invokeBeanFactoryPostProcessors(beanFactory)----- 执行 BeanFactoryPostProcessor 的方法
BeanFactoryPostProcessor:BeanFactory 的后置处理器. 在 BeanFactory 标准初始化之后执行的;
两个接口: BeanFactoryPostProcessor,BeanDefinitionRegistryPostProcessor
1), 执行 BeanFactoryPostProcessor 的方法;
先执行 BeanDefinitionRegistryPostProcessor
1), 获取所有的 BeanDefinitionRegistryPostProcessor;
2), 看先执行实现了 PriorityOrdered 优先级接口的 BeanDefinitionRegistryPostProcessor,
postProcessor.postProcessBeanDefinitionRegistry(registry)
3), 在执行实现了 Ordered 顺序接口的 BeanDefinitionRegistryPostProcessor;
postProcessor.postProcessBeanDefinitionRegistry(registry)
4), 最后执行没有实现任何优先级或者是顺序接口的 BeanDefinitionRegistryPostProcessors;
postProcessor.postProcessBeanDefinitionRegistry(registry)
2), 再执行 BeanFactoryPostProcessor 的方法
1), 获取所有的 BeanFactoryPostProcessor
2), 看先执行实现了 PriorityOrdered 优先级接口的 BeanFactoryPostProcessor,
postProcessor.postProcessBeanFactory()
3), 在执行实现了 Ordered 顺序接口的 BeanFactoryPostProcessor;
postProcessor.postProcessBeanFactory()
4), 最后执行没有实现任何优先级或者是顺序接口的 BeanFactoryPostProcessor;
postProcessor.postProcessBeanFactory()
6,registerBeanPostProcessors(beanFactory)----- 注册 BeanPostProcessor(Bean 的后置处理器)[ intercept bean creation]
不同接口类型的 BeanPostProcessor; 在 Bean 创建前后的执行时机是不一样的
BeanPostProcessor,DestructionAwareBeanPostProcessor,InstantiationAwareBeanPostProcessor,SmartInstantiationAwareBeanPostProcessor,MergedBeanDefinitionPostProcessor[internalPostProcessors] ,
1), 获取所有的 BeanPostProcessor; 后置处理器都默认可以通过 PriorityOrdered,Ordered 接口来执行优先级
2), 先注册 PriorityOrdered 优先级接口的 BeanPostProcessor; 把每一个 BeanPostProcessor; 添加到 BeanFactory 中 beanFactory.addBeanPostProcessor(postProcessor);
3), 再注册 Ordered 接口的
4), 最后注册没有实现任何优先级接口的
5), 最终注册 MergedBeanDefinitionPostProcessor;
6), 注册一个 ApplicationListenerDetector; 来在 Bean 创建完成后检查是否是 ApplicationListener, 如果是 applicationContext.addApplicationListener((ApplicationListener<?>) bean);
7,initMessageSource(); 初始化 MessageSource 组件 (做国际化功能; 消息绑定, 消息解析)
1), 获取 BeanFactory
2), 看容器中是否有 id 为 messageSource 的, 类型是 MessageSource 的组件; 如果有赋值给 messageSource, 如果没有自己创建一个 DelegatingMessageSource;
MessageSource: 取出国际化配置文件中的某个 key 的值; 能按照区域信息获取;
3), 把创建好的 MessageSource 注册在容器中, 以后获取国际化配置文件的值的时候, 可以自动注入 MessageSource;
- beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
- MessageSource.getMessage(String code, Object[] args, String defaultMessage, Locale locale);
8,initApplicationEventMulticaster(); 初始化事件派发器;
1), 获取 BeanFactory
2), 从 BeanFactory 中获取 applicationEventMulticaster 的 ApplicationEventMulticaster;
3), 如果上一步没有配置; 创建一个 SimpleApplicationEventMulticaster
4), 将创建的 ApplicationEventMulticaster 添加到 BeanFactory 中, 以后其他组件直接自动注入
9,onRefresh(); 留给子容器 (子类)
1, 子类重写这个方法, 在容器刷新的时候可以自定义逻辑;
10,registerListeners(); 给容器中将所有项目里面的 ApplicationListener 注册进来;
1, 从容器中拿到所有的 ApplicationListener
2, 将每个监听器添加到事件派发器中;
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
3, 派发之前步骤产生的事件;
11,finishBeanFactoryInitialization(beanFactory); 初始化所有剩下的单实例 bean;
1,beanFactory.preInstantiateSingletons(); 初始化后剩下的单实例 bean1), 获取容器中的所有 Bean, 依次进行初始化和创建对象 2), 获取 Bean 的定义信息; RootBeanDefinition3),Bean 不是抽象的, 是单实例的, 不是懒加载; 1), 判断是否是 FactoryBean; 是否是实现 FactoryBean 接口的 Bean;2), 不是工厂 Bean. 利用 getBean(beanName); 创建对象, getBean(beanName); IoC.getBean();
,doGetBean(name, null, null, false);2, 先获取缓存中保存的单实例 Bean. 如果能获取到说明这个 Bean 之前被创建过 (所有创建过的单实例 Bean 都会被缓存起来) 从 private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256); 获取的 3, 缓存中获取不到, 开始 Bean 的创建对象流程; 4, 标记当前 bean 已经被创建 5, 获取 Bean 的定义信息; 6,[获取当前 Bean 依赖的其他 Bean; 如果有按照 getBean() 把依赖的 Bean 先创建出来;]7, 启动单实例 Bean 的创建流程; 1),createBean(beanName, mbd, args);2),Object bean = resolveBeforeInstantiation(beanName, mbdToUse); 让 BeanPostProcessor 先拦截返回代理对象;[InstantiationAwareBeanPostProcessor] : 提前执行; 先触发: postProcessBeforeInstantiation(); 如果有返回值: 触发 postProcessAfterInitialization();3), 如果前面的 InstantiationAwareBeanPostProcessor 没有返回代理对象; 调用 4)4),Object beanInstance = doCreateBean(beanName, mbdToUse, args); 创建 Bean1),[创建 Bean 实例] ;createBeanInstance(beanName, mbd, args); 利用工厂方法或者对象的构造器创建出 Bean 实例; 2),applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName); 调用 MergedBeanDefinitionPostProcessor 的 postProcessMergedBeanDefinition(mbd, beanType, beanName);3),[Bean 属性赋值] populateBean(beanName, mbd, instanceWrapper); 赋值之前: 1), 拿到 InstantiationAwareBeanPostProcessor 后置处理器; postProcessAfterInstantiation();2), 拿到 InstantiationAwareBeanPostProcessor 后置处理器; postProcessPropertyValues();===== 赋值之前:===3), 应用 Bean 属性的值; 为属性利用 setter 方法等进行赋值; applyPropertyValues(beanName, mbd, bw, pvs);4),[Bean 初始化] initializeBean(beanName, exposedObject, mbd);1),[执行 Aware 接口方法] invokeAwareMethods(beanName, bean); 执行 xxxAware 接口的方法 BeanNameAware\BeanClassLoaderAware\BeanFactoryAware2),[执行后置处理器初始化之前] applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);BeanPostProcessor.postProcessBeforeInitialization();3),[执行初始化方法] invokeInitMethods(beanName, wrappedBean, mbd);1), 是否是 InitializingBean 接口的实现; 执行接口规定的初始化; 2), 是否自定义初始化方法; 4),[执行后置处理器初始化之后] applyBeanPostProcessorsAfterInitializationBeanPostProcessor.postProcessAfterInitialization();5), 注册 Bean 的销毁方法; 5), 将创建的 Bean 添加到缓存中 singletonObjects;IoC 容器就是这些 Map; 很多的 Map 里面保存了单实例 Bean, 环境信息....; 所有 Bean 都利用 getBean 创建完成以后; 检查所有的 Bean 是否是 SmartInitializingSingleton 接口的; 如果是; 就执行 afterSingletonsInstantiated();
12,finishRefresh(); 完成 BeanFactory 的初始化创建工作; IoC 容器就创建完成;
1),initLifecycleProcessor(); 初始化和生命周期有关的后置处理器; LifecycleProcessor
默认从容器中找是否有 lifecycleProcessor 的组件 [LifecycleProcessor] ; 如果没有 new DefaultLifecycleProcessor();
加入到容器;
写一个 LifecycleProcessor 的实现类, 可以在 BeanFactory
- void onRefresh();
- void onClose();
- 2), getLifecycleProcessor().onRefresh();
拿到前面定义的生命周期处理器 (BeanFactory); 回调 onRefresh();
3),publishEvent(new ContextRefreshedEvent(this)); 发布容器刷新完成事件;
4),liveBeansView.registerApplicationContext(this);
====== 总结 ===========
1),Spring 容器在启动的时候, 先会保存所有注册进来的 Bean 的定义信息;
1),xml 注册 bean;<bean>
2), 注解注册 Bean;@Service,@Component,@Bean,xxx
2),Spring 容器会合适的时机创建这些 Bean
1), 用到这个 bean 的时候; 利用 getBean 创建 bean; 创建好以后保存在容器中;
2), 统一创建剩下所有的 bean 的时候; finishBeanFactoryInitialization();
3), 后置处理器; BeanPostProcessor
1), 每一个 bean 创建完成, 都会使用各种后置处理器进行处理; 来增强 bean 的功能;
AutowiredAnnotationBeanPostProcessor: 处理自动注入
AnnotationAwareAspectJAutoProxyCreator: 来做 AOP 功能;
xxx....
增强的功能注解:
- AsyncAnnotationBeanPostProcessor
- ....
4), 事件驱动模型;
ApplicationListener; 事件监听;
ApplicationEventMulticaster; 事件派发:
来源: http://www.bubuko.com/infodetail-3112555.html