Spring Framework，也就是我们常说的Spring框架，我觉得其中最核心的部分应该就是IOC容器了，Spring的IOC容器的实现也叫做DI，也就是依赖注入。这篇博客要说的就是这其中的大概的实现过程。
AnnotationConfigApplicationContext context=new AnnotationConfigApplicationContext(SpringConfig.class);Spring的启动只需要这样一行代码就可以了
public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
this();
register(componentClasses);
refresh();
}先看一看类图
在这个类图中，最核心的一个就是AbstractApplicationContext。
接着看代码，首先初始化注解以及XML的读取或者扫描的两个类，接着将实例化AnnotationConfigApplicationContext时传入的类，也就是register方法中传入的类，生成该类的BeanDefinition（这里必须先要弄明白BeanDefinition和Bean的区别，而且注意生成的仅仅是这个register类的BeanDefinition），存入beanDefinitionMap，而此时并没有执行扫描，接着执行refresh方法。
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
// context refresh开始之前的操作
prepareRefresh();
// Tell the subclass to refresh the internal bean factory.
// 获取一个BeanFactory ，通常是 DefaultListableBeanFactory
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// beanFactory的一些预操作
// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);
try {
// 允许这里对BeanFactory做一些处理,默认空实现
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);
// 执行BeanFactory的后置处理器
// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// 注册所有的BeanPostProcessor到beanFactory中
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);
// 国际化
// Initialize message source for this context.
initMessageSource();
//初始化事件传播器
// Initialize event multicaster for this context.
initApplicationEventMulticaster();
//初始化一些特殊的bean ,交给子类实现，默认空实现
// Initialize other special beans in specific context subclasses.
onRefresh();
// 注册ApplicationListener到事件传播器中(实际上只是放入了名称)
// Check for listener beans and register them.
registerListeners();
// Instantiate all remaining (non-lazy-init) singletons.
//实例化非懒加载的bean
finishBeanFactoryInitialization(beanFactory);
//spring容器构建结束
// 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方法，这里主要是web环境下加载一些配置属性，不过这需要子类GenericWebApplicationContext去实现，如果是当前AnnotationConfigApplicationContext ，默认无动作
protected void prepareRefresh() {
// Switch to active.
this.startupDate = System.currentTimeMillis();
this.closed.set(false);
this.active.set(true);
if (logger.isDebugEnabled()) {
if (logger.isTraceEnabled()) {
logger.trace("Refreshing " + this);
}
else {
logger.debug("Refreshing " + getDisplayName());
}
}
// Initialize any placeholder property sources in the context environment.
// web环境下加载一些配置属性
initPropertySources();
//验证配置属性
// Validate that all properties marked as required are resolvable:
// see ConfigurablePropertyResolver#setRequiredProperties
getEnvironment().validateRequiredProperties();
// Store pre-refresh ApplicationListeners...
if (this.earlyApplicationListeners == null) {
this.earlyApplicationListeners = new LinkedHashSet<>(this.applicationListeners);
}
else {
// Reset local application listeners to pre-refresh state.
this.applicationListeners.clear();
this.applicationListeners.addAll(this.earlyApplicationListeners);
}
// Allow for the collection of early ApplicationEvents,
// to be published once the multicaster is available...
this.earlyApplicationEvents = new LinkedHashSet<>();
}接着获取一个BeanFactory，看一看BeanFactory的类图
接着prepareBeanFactory方法，准备工厂，就是对工厂注册了一些需要的后置处理器以及环境等等
接着postProcessBeanFactory方法，允许这里对BeanFactory做一些处理，默认空实现
接着invokeBeanFactoryPostProcessors方法，执行BeanFactory的后置处理器
PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());这个方法比较长，整体来说分为两个部分。
前一部分是执行BeanDefinitionRegistryPostProcessor的postProcessBeanDefinitionRegistry方法。
后一部分是执行BeanFactoryPostProcessor的postProcessBeanFactory方法。
首先先说前一部分，也就是执行postProcessBeanDefinitionRegistry的这部分
先是从当前BeanFactoryPostProcessor列表中找出BeanDefinitionRegistryPostProcessor类型的，并执行，
接着从BeanFactory中获取，先对继承了PriorityOrdered接口的排序并执行，
再对继承了Ordered接口的排序并执行，
最后对剩下的依次执行。
再说后一部分，也就是执行postProcessBeanFactory的这部分
同样是先对继承了PriorityOrdered接口的排序并执行，
再对继承了Ordered接口的排序并执行，
最后对剩下的依次执行。
public static void invokeBeanFactoryPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {
// Invoke BeanDefinitionRegistryPostProcessors first, if any.
Set<String> processedBeans = new HashSet<>();
if (beanFactory instanceof BeanDefinitionRegistry) {
BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;
List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();
List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();
//找出BeanFactoryPostProcessor列表中的BeanDefinitionRegistryPostProcessor对beanFactory轮流处理
//其他的BeanFactoryPostProcessor放入regularPostProcessors集合最后调用
for (BeanFactoryPostProcessor postProcessor : beanFactoryPostProcessors) {
if (postProcessor instanceof BeanDefinitionRegistryPostProcessor) {
BeanDefinitionRegistryPostProcessor registryProcessor =
(BeanDefinitionRegistryPostProcessor) postProcessor;
registryProcessor.postProcessBeanDefinitionRegistry(registry);
registryProcessors.add(registryProcessor);
}
else {
regularPostProcessors.add(postProcessor);
}
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
// Separate between BeanDefinitionRegistryPostProcessors that implement
// PriorityOrdered, Ordered, and the rest.
List<BeanDefinitionRegistryPostProcessor> currentRegistryProcessors = new ArrayList<>();
//先找出实现了PriorityOrdered的BeanDefinitionRegistryPostProcessor
//执行postProcessBeanDefinitionRegistry，并且放入registryProcessors集合
//同时放入processedBeans表示已经执行过了
//重点关注 ConfigurationClassPostProcessor，用于扫描生成BeanDefinition
ConfigurationClassPostProcessor to;
//接着找出实现了Ordered的BeanDefinitionRegistryPostProcessor
//执行postProcessBeanDefinitionRegistry，并且放入registryProcessors集合
//同时放入processedBeans表示已经执行过了
//最后找出不在processedBeans中的BeanDefinitionRegistryPostProcessor
//执行postProcessBeanDefinitionRegistry，并且放入registryProcessors集合
// First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
// Finally, invoke all other BeanDefinitionRegistryPostProcessors until no further ones appear.
boolean reiterate = true;
while (reiterate) {
reiterate = false;
postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);
for (String ppName : postProcessorNames) {
if (!processedBeans.contains(ppName)) {
currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));
processedBeans.add(ppName);
reiterate = true;
}
}
sortPostProcessors(currentRegistryProcessors, beanFactory);
registryProcessors.addAll(currentRegistryProcessors);
invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry);
currentRegistryProcessors.clear();
}
//最后执行registryProcessors集合中所有成员的postProcessBeanFactory方法
//以及regularPostProcessors中的所有成员的postProcessBeanFactory
// 需要重点关注 ConfigurationClassPostProcessor
// Now, invoke the postProcessBeanFactory callback of all processors handled so far.
invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);
invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);
}
else {
// Invoke factory processors registered with the context instance.
invokeBeanFactoryPostProcessors(beanFactoryPostProcessors, beanFactory);
}
//找出BeanFactoryPostProcessor
//按照之前的逻辑再来一次
//需要关注的是EventListenerMethodProcessor 用于生成注解的ApplicationListener
EventListenerMethodProcessor to;
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let the bean factory post-processors apply to them!
String[] postProcessorNames =
beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);
// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
List<BeanFactoryPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
for (String ppName : postProcessorNames) {
if (processedBeans.contains(ppName)) {
// skip - already processed in first phase above
}
else if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
priorityOrderedPostProcessors.add(beanFactory.getBean(ppName, BeanFactoryPostProcessor.class));
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);
// Next, invoke the BeanFactoryPostProcessors that implement Ordered.
List<BeanFactoryPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());
for (String postProcessorName : orderedPostProcessorNames) {
orderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
sortPostProcessors(orderedPostProcessors, beanFactory);
invokeBeanFactoryPostProcessors(orderedPostProcessors, beanFactory);
// Finally, invoke all other BeanFactoryPostProcessors.
List<BeanFactoryPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());
for (String postProcessorName : nonOrderedPostProcessorNames) {
nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));
}
invokeBeanFactoryPostProcessors(nonOrderedPostProcessors, beanFactory);
// Clear cached merged bean definitions since the post-processors might have
// modified the original metadata, e.g. replacing placeholders in values...
beanFactory.clearMetadataCache();
}在执行postProcessBeanDefinitionRegistry的过程中，有一个最为重要的bean是ConfigurationClassPostProcessor，这个后置处理器会进行扫描，将所有的扫描路径下的类生成一个BeanDefinition列表，为接下来的生成Bean做准备
接着registerBeanPostProcessors(beanFactory)方法，这里将所有的BeanPostProcessor找出来并注册到了容器中。
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);其中的方法和上面的BeanFactoryPostProcessor的那部分逻辑基本类似。
再接着执行initMessageSource方法，，这个主要用来处理国际化的
再接着是initApplicationEventMulticaster方法，注册一个事件传播器，
再接着是onRefresh方法，默认空实现。
再往下看registerListeners方法，注册监听器到容器中。
for (ApplicationListener<?> listener : getApplicationListeners()) {
getApplicationEventMulticaster().addApplicationListener(listener);
}再接着看finishBeanFactoryInitialization方法。这里就是真正的bean的生命周期开始执行了。
会去调用preInstantiateSingletons方法。
// Trigger initialization of all non-lazy singleton beans...
// 循环beanNames，实例化单例bean
for (String beanName : beanNames) {
RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
//判断 非抽象的，单例的，非懒加载的
if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
//判断是不是FactoryBean
if (isFactoryBean(beanName)) {
//FactoryBean 需要带上&前缀才能找到真正的bean
Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
if (bean instanceof FactoryBean) {
FactoryBean<?> factory = (FactoryBean<?>) bean;
boolean isEagerInit;
if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
isEagerInit = AccessController.doPrivileged(
(PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
getAccessControlContext());
}
else {
isEagerInit = (factory instanceof SmartFactoryBean &&
((SmartFactoryBean<?>) factory).isEagerInit());
}
if (isEagerInit) {
getBean(beanName);
}
}
}
else {
//加载bean
getBean(beanName);
}
}
}getBean(beanName)方法就是开始去加载生成bean了。
接着是doGetBean方法
首先会调用getSingleton方法，第一次进来肯定是什么也获取不到的。
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
//先从一级缓存singletonObjects中获取 singletonObjects同样也是最终实例的存储容器
Object singletonObject = this.singletonObjects.get(beanName);
//如果singletonObjects获取不到，并且正在创建中
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
//加锁，确保原子性
synchronized (this.singletonObjects) {
//再从二级缓存earlySingletonObjects中获取
singletonObject = this.earlySingletonObjects.get(beanName);
//如果二级缓存是空的，并且支持循环依赖
if (singletonObject == null && allowEarlyReference) {
//从三级缓存singletonFactories中获取
ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
//singletonFactories中存放的是lambda对象，通过getObject生成二级缓存，并且放入二级缓存中去
singletonObject = singletonFactory.getObject();
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}接着还会尝试从parent父容器中获取
//从parent容器中查看能不能获取到
// Check if bean definition exists in this factory.
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// Not found -> check parent.
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// Delegation to parent with explicit args.
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else if (requiredType != null) {
// No args -> delegate to standard getBean method.
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
else {
return (T) parentBeanFactory.getBean(nameToLookup);
}
}再往下，获取depenceOn，先加载依赖项
// Guarantee initialization of beans that the current bean depends on.
//判断是不是有dependsOn的bean ,有的话，先去生成dependsOn的bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
}
registerDependentBean(dep, beanName);
try {
getBean(dep);
}
catch (NoSuchBeanDefinitionException ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"'" + beanName + "' depends on missing bean '" + dep + "'", ex);
}
}
}最后根据不同的scope创建bean
//创建bean ,不同的scope有不同的创建方式
// Create bean instance.
//创建单例
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
//创建bean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
//创建原型
else if (mbd.isPrototype()) {
// It's a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
//将bean移除正在创建的集合标签中
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
//其他scope
else {
String scopeName = mbd.getScope();
if (!StringUtils.hasLength(scopeName)) {
throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
}
Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new ScopeNotActiveException(beanName, scopeName, ex);
}
}
}主要看单例的创建过程。也就是createBean(beanName, mbd, args)方法。
首先执行后置处理器的postProcessorBeforeInstantiation方法，尝试返回自定义的代理对象(和aop无关)
// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
// 给予后置处理器们一个机会，返回自己的代理对象
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
Object bean = null;
if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
// Make sure bean class is actually resolved at this point.
//先调用postProcessBeforeInstantiation
//如果有自己代理对象返回，那就直接调用postProcessAfterInitialization
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
Class<?> targetType = determineTargetType(beanName, mbd);
if (targetType != null) {
bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
if (bean != null) {
bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
}
}
}
mbd.beforeInstantiationResolved = (bean != null);
}
return bean;
}再接着调用doCreateBean方法
Object beanInstance = doCreateBean(beanName, mbdToUse, args);首先会实例化对象
//实例化，创建对象
if (instanceWrapper == null) {
//通过构造方法实例化对象
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
//bean实例
Object bean = instanceWrapper.getWrappedInstance();实例生成是通过构造器反射生成的，构造器的注入也是在这里进行
//构造器注入
// Candidate constructors for autowiring?
Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}接着调用applyMergedBeanDefinitionPostProcessors方法，执行BeanFactory中所有实现了MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition方法。
// postProcessMergedBeanDefinition后置处理器方法
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}再接着添加三级缓存，三级缓存是为了延迟执行，就是说如果确实有循环依赖，才会在后续循环依赖的地方执行该方法，否则不会执行该方法。
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
//判断是否允许循环依赖，并且正在创建中
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isTraceEnabled()) {
logger.trace("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
//添加三级缓存
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}再往下，执行populateBean方法，填充Bean实例的属性。
首先执行postProcessAfterInstantiation方法
// 调用postProcessAfterInstantiation 实例化完成后的回调方法
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
return;
}
}
}接下来执行postProcessProperties方法，用后置处理器的模式进行属性的填充
//执行填充属性的后置处理器
//重点注意CommonAnnotationBeanPostProcessor和 AutowiredAnnotationBeanPostProcessor
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}这里面最重要的是CommonAnnotationBeanPostProcessor和AutowiredAnnotationBeanPostProcessor，分别是对@Resource和@Autowired注解的属性进行注入
接下来调用initializeBean方法。
首先调用invokeAwareMethods方法，方法中调用了三个Aware的方法，BeanNameAware，BeanClassLoaderAware和BeanFactoryAware
private void invokeAwareMethods(final String beanName, final Object bean) {
if (bean instanceof Aware) {
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}接着调用applyBeanPostProcessorsBeforeInitialization，方法里获取了所有BeanPostProcessor调用postProcessBeforeInitialization方法。
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessBeforeInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}其中有几个比较重要的后置处理器。
首先是ApplicationContextAwareProcessor，如果当前bean实现了几个Aware接口，会调用invokeAwareInterfaces方法
private void invokeAwareInterfaces(Object bean) {
if (bean instanceof EnvironmentAware) {
((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
}
if (bean instanceof EmbeddedValueResolverAware) {
((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
}
if (bean instanceof ResourceLoaderAware) {
((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
}
if (bean instanceof ApplicationEventPublisherAware) {
((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
}
if (bean instanceof MessageSourceAware) {
((MessageSourceAware) bean).setMessageSource(this.applicationContext);
}
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
}
}接着是InitDestroyAnnotationBeanPostProcessor，方法中就是执行注解了@PostConstruct的初始化方法
所有的BeanPostProcessor执行完之后，再往下调用invokeInitMethods方法，如果当前bean实现了InitializingBean，会调用afterPropertiesSet的初始化方法。
((InitializingBean) bean).afterPropertiesSet()再往下调用自定义的初始化方法，就是xml中配置的那个
if (mbd != null && bean.getClass() != NullBean.class) {
String initMethodName = mbd.getInitMethodName();
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
invokeCustomInitMethod(beanName, bean, mbd);
}
}再往下调用applyBeanPostProcessorsAfterInitialization方法，方法中同样是取出所有的BeanPostProcesser，不同的是这里调用postProcessAfterInitialization方法
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor processor : getBeanPostProcessors()) {
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}其中重要的是AbstractAutoProxyCreator，这里进行了Aop代理
还有一个是ApplicationListenerDetector，这个后置处理器中判断了当前Bean有没有实现ApplicationListener，有的话添加进applicationListeners中
@Override
public Object postProcessAfterInitialization(Object bean, String beanName) {
if (bean instanceof ApplicationListener) {
// potentially not detected as a listener by getBeanNamesForType retrieval
Boolean flag = this.singletonNames.get(beanName);
if (Boolean.TRUE.equals(flag)) {
// singleton bean (top-level or inner): register on the fly
this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);
}
else if (Boolean.FALSE.equals(flag)) {
if (logger.isWarnEnabled() && !this.applicationContext.containsBean(beanName)) {
// inner bean with other scope - can't reliably process events
logger.warn("Inner bean '" + beanName + "' implements ApplicationListener interface " +
"but is not reachable for event multicasting by its containing ApplicationContext " +
"because it does not have singleton scope. Only top-level listener beans are allowed " +
"to be of non-singleton scope.");
}
this.singletonNames.remove(beanName);
}
}
return bean;
}至此，bean就创建完成了，最后将bean放入singletonObjects中，也就是容器中。
if (newSingleton) {
addSingleton(beanName, singletonObject);
}/**
* Add the given singleton object to the singleton cache of this factory.
* <p>To be called for eager registration of singletons.
* @param beanName the name of the bean
* @param singletonObject the singleton object
*/
protected void addSingleton(String beanName, Object singletonObject) {
synchronized (this.singletonObjects) {
this.singletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
}
}bean创建完成。
当所有的bean创建完成以后，会依次调用实现了SmartInitializingSingleton的后置方法
//触发SmartInitializingSingleton的回调方法 afterSingletonsInstantiated
//重点注意 EventListenerMethodProcessor
// Trigger post-initialization callback for all applicable beans...
for (String beanName : beanNames) {
Object singletonInstance = getSingleton(beanName);
if (singletonInstance instanceof SmartInitializingSingleton) {
SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
smartSingleton.afterSingletonsInstantiated();
return null;
}, getAccessControlContext());
}
else {
smartSingleton.afterSingletonsInstantiated();
}
}执行完之后，finishBeanFactoryInitialization方法也就执行完成了
再接着是finishRefresh方法
protected void finishRefresh() {
// Clear context-level resource caches (such as ASM metadata from scanning).
clearResourceCaches();
//向context中注册一个LifecycleProcessor
// Initialize lifecycle processor for this context.
initLifecycleProcessor();
//执行实现了Lifecycle的start方法
// Propagate refresh to lifecycle processor first.
getLifecycleProcessor().onRefresh();
//发布一个ContextRefreshedEvent事件
// Publish the final event.
publishEvent(new ContextRefreshedEvent(this));
// Participate in LiveBeansView MBean, if active.
LiveBeansView.registerApplicationContext(this);
}首先是initLifecycleProcessor方法，注册了一个LifecycleProcessor
/**
* Initialize the LifecycleProcessor.
* Uses DefaultLifecycleProcessor if none defined in the context.
* @see org.springframework.context.support.DefaultLifecycleProcessor
*/
protected void initLifecycleProcessor() {
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(LIFECYCLE_PROCESSOR_BEAN_NAME)) {
this.lifecycleProcessor =
beanFactory.getBean(LIFECYCLE_PROCESSOR_BEAN_NAME, LifecycleProcessor.class);
if (logger.isTraceEnabled()) {
logger.trace("Using LifecycleProcessor [" + this.lifecycleProcessor + "]");
}
}
else {
DefaultLifecycleProcessor defaultProcessor = new DefaultLifecycleProcessor();
defaultProcessor.setBeanFactory(beanFactory);
this.lifecycleProcessor = defaultProcessor;
beanFactory.registerSingleton(LIFECYCLE_PROCESSOR_BEAN_NAME, this.lifecycleProcessor);
if (logger.isTraceEnabled()) {
logger.trace("No '" + LIFECYCLE_PROCESSOR_BEAN_NAME + "' bean, using " +
"[" + this.lifecycleProcessor.getClass().getSimpleName() + "]");
}
}
}注册好之后调用onRefresh方法，方法中调用startBeans
@Override
public void onRefresh() {
startBeans(true);
this.running = true;
}方法中首先获取容器中所有实现了Lifecycle的bean，接着做了个判断，如果实现了SmartLifecycle，那么isAutoStartup返回true的进入，或者autoStartupOnly是false，不过当前传入的是true，进入后，获取所有Lifecycle的phase，根据phase的大小排序，小的先执行start方法，大的后执行
private void startBeans(boolean autoStartupOnly) {
//获取所有实现了Lifecycle的bean
Map<String, Lifecycle> lifecycleBeans = getLifecycleBeans();
Map<Integer, LifecycleGroup> phases = new HashMap<>();
//找出需要调用start方法的Lifecycle
//一个是autoStartupOnly设置了false,或者是实现了SmartLifecycle并且isAutoStartup属性是true
//通过getPhase获取到的值排序，依次执行start方法
lifecycleBeans.forEach((beanName, bean) -> {
if (!autoStartupOnly || (bean instanceof SmartLifecycle && ((SmartLifecycle) bean).isAutoStartup())) {
int phase = getPhase(bean);
LifecycleGroup group = phases.get(phase);
if (group == null) {
group = new LifecycleGroup(phase, this.timeoutPerShutdownPhase, lifecycleBeans, autoStartupOnly);
phases.put(phase, group);
}
group.add(beanName, bean);
}
});
if (!phases.isEmpty()) {
List<Integer> keys = new ArrayList<>(phases.keySet());
Collections.sort(keys);
for (Integer key : keys) {
phases.get(key).start();
}
}
}返回，接着调用publishEvent方法。创建并发布ContextRefreshedEvent事件
getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);最后调用resetCommonCaches清除各种缓存，spring框架启动就到此结束了。
当然spring框架中肯定还有许多的细节，因为spring框架是真的非常难，非常庞大。
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
