Spring源码 浅析
Spring IOC源码流程分析
//从下面的源码 加载过程开启 分析
1. AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext(TxConfig.class);
2. public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
register(annotatedClasses);
refresh(); //进入该方法
}
//**主要对如下 12个方法 进行流程整理_文字说明_后续将整理具体流程图_并详细说明具体含义**
3. public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// Initialize message source for this context.
initMessageSource();
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
// Initialize other special beans in specific context subclasses.
onRefresh();
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);
// Last step: publish corresponding event.
finishRefresh();
}
Spring容器的 refresh()【创建刷新】
1.prepareRefresh() 刷新前预处理
-1)initPropertySources() 初始化属性设置(默认空方法)；子类自定义属性个性化的属性设置
-2)getEnvironment().validateRequiredProperties(); 检验属性的合法等
-3)earlyApplicationEvents = new LinkedHashSet<>();保存容器中一些早期的事件
2.obtainFreshBeanFactory();获取 BeanFactory
-1)refreshBeanFactory();刷新 BeanFactory
–1)创建一个 this.beanFactory.setSerializationId(getId()); 设置序列化id
-2)getBeanFactory()；返回刚才 GenericApplicationContext 创建的 BeanFactory
-3)将创建的 BeanFactory【DefaultListableBeanFactory】返回
3.prepareBeanFactory(beanFactory); BeanFactory 预准备工作(BeanFactory进行一些设置)
-1)设置 BeanFactory类加载器，支持表达式解析器
-2)添加部分 BeanPostProcessor【ApplicationContextAwareProcessor】
-3)设置忽略的自动装配的接口 {EnvironmentAware,EmbeddedValueResolverAware,ResourceLoaderAware…}
-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);执行 BeanFactoryPostProcessors
BeanFactoryPostProcessors:BeanFactory的后置处理器。 BeanFactory标准初始化之后执行
两个接口:BeanFactoryPostProcessor ，BeanDefinitionRegistryPostProcessor
-1)执行 BeanFactoryPostProcessor 的方法
–1)先执行 BeanDefinitionRegistryPostProcessor
—1)获取所有的 BeanDefinitionRegistryPostProcessor
—2)先执行实现优先级接口 PriorityOrdered 的 BeanDefinitionRegistryPostProcessor
postProcessor.postProcessBeanDefinitionRegistry(registry);
—3)再执行实现了Ordered顺序接口的 BeanDefinitionRegistryPostProcessor
postProcessor.postProcessBeanDefinitionRegistry(registry);
—4)最后执行没有实现任何优先级或者顺序接口的 BeanDefinitionRegistryPostProcessor
postProcessor.postProcessBeanDefinitionRegistry(registry);
–2)再执行 BeanFactoryPostProcessor 的方法
—1)获取所有的 BeanFactoryPostProcessor
—2)先执行实现优先级接口 PriorityOrdered 的 BeanFactoryPostProcessor
postProcessor.postProcessBeanFactory(beanFactory);
—3)再执行实现了Ordered顺序接口的 BeanFactoryPostProcessor
postProcessor.postProcessBeanFactory(beanFactory);
—4)最后执行没有实现任何优先级或者顺序接口的 BeanFactoryPostProcessor
postProcessor.postProcessBeanFactory(beanFactory);
6.registerBeanPostProcessors(beanFactory);注册 BeanPostProcessor(Bean的后置处理器)[intercept bean creation]
不同接口类型的 BeanPostProcessor ，在bean创建前后执行时机不同
BeanPostProcessor
DestructionAwareBeanPostProcessor
InstantiationAwareBeanPostProcessor
SmartInstantiationAwareBeanPostProcessor
MergedBeanDefinitionPostProcessor
-1)获取所有的 BeanPostProcessor ；后置处理器都默认可以通过 PriorityOrdered Ordered 接口来执行优先级
-2)先执行注册 PriorityOrdered 接口的 BeanPostProcessor
–1)sortPostProcessors(priorityOrderedPostProcessors, beanFactory); //排序
–2)registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors); //注册
—1)循环执行 beanFactory.addBeanPostProcessor(postProcessor)
-3)再执行注册 Ordered 接口的 BeanPostProcessor
-4)最后剩余没有实现任何优先级的接口 BeanPostProcessor
-5)最终注册 MergedBeanDefinitionPostProcessor // Finally, re-register all internal BeanPostProcessors
-6)注册一个 ApplicationListenerDetector; 来在bean创建完成后检测是否是 ApplicationListtener.
如果是 this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);
7.initMessageSource()；初始化 MessageSource组件(做国际化功能，消息绑定 解析)
-1)获取 BeanFactory
-2)看容器内是否id为 messageSource ，类型是 MessageSource 的组件
如果有: 赋值给 messageSource
如果没：自己创建一个 DelegatingMessageSource
MessageSource ：取出国际化配置文件中某key值，能按照区域信息获取
-3) 把创建好的MessageSource 注册在容器中，以后可以自动注入
8.initApplicationEventMulticaster() 初始化事件派发器
-1)获取 BeanFactory
-2)从BeanFactory中获取 applicationEventMulticaster 的 ApplicationEventMulticaster组件
-3)如果上一步没有配置，创建一个 SimpleApplicationEventMulticaster
-4)将创建的 SimpleApplicationEventMulticaster 添加到 BeanFactory 中
9.onRefresh(); 留给子容器(子类) 默认空方法
-1)子类重写这个方法，在容器刷新的时候可以自定义逻辑
10.registerListeners(); 给容器中 将所有项目里面的 ApplicationListener 注册进来
-1) 从容器中拿到所有的 ApplicationListener
-2) 将每个监听器添加到时间派发器中:
getApplicationEventMulticaster().addApplicationListener(listener);
-3) 派发之前步骤产生的事件
11.finishBeanFactoryInitialization(beanFactory); //初始化所有剩下的单实例 Bean
-1) beanFactory.preInstantiateSingletons(); // Instantiate all remaining (non-lazy-init) singletons.
–1) 获取容器内所有的Bean，一次初始化和创建对象
–2) 获取Bean 的定义信息 RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
–3) Bean不是抽象的，是单实例的，不是懒加载的
—1) 是否是 isFactoryBean(beanName):是否是实现 FactoryBean 接口的 工厂Bean
是:使用工厂方法创建
否:利用getBean(beanName)方法创建，步骤如下：
----1)doGetBean(name, null, null, false);
----2) 先获取缓存中保存的单实例 Bean.如果能获取到说明这个Bean之前被创建过(所有被创建的单实例Bean都会被缓存起来)
Object sharedInstance = getSingleton(beanName);
/** Cache of singleton objects: bean name --> bean instance */
从private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
----3)缓存中获取不到 开始创建 Bean
----4)markBeanAsCreated(beanName); 标记当前 bean 已经被创建,防止多线程重复创建问题
----5)获取 bean定义信息
----6)String[] dependsOn = mbd.getDependsOn();获取当前 bean依赖的其他bean[dependsOn]
如果有:按照 getBean(dep);先创建进来
----7)if(mbd.isSingleton(){} 启动单实例bean创建
-----1)createBean(beanName, mbd, args);
-----2)Object bean = resolveBeforeInstantiation(beanName, mbdToUse);//让 BeanPostProcessor先拦截返回代理对象
InstantiationAwareBeanPostProcessor:提前执行
先触发:Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
result不是NULL，再执行：Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
-----3)如果前面 InstantiationAwareBeanPostProcessor 没有返回代理对象
-----4)执行:Object beanInstance = doCreateBean(beanName, mbdToUse, args);
------1) instanceWrapper = createBeanInstance(beanName, mbd, args); //利用工厂方法或者构造器创建出Bean实例
------2) applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
MergedBeanDefinitionPostProcessor :提前执行 会执行下面方法
MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
-----5)【bean属性赋值】populateBean(beanName, mbd, instanceWrapper);
正式开始赋值前1、2:
------1)拿到 InstantiationAwareBeanPostProcessor 后置处理器
postProcessAfterInstantiation()
------2)拿到 InstantiationAwareBeanPostProcessor 后置处理器
postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
------3)应用 Bean属性的值，为属性利用setter 方法等进行赋值
applyPropertyValues(beanName, mbd, bw, pvs);//反射机制等实现
-----6)【Bean初始化】initializeBean(beanName, exposedObject, mbd);
------1)【执行Aware接口方法】invokeAwareMethods(beanName, bean); 执行xxxAware接口的方法
{BeanNameAware BeanClassLoaderAware BeanFactoryAware}
------2)【后置处理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
BeanPostProcessor.postProcessBeforeInitialization(result, beanName);
------3)【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);
-------1) 是否是 InitializingBean 接口的实现;执行接口规定的初始化方法
-------1) 是否自定义了初始化方法 invokeCustomInitMethod(beanName, bean, mbd);
------4)【后置处理器初始化之后】applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
beanProcessor.postProcessAfterInitialization(result, beanName);
-----7)【注册Bean的销毁】registerDisposableBeanIfNecessary(beanName, bean, mbd);
registerDisposableBean(beanName,new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
----8)将创建的bean添加到单实例缓存中 afterSingletonCreation(beanName) -> addSingleton(beanName, singletonObject);
ioc容器就是这些Map 多个Map保存了单实例Bean 等等…
所有bean 都通过getBean创建完成以后:
检查所有的Bean 是否是 SmartInitializingSingleton 接口的；
是：就执行 afterSingletonsInstantiated()
12.finishRefresh(); 完成 BeanFactory初始化创建工作，IOC容器创建完成
-1)initLifecycleProcessor();//初始化和生命周期有关的后置处理器
默认从容器中找 lifecycleProcessor组件【LifecycleProcessor】
如果没 会创建的新的 DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();加入到容器中
LifecycleProcessor 接口写一个实现类 可以在 BeanFactory 刷新和关闭时候回调用
-2)getLifecycleProcessor().onRefresh(); //拿到前面定义的生命周期处理器【BeanFactory】回调 .onRefresh()
-3)publishEvent(new ContextRefreshedEvent(this)); //发布容器刷新完成事件
-4)LiveBeansView.registerApplicationContext(this);