spring启动的方法
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
register(annotatedClasses);
refresh();
}register方法是用来解析所有bean的定义信息。
refresh方法完成了容器的创建与刷新工作，看下它的实现及流程
@Override
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();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// Destroy already created singletons to avoid dangling resources.
destroyBeans();
// Reset 'active' flag.
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();
}
}
}
第一步：prepareRefresh() 刷新之前的预处理工作
1）、initPropertySources();初始化属性设置，这个是没有实现的，可以让子类（可以自定义）自定义个性化属性的方法
2）、getEnvironment().validateRequiredProperties();检验属性的合法等
3）、this.earlyApplicationEvents = new LinkedHashSet<>();保存容器中早期的一些事件，当事件处理器好的时候，可以处理些事件
第二步：ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();获取beanFactory
1）、refreshBeanFactory：刷新创建bean工厂
创建一个beanFactory对象：this.beanFactory = new DefaultListableBeanFactory();
设置ID:this.beanFactory.setSerializationId(getId());->id = ObjectUtils.identityToString(this)
2）、获取bean工厂：getBeanFactory()
3）、返回创建的beanFacory(DefaultListableBeanFactory)
第三步：prepareBeanFactory(beanFactory);beanFactory的预准备工作
1）、设置beanFacory的类加载器：默认取值为：Thread.currentThread().getContextClassLoader()
2）、设置表达式的解析
3）、添加beanPostPorcessor: ApplicationContextAwareProcessor：为实现了ApplicationContextAware接口的类设置ApplicationContext值
4）、设置忽略的自动装配的接口，设置了这些类，不能通过自动注入来获取这些值
1）、EnvironmentAware
2）、EmbeddedValueResolverAware
3）、ResourceLoaderAware
4）、ApplicationEventPublisherAware
5）、MessageSourceAware
6）、ApplicationContextAware
5）、设置能自动注入的接口
1）、BeanFactory
2）、ResourceLoader
3）、ApplicationEventPublisher
4）、ApplicationContext
6）、添加beanPostPorcessor: ApplicationListenerDetector
7）、添加编译时的AspectJ
8）、给beanFactory注册一些能用的组件：
1）、environment（ConfigurableEnvironment）：数据来源：System.getProperties()、System.getenv()
2）、systemProperties：数据来源于1中的System.getProperties()
3）、systemEnvironment：数据来源于1中的System.getenv()
第四步：postProcessBeanFactory(beanFactory)，beanFactory完成之后进行的后置处理工作
1）、此类未实现，子类通过重写来做一些个性的设置
至此完成了beanFactory的创建及预准备工作
第五步：invokeBeanFactoryPostProcessors(beanFactory)，执行BeanFactoryPostProcessor：
BeanFactoryPostProcessor，Beanfactory的后置处理器，在beanFactory标准初始化之后执行的
两个接口：BeanFactoryPostProcessor，BeanDefinitionRegistryPostProcessor
1）、执行BeanFactoryPostProcessor的方法
1）、String[] postProcessorNames =beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
获取所有BeanDefinitionRegistryPostProcessor的类
2）、优先获取了，实现了：PriorityOrdered的BeanDefinitionRegistryPostProcessor类
3）、然后再排序
4）、执行postProcessor.postProcessBeanDefinitionRegistry(registry)的方法
5）、再获取，实现了Ordered的BeanDefinitionRegistryPostProcessor
6）、之后的实现同3，4。
7）、再获取剩余的BeanDefinitionRegistryPostProcessor，然后执行同3，4，
接下来再执行BeanFactoryPostProcessor，过程同上，只不过，执行的方法是
postProcessor.postProcessBeanFactory(beanFactory);
第六步：registerBeanPostProcessors(beanFactory)，注册BeanPostProcessor，bean的后置处理器
BeanPostProcessor包括
BeanPostProcessor，
InstantiationAwareBeanPostProcessor，
DestructionAwareBeanPostProcessor，
SmartInstantiationAwareBeanPostProcessor，
MergedBeanDefinitionPostProcessor（记录在internalPostProcessors里）等等
不同接口类型的BeanPostProcessor，在Bean创建前后的执行时机是不一样的
1）、获取所有的BeanPostProcessor：String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false); 后置处理器默认都可以通过PriorityOrdered，Ordered指定优先级
2）、先注册实现了PriorityOrdered的BeanPostProcessor，然后是Ordered的，最后是普通的
3）、注册就是添加到beanFactory里beanFactory.addBeanPostProcessor(postProcessor);
4）、最终注册的是internalPostProcessors的，也就是MergedBeanDefinitionPostProcessor
5）、最后注册了一个ApplicationListenerDetector，处理spring事件的监听器
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
第七步：initMessageSource():实现国际化语言的
1）、获取beanFactory
2）、看容器中是否有messageSource的组件，类型是messageSource的组件，如果有，赋值给messageSource属性，如果没有创建一个DelegatingMessageSource
，然后赋值给messageSource。
messageSource，可以取出国际化配置文件的某个key的值，能按照区域信息，取。
以后业务系统中要用，可以自己注入就可以。
第八步：initApplicationEventMulticaster：初始化事件派发器
1）、获取beanFactory
2）、获取applicationEventMulticaster的ApplicationEventMulticaster
3）、如果没有配置就自己创建一个SimpleApplicationEventMulticaster
4）、业务代码中要用，可以自己注入
第九步：onRefresh()：是留给子容器的
1）、子类可以重写这个方法，在容器刷新时，进行一个个性化处理
第十步：registerListeners();把事件的监听器，注册到容器中
1）、从容器中获取所有的ApplicationListener组件
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
2）、将监听器添加到派发器中
getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
3）、派发早期的事件
Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;
this.earlyApplicationEvents = null;
if (earlyEventsToProcess != null) {
for (ApplicationEvent earlyEvent : earlyEventsToProcess) {
getApplicationEventMulticaster().multicastEvent(earlyEvent);
}
}
第十一步：finishBeanFactoryInitialization(beanFactory);完成所有剩余的单示例bean
1）、beanFactory.preInstantiateSingletons();初始化所有的单示例bean
1）、获取容器中所有的bean,依次初始化和创建对象
2）、拿到Bean的定义信息
3）、过滤条件是：Bean不是抽象的，单例的，不是懒加载的
1）、判断是否是factoryBean，如果是调用factoryBean.getObject()来实例化对象,在这时不进行创建，在第一次使用时，才创建
2）、如果不是则用getBean()
1）、getBean(beanName)
2）、doGetBean(name, null, null, false);
3）、先从缓存中获取已经创建的单示例bean，如果已经创建，则直接返回
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
4）、缓存中没有，则开始创建
获取beanFacory及parentBeanFactory（当成mvc整合之后，容器会有父子之分，mvc的容器是子容器，spring为父容器）
5）、标识bean已被创建
markBeanAsCreated(beanName);
6）、获取bean的定义信息
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
7）、获取当前bean的依赖信息，如果有，则先创建依赖的bean
String[] dependsOn = mbd.getDependsOn();
8）、启动单示例bean的创建流程
1）、createBean(beanName, mbd, args);
2）、Object bean = resolveBeforeInstantiation(beanName, mbdToUse);让beanPostPorcessor先拦截返回代理对象
是InstantiationAwareBeanPostProcessor提前执行的逻辑
触发的是这个方法：Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
如果返回值不为空，则：Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
3）、如果在2中返回null，则继续创建
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
1）、创建bean示例
instanceWrapper = createBeanInstance(beanName, mbd, args);
2）、利用bean的工厂方法和bean构造器创建对象（反射创建）
3）、执行MergedBeanDefinitionPostProcessor后置处理器
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
4）、为bean赋值：
populateBean(beanName, mbd, instanceWrapper);
1）、执行后置管理器InstantiationAwareBeanPostProcessor
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
continueWithPropertyPopulation = false;
break;
}
2）、执行后置管理器InstantiationAwareBeanPostProcessor，这个会返回一个属性值，可赋值给bean
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvs == null) {
return;
}
}
} 3）、开始为bean赋值
applyPropertyValues(beanName, mbd, bw, pvs);
5）、初始化initializeBean(beanName, exposedObject, mbd);
1）、执行invokeAwareMethods(beanName, bean);为一些aware赋值
BeanNameAware、BeanClassLoaderAware、BeanFactoryAware
2）、执行后置处理器
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
Object current = beanProcessor.postProcessBeforeInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
} 3）、初始化：invokeInitMethods，包括：
1）、实现了InitializingBean的afterPropertiesSet方法
2）、调用的是bean配置的init-method方法
4）、执行后置处理器
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
} 5）、注册bean的销毁方法
registerDisposableBeanIfNecessary(beanName, bean, mbd);
1）、实现了DisposableBean
2）、定义bean时指定了destroy方法
6）、当创建的bean放入singleBean里：addSingleton(beanName, singletonObject);
9）、所有bean创建完之后，判断bean是否实现了SmartInitializingSingleton，实现了调用afterSingletonsInstantiated方法
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}
}
第十二步：完成bean的初始化创建工作
finishRefresh();
1）、clearResourceCaches
2）、initLifecycleProcessor：初始化生命周期有关的后置处理LifecycleProcessor
默认从容器中找，如果没有，则创建一个DefaultLifecycleProcessor
3）、getLifecycleProcessor().onRefresh();调用生命周期后置处理器的，回调onRefresh方法
4）、publishEvent(new ContextRefreshedEvent(this));发布容器刷新事件
扫一扫
2581
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
