Spring的创建主要是在refresh()方法内实现
1,prepareRefresh();
刷新前预处理
1),initPropertySources();
初始化一些属性设置,子类自定义个性化的属性设置方法
2),getEnvironment().validateRequiredProperties();
检验属性的合法等功能
3),this.earlyApplicationEvents = new LinkedHashSet<>();
保存容器中一些早期的事件
2,obtainFreshBeanFactory();
获取BeanFactory
1),刷新 BeanFactory --> refreshBeanFactory();
创建了一个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,
ResourceLoaderAware,
ApplicationEventPublisherAware,
MessageSourceAware,
ApplicationContextAware
4),注册可以解析的自动装配registerResolvableDependency(BeanFactory.class, beanFactory);
我们能直接在任何组件中自动注入:
BeanFactory,
ResourceLoader,
ApplicationEventPublisher,
ApplicationContext
5),添加 BeanPostProcesso r【ApplicationListenerDetector】
6),添加编译时的Aspectj
7),给BeanFactory中注册一些能用的组件:
environment【ConfigurableEnvironment】,
systemProperties【Map<String, Object>】,
systemEnvironment【Map<String, Object>】
4,postProcessBeanFactory(beanFactory);
BeanFactory 准备工作完成后进行的后置处理工作
子类通过重写postProcessBeanFactory()方法，来在 BeanFactory 创建并预准备完成以后做进一步的设置
以上是 BeanFactory 的创建以及预准备工作
5),invokeBeanFactoryPostProcessors(beanFactory);
执行所有的BeanFactoryPostProcessor的方法
BeanFactoryPostProcessor:BeanFactory 的后置处理器,在BeanFactory标准初始化之后(前四步)执行的
两个接口:BeanFactoryPostProcessor--->BeanDefinitionRegistryPostProcessor
【执行 BeanFactoryPostProcessor 的方法】
先执行 BeanDefinitionRegistryPostProcessor 的方法
1),获取所有的 BeanDefinitionRegistryPostProcessor
2),先执行实现了 PriorityOrdered 优先级接口的 BeanDefinitionRegistryPostProcessor
postProcessor.postProcessBeanDefinitionRegistry(registry);
3),再执行实现了 Ordered 顺序接口的 BeanDefinitionRegistryPostProcessor
postProcessor.postProcessBeanDefinitionRegistry(registry);
4),最后执行没有实现任何优先级接口的或者是顺序接口的 BeanDefinitionRegistryPostProcessor
postProcessor.postProcessBeanDefinitionRegistry(registry);
再执行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的后置处理器)【拦截整个Bean的创建过程】
不同接口类型的 BeanPostProcessor，在Bean创建前后执行时机是不一样的
BeanPostProcessor（BeanPostProcessor 及其子接口）
-->DestructionAwareBeanPostProcessor 容器销毁的 Processor
-->InstantiationAwareBeanPostProcessor
-->SmartInstantiationAwareBeanPostProcessor
-->MergedBeanDefinitionPostProcessor【internalPostProcessors存放】
1),获取所有的 BeanPostProcessor;后置处理器都默认可以通过 PriorityOrdered,Ordered 接口指定优先级
2),先注册PriorityOrdered接口的BeanPostProcessor;
把每一个BeanPostProcessor添加到BeanFactory中
beanFactory.addBeanPostProcessor(postProcessor);
3)，再注册Ordered接口的
4),最后注册没有实现任何优先级接口的BeanPostProcessor
5),最终注册MergedBeanDefinitionPostProcessor接口的BeanPostProcessor
6),再注册一个ApplicationListenerDetector，来在Bean创建完成后检查是否是ApplicationListener，
如果是:applicationContext.addApplicationListener((ApplicationListener<?>) bean);
7),initMessageSource();
初始化MessageSource组件(做国际化功能，消息绑定，消息解析);
1),获取BeanFactory
2),看容器中是否有id为messageSource,类型为MessageSource的组件
如果有，从BeanFactory获取到并赋值给messageSource属性
如果没有就自己创建一个DelegatingMessageSource;new 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中获取id=“applicationEventMulticaster”的ApplicationEventMulticaster类型的组件，并赋值给
applicationEventMulticaster = beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
3),如果上一步没有配置，就自己创建一个如果没有，就自己创建一个
applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
并且将创建的ApplicationEventMulticaster注册到BeanFactory中,以后其他组件可以直接自动注入获取到该组件
9),onRefresh();
初始化其他的Bean,留给子容器(子类)
1),子类重写这个方法，在容器中刷新的时候可以自定义逻辑
10),registerListeners();
给容器中将所有项目里面的ApplicationListener注册进来
1),从容器中拿到所有的ApplicationListener
2),将每个监听器添加到事件派发器中:
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
3),派发之前步骤产生的事件
11),finishBeanFactoryInitialization(beanFactory);
初始化所有剩下的单实例Bean
1),beanFactory.preInstantiateSingletons();初始化剩下的单实例Bean
1),获取容器中的所有Bean，依次进行初始化和创建对象
2),获取Bean的定义信息 RootBeanDefinition
3),如果Bean不是抽象的，是单实例的，是懒加载的
1),判断是否是FactoryBean:是否是实现FactoryBean接口的Bean
2),不是工厂Bean，利用getBean(beanName);创建对象
0),getBean(beanName):ioc.getBean(beanName);
1),doGetBean(name, null, null, false);
2),先获取缓存中保存的单实例Bean，如果能获取到，说明这个Bean之前被创建过了(所有创建过的单实例Bean都会被缓存起来)
从private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);获取
singletonObjects(缓存单实例Bean的容器)
3),缓存中获取不到，开始Bean的创建对象流程:
4),标记当前Bean已经被创建markBeanAsCreated(beanName);
5),获取Bean定义信息getMergedLocalBeanDefinition(beanName);
6),【从Bean定义信息中获取当前Bean依赖的其他Bean getDependsOn();
如果有，按照第0步的getBean()的方式，先把依赖的Bean创建出来】
7),启动单实例Bean的创建流程:
1),createBean(beanName, mbd, args);
2),Object bean = resolveBeforeInstantiation(beanName, mbdToUse);让BeanPostProcessor先拦截返回代理对象;
【InstantiationAwareBeanPostProcessor】提前执行
先触发postProcessBeforeInstantiation(beanClass, beanName);
如果有返回值，再触发applyBeanPostProcessorsAfterInitialization(bean, beanName);
3),如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象，进行下一步
4),Object beanInstance = doCreateBean(beanName, mbdToUse, args);
1),createBeanInstance(beanName, mbd, args);创建Bean实例
利用工厂方法或者对象的构造器创建出Bean实例
2),applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
调用MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(mbd, beanType, beanName);
3),populateBean(beanName, mbd, instanceWrapper);【Bean属性赋值】
赋值之前:
1),拿到InstantiationAwareBeanPostProcessor后置处理器
执行postProcessAfterInstantiation()方法
2),再次拿到InstantiationAwareBeanPostProcessor后置处理器
执行postProcessProperties();方法
赋值前后
3),applyPropertyValues(beanName, mbd, bw, pvs);应用Bean属性的值,为属性利用setter等方法赋值
4),initializeBean(beanName, exposedObject, mbd);【Bean初始化】
1),invokeAwareMethods(beanName, bean);执行XXXAware接口的方法
BeanNameAware/BeanClassLoaderAware/BeanFactoryAware
2),applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);【执行后置处理器初始化之前的方法】
BeanPostProcessor.postProcessBeforeInitialization();
3),invokeInitMethods(beanName, wrappedBean, mbd);【执行初始化方法】
1),是否是InitializingBean接口的实现，如果是执行接口规定的初始化方法
2),执行自定义初始化方法
4),applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);【执行后置处理器初始化之后的方法】
BeanPostProcessor.postProcessAfterInitialization()
5),registerDisposableBeanIfNecessary(beanName, bean, mbd);【注册Bean的销毁方法】
5),addSingleton(beanName, singletonObject);【将创建的Bean添加到缓存中】
ioc容器就是这些Map，很多的Map保存了单实例Bean和环境信息....
3),所有Bean都利用getBean创建完成后:
检查所有的Bean是否是SmartInitializingSingleton接口的；如果是就执行
SmartInitializingSingleton.afterSingletonsInstantiated();
12),finishRefresh();
完成BeanFactory的初始化创建工作,IOCr容器就创建完成
1),clearResourceCaches();
2),initLifecycleProcessor();【初始化和生命周期有关的后置处理器】
默认从容器中找LifecycleProcessor组件，如果没有就用默认的生命周期组件
new DefaultLifecycleProcessor();然后注册到容器中
写一个LifecycleProcessor的实现类，可以在BeanFactory
void onRefresh();
void onClose();
3),getLifecycleProcessor().onRefresh();【拿到前面定义的生命周期处理器，监听BeanFactory，回调onRefresh()方法】
4),publishEvent(new ContextRefreshedEvent(this));【发布一个容器刷新完成事件】
5),LiveBeansView.registerApplicationContext(this);
总结
1)Spring容器在启动的时候，先会保存所有注册过的Bean的定义信息;
1),xml注册Bean:
2),注解注册Bean:@Service,@Component,@Bean…
2),Spring容器会在合适的时机创建这些Bean
1),用到这个Bean的时候，利用getBean()方法创建Bean，创建好以后保存到容器中
2),统一创建剩下的所有Bean的时候finishBeanFactoryInitialization(beanFactory);
3),后置处理器:
1),每一个Bean创建完成后，都会使用各种后置处理器，来增强Bean的功能
例如:
AutowiredAnnotationBeanPostProcessor:处理自动注入
AnnotationAwareAspectJAutoProxyCreator:来做AOP功能
AsyncAnnotationBeanPostProcessor:支持异步处理的
…
4),Spring的事件驱动模型
ApplicationListener:事件监听
事件派发:ApplicationEventMulticaster接口
714
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
