一文搞懂Spring执行流程

要想搞清楚Spring的执行逻辑我们必须明白在Spring的IOC容器中执行的12步都在干什么。

@Override  //容器刷新的十二大步。模板模式
public void refresh() throws BeansException, IllegalStateException {synchronized (this.startupShutdownMonitor) {StartupStep contextRefresh = this.applicationStartup.start("spring.context.refresh");//准备上下文环境 Prepare this context for refreshing.prepareRefresh();// Tell the subclass to refresh the internal bean factory.// 工厂创建：BeanFactory第一次开始创建的时候,有xml解析逻辑。ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();//给容器中注册了环境信息作为单实例Bean方便后续自动装配；放了一些后置处理器处理（监听、xxAware功能） Prepare the bean factory for use in this context.prepareBeanFactory(beanFactory);try {//留给子类的模板方法，允许子类继续对工厂执行一些处理； Allows post-processing of the bean factory in context subclasses.postProcessBeanFactory(beanFactory);StartupStep beanPostProcess = this.applicationStartup.start("spring.context.beans.post-process");//【大核心】工厂增强：执行所有的BeanFactory后置增强器；利用BeanFactory后置增强器对工厂进行修改或者增强,配置类会在这里进行解析。 Invoke factory processors registered as beans in the context.invokeBeanFactoryPostProcessors(beanFactory);//【核心】注册所有的Bean的后置处理器 Register bean processors that intercept bean creation.registerBeanPostProcessors(beanFactory);beanPostProcess.end();//初始化国际化功能 Initialize message source for this context.initMessageSource();//初始化事件多播功能（事件派发） Initialize event multicaster for this context.initApplicationEventMulticaster();// 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创建；完成 BeanFactory 初始化。（工厂里面所有的组件都好了）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();contextRefresh.end();}}
}

下面我们就来一个一个说明。

一、准备上下文环境

1、保存环境变量信息

// 准备上下文环境
prepareRefresh();

protected void prepareRefresh() {// 修改容器状态为执行状态Switch to active.this.startupDate = System.currentTimeMillis();this.closed.set(false);this.active.set(true);// 其他子容器自行实现（比如：WebApplicationContext） Initialize any placeholder property sources in the context environment.// 这个方法是可以让子类去实现的，每个容器类都会维护一个environment属性，这个属性里面就存储了环境变量的信息，子实现类可以自由重写这个方法来添加属性initPropertySources();//准备环境变量信息 Validate that all properties marked as required are resolvable:// see ConfigurablePropertyResolver#setRequiredProperties// 将环境变量信息添加到属性environment中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<>();
}

这个步骤相对简单，只是准备一些环境变量添加到容器中。

二、工厂创建

1、创建BeanFactory

// 工厂创建：BeanFactory第一次开始创建的时候,有xml解析逻辑。
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {//刷新整个BeanFactory,注解模式下就是准备工厂，设置工厂id；xml模式下会解析xmlrefreshBeanFactory(); return getBeanFactory();
}

@Override
protected final void refreshBeanFactory() throws BeansException {// 如果已经创建工厂了就销毁if (hasBeanFactory()) {destroyBeans();closeBeanFactory();}/** 创建Bean工厂DefaultListableBeanFactory这个DefaultListableBeanFactory类很有意思它实现了SingletonBeanRegistry接口代表它是一个单例池，保存所有单例对象它实现了BeanFactory接口的子接口ListableBeanFactory代表它能根据名称或类型获取BeanDefinition或Bean它实现了BeanDefinitionRegistry接口代表它是一个档案馆，可以获取BeanDefinition*/DefaultListableBeanFactory beanFactory = createBeanFactory(); // 设置序列化IDbeanFactory.setSerializationId(getId());// 可以设置是否允许循环依赖等，作用不大customizeBeanFactory(beanFactory);// 加载BeanDefinitionsloadBeanDefinitions(beanFactory);// 保存IOC容器this.beanFactory = beanFactory;
}

// 创建DefaultListableBeanFactory
protected DefaultListableBeanFactory createBeanFactory() {return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}

2、加载BeanDefinition

// 加载BeanDefinitions
loadBeanDefinitions(beanFactory);

@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {// 创建BeanDefinitionReader准备读取xml内容的读取器 Create a new XmlBeanDefinitionReader for the given BeanFactory. XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);// Configure the bean definition reader with this context's// resource loading environment.// 将环境信息保存到IOC容器中beanDefinitionReader.setEnvironment(this.getEnvironment());// 将IOC容器当作资源加载器传入Reader中准备读取XML文件beanDefinitionReader.setResourceLoader(this); 	beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));// Allow a subclass to provide custom initialization of the reader,// then proceed with actually loading the bean definitions.// 初始化BeanDefinitionReader，主要目的是让子类可以重写来实现自定义Reader的效果initBeanDefinitionReader(beanDefinitionReader);// 真正的加载loadBeanDefinitionloadBeanDefinitions(beanDefinitionReader);
}

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {// 以Resource的格式获取资源，这里默认的getConfigResources()方法默认返回null，留给子类去实现来设置资源位置Resource[] configResources = getConfigResources();if (configResources != null) {reader.loadBeanDefinitions(configResources);}// 这里的configLocations就是我们传进去的配置文件的路径和名称，可以一次传入很多配置文件String[] configLocations = getConfigLocations();if (configLocations != null) {// 读取配置文件并加载BeanDefinitionreader.loadBeanDefinitions(configLocations); }
}

@Override
public int loadBeanDefinitions(String... locations) throws BeanDefinitionStoreException {Assert.notNull(locations, "Location array must not be null");int count = 0;for (String location : locations) { // 加载每一个配置文件里面的内容count += loadBeanDefinitions(location);}return count;
}

public int loadBeanDefinitions(String location, @Nullable Set<Resource> actualResources) throws BeanDefinitionStoreException {// 就是IOC容器ResourceLoader resourceLoader = getResourceLoader();if (resourceLoader instanceof ResourcePatternResolver) {// Resource pattern matching available.// 一般情况下走这里// 将xml资源转换为Resource类Resource[] resources = ((ResourcePatternResolver) resourceLoader).getResources(location);// 加载资源为BeanDefinition的地方int count = loadBeanDefinitions(resources);return count;}else {// Can only load single resources by absolute URL.// 根据URL加载资源的Loader走这里Resource resource = resourceLoader.getResource(location);int count = loadBeanDefinitions(resource);return count;}
}

@Override
public int loadBeanDefinitions(Resource... resources) throws BeanDefinitionStoreException {Assert.notNull(resources, "Resource array must not be null");int count = 0;for (Resource resource : resources) {// 遍历加载每一个BeanDefinitioncount += loadBeanDefinitions(resource);}return count;
}

@Override
public int loadBeanDefinitions(Resource resource) throws BeanDefinitionStoreException {// 装饰器模式装饰了一下资源return loadBeanDefinitions(new EncodedResource(resource));
}

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {// 获取ThreadLocal中的资源SetSet<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();// 将传入的资源添加到Set中if (!currentResources.add(encodedResource)) {throw new BeanDefinitionStoreException("Detected cyclic loading of " + encodedResource + " - check your import definitions!");}try (InputStream inputStream = encodedResource.getResource().getInputStream()) {InputSource inputSource = new InputSource(inputStream);if (encodedResource.getEncoding() != null) {inputSource.setEncoding(encodedResource.getEncoding());}// 处理资源return doLoadBeanDefinitions(inputSource, encodedResource.getResource());} finally {// 处理完后从Set中移除这个资源currentResources.remove(encodedResource);if (currentResources.isEmpty()) {this.resourcesCurrentlyBeingLoaded.remove();}}
}

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource) throws BeanDefinitionStoreException {//利用dom解析工具把xml变成DocumentDocument doc = doLoadDocument(inputSource, resource); // 注册BeanDefinitions到容器中int count = registerBeanDefinitions(doc, resource);return count;
}

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {// 创建Document解析器来解析document对象BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();// 获取IOC容器中BeanDefinitionMap的size()int countBefore = getRegistry().getBeanDefinitionCount();// 读取doc中的内容为BeanDefinition并保存到IOC容器的BeanDefinitionMap中，这里太深入就不看了，设计到DOM解析过程，知道大概就可以了documentReader.registerBeanDefinitions(doc, createReaderContext(resource));return getRegistry().getBeanDefinitionCount() - countBefore;
}

至此所有BeanDefinition就都加载到IOC容器中了。工厂创建过程完成。

三、准备BeanFactory

// 给容器中注册了环境信息作为单实例Bean方便后续自动装配；放了一些后置处理器处理（监听、xxAware功能） Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {// Tell the internal bean factory to use the context's class loader etc.// 设置Bean的类加载器beanFactory.setBeanClassLoader(getClassLoader());if (!shouldIgnoreSpel) { // 解释器模式，配置解析${}的解析器beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));}beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));// Configure the bean factory with context callbacks.// 添加XxxAware接口的执行器，这个执行器负责执行给Bean注入相应的XxxbeanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));// 告诉Spring先别管这些接口，将这些类添加到HashSet集合中// 因为在ApplicationContextAwareProcessor中已经完成了手动注入beanFactory.ignoreDependencyInterface(EnvironmentAware.class); beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);beanFactory.ignoreDependencyInterface(MessageSourceAware.class);beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);beanFactory.ignoreDependencyInterface(ApplicationStartupAware.class);//注册可以解析到的依赖 BeanFactory interface not registered as resolvable type in a plain factory.// MessageSource registered (and found for autowiring) as a bean.beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);beanFactory.registerResolvableDependency(ResourceLoader.class, this);beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);beanFactory.registerResolvableDependency(ApplicationContext.class, this);// Register early post-processor for detecting inner beans as ApplicationListeners.beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));// Detect a LoadTimeWeaver and prepare for weaving, if found.if (!NativeDetector.inNativeImage() && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));// Set a temporary ClassLoader for type matching.beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}// 注册默认单例组件： Register default environment beans.if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());}if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());}if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());}if (!beanFactory.containsLocalBean(APPLICATION_STARTUP_BEAN_NAME)) {beanFactory.registerSingleton(APPLICATION_STARTUP_BEAN_NAME, getApplicationStartup());}
}

这个步骤给BeanFactory做了一些简单处理，比如放置了一些后置处理器类并注入了一些基本单例对象。

四、BeanFactory处理

// 留给子类的模板方法，允许子类继续对工厂执行一些处理；父类没有提供任何方法 Allows post-processing of the bean factory in context subclasses.
// 在标准初始化之后修改应用程序上下文的内部 bean 工厂。所有 bean 定义都将被加载，但还没有 bean 被实例化。这允许在某些 ApplicationContext 实现中注册特殊的 BeanPostProcessors 等。
postProcessBeanFactory(beanFactory);

五、执行BeanFactory后置增强器

//【大核心】工厂增强：执行所有的BeanFactory后置增强器；利用BeanFactory后置增强器对工厂进行修改或者增强,配置类会在这里进行解析。 Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);

protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {// 执行所有的工厂增强器，主要逻辑在这里，目前getBeanFactoryPostProcessors()为nullPostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors()); //上面的类叫：后置处理器的注册代理（门面模式-装饰模式）// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)if (!NativeDetector.inNativeImage() && beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}
}

public static void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory, List<BeanFactoryPostProcessor> beanFactoryPostProcessors) {// Invoke BeanDefinitionRegistryPostProcessors first, if any.// 创建Set集合保存所有处理器BeanSet<String> processedBeans = new HashSet<>();if (beanFactory instanceof BeanDefinitionRegistry) {BeanDefinitionRegistry registry = (BeanDefinitionRegistry) beanFactory;// 常规后置处理器List<BeanFactoryPostProcessor> regularPostProcessors = new ArrayList<>();// 注册的后置处理器List<BeanDefinitionRegistryPostProcessor> registryProcessors = new ArrayList<>();// 先拿到底层默认有的BeanFactoryPostProcessor，默认为nullfor (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； First, invoke the BeanDefinitionRegistryPostProcessors that implement PriorityOrdered.// 先获得实现了BeanDefinitionRegistryPostProcessor接口的后置处理器类的名称列表// 具体获得过程是拿到系统中每一个组件的BeanDefinition信息，进行类型对比，是否匹配指定的类型，如果匹配就添加到result(ArrayList类型)，最后再将result返回String[] postProcessorNames =beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {// 从工厂中获取这个组件【getBean整个组件创建的流程】并放到这个集合currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));processedBeans.add(ppName);}} // 下面利用优先级排序sortPostProcessors(currentRegistryProcessors, beanFactory);registryProcessors.addAll(currentRegistryProcessors);// 执行这些BeanDefinitionRegistryPostProcessor的方法，会在下面介绍invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup()); currentRegistryProcessors.clear();// 接下来，获取所有实现了Ordered接口的 BeanDefinitionRegistryPostProcessor Next, invoke the BeanDefinitionRegistryPostProcessors that implement Ordered.postProcessorNames = beanFactory.getBeanNamesForType(BeanDefinitionRegistryPostProcessor.class, true, false);for (String ppName : postProcessorNames) {// 这里判断一下processedBeans中没有的防止重复执行if (!processedBeans.contains(ppName) && beanFactory.isTypeMatch(ppName, Ordered.class)) {currentRegistryProcessors.add(beanFactory.getBean(ppName, BeanDefinitionRegistryPostProcessor.class));processedBeans.add(ppName); //即使实现了 PriorityOrdered 和Ordered，也是以 PriorityOrdered}}//排序sortPostProcessors(currentRegistryProcessors, beanFactory);registryProcessors.addAll(currentRegistryProcessors);invokeBeanDefinitionRegistryPostProcessors(currentRegistryProcessors, registry, beanFactory.getApplicationStartup()); //执行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);//拿到所有的BeanDefinitionRegistryPostProcessorfor (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, beanFactory.getApplicationStartup());currentRegistryProcessors.clear(); //防止重复执行}// 接下来，再来执行实现BeanDefinitionRegistryPostPrecessor接口的postProcessBeanFactory方法，下面有介绍 Now, invoke the postProcessBeanFactory callback of all processors handled so far.invokeBeanFactoryPostProcessors(registryProcessors, beanFactory);invokeBeanFactoryPostProcessors(regularPostProcessors, beanFactory);}// 以前在执行 BeanDefinitionRegistryPostProcessor ,以后来执行 BeanFactoryPostProcessor// Do not initialize FactoryBeans here: We need to leave all regular beans// uninitialized to let the bean factory post-processors apply to them!// 获取所有实现BeanFactoryProcessor接口的类的定义信息的名字String[] postProcessorNames =beanFactory.getBeanNamesForType(BeanFactoryPostProcessor.class, true, false);// Separate between BeanFactoryPostProcessors that implement PriorityOrdered,// Ordered, and the rest.// 在这里直接创建了三个列表分别存放实现PriorityOrdered、Ordered、没有实现任何接口的对象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);}}// 首先执行所有实现了 PriorityOrdered 的 BeanFactoryPostProcessor；First, invoke the BeanFactoryPostProcessors that implement PriorityOrdered.sortPostProcessors(priorityOrderedPostProcessors, beanFactory);invokeBeanFactoryPostProcessors(priorityOrderedPostProcessors, beanFactory);// 接下来执行，实现了 Ordered 接口的 BeanFactoryPostProcessor  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);// 最后执行没有任何优先级和排序接口的 BeanFactoryPostProcessor 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); //执行所有的 BeanFactoryPostProcessor// Clear cached merged bean definitions since the post-processors might have// modified the original metadata, e.g. replacing placeholders in values...beanFactory.clearMetadataCache();
}

private static void invokeBeanDefinitionRegistryPostProcessors(Collection<? extends BeanDefinitionRegistryPostProcessor> postProcessors, BeanDefinitionRegistry registry, ApplicationStartup applicationStartup) {for (BeanDefinitionRegistryPostProcessor postProcessor : postProcessors) {StartupStep postProcessBeanDefRegistry = applicationStartup.start("spring.context.beandef-registry.post-process").tag("postProcessor", postProcessor::toString);// 核心，配置类的后置处理器会在此执行postProcessBeanDefinitionRegistry方法postProcessor.postProcessBeanDefinitionRegistry(registry); postProcessBeanDefRegistry.end();}
}

private static void invokeBeanFactoryPostProcessors(Collection<? extends BeanFactoryPostProcessor> postProcessors, ConfigurableListableBeanFactory beanFactory) {for (BeanFactoryPostProcessor postProcessor : postProcessors) {StartupStep postProcessBeanFactory = beanFactory.getApplicationStartup().start("spring.context.bean-factory.post-process").tag("postProcessor", postProcessor::toString);postProcessor.postProcessBeanFactory(beanFactory);postProcessBeanFactory.end();}
}

这里是BeanDefinitionRegistryPostProcesser执行postProcessBeanDefinitionRegistry()、postProcessBeanFactory()方法和BeanFactoryPostProcesser执行postProcessBeanFactory()方法的地方，那么我们都知道上一步我们只是将Bean的定义信息添加到IOC容器中，那么我们是怎么将BeanFactory定义信息转换为对象来执行相应的方法呢？主要逻辑在下面这句话

nonOrderedPostProcessors.add(beanFactory.getBean(postProcessorName, BeanFactoryPostProcessor.class));

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)throws BeansException {String beanName = transformedBeanName(name); //转换Bean名字Object beanInstance;// 先检查单实例bean的缓存 Eagerly check singleton cache for manually registered singletons.Object sharedInstance = getSingleton(beanName); //检查缓存中有没有，如果是第一次获取肯定是没有的if (sharedInstance != null && args == null) {if (logger.isTraceEnabled()) {if (isSingletonCurrentlyInCreation(beanName)) {logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +"' that is not fully initialized yet - a consequence of a circular reference");}else {logger.trace("Returning cached instance of singleton bean '" + beanName + "'");}}beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);}else { //默认第一次获取组件都会进入else环节// Fail if we're already creating this bean instance:// We're assumably within a circular reference.if (isPrototypeCurrentlyInCreation(beanName)) {throw new BeanCurrentlyInCreationException(beanName);}// 拿到整个beanFactory的父工厂；看父工厂没有，从父工厂先尝试获取组件； 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);}}if (!typeCheckOnly) {markBeanAsCreated(beanName); //标记当前beanName的bean已经被创建}StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate").tag("beanName", name);try {if (requiredType != null) {beanCreation.tag("beanType", requiredType::toString);}RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);checkMergedBeanDefinition(mbd, beanName, args);// Guarantee initialization of beans that the current bean depends on.String[] dependsOn = mbd.getDependsOn();if (dependsOn != null) {for (String dep : dependsOn) { //看当前Bean有没有依赖其他Beanif (isDependent(beanName, dep)) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");}registerDependentBean(dep, beanName);try {getBean(dep); //依赖了其他bean，就先获取其他的哪些bean}catch (NoSuchBeanDefinitionException ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"'" + beanName + "' depends on missing bean '" + dep + "'", ex);}}}// 创建bean的实例；Create bean instance.if (mbd.isSingleton()) {sharedInstance = getSingleton(beanName, () -> {try {return createBean(beanName, mbd, args);  //创建bean对象的实例}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是否是FactoryBeanbeanInstance = 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 {afterPrototypeCreation(beanName);}beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);}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);}});beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);}catch (IllegalStateException ex) {throw new ScopeNotActiveException(beanName, scopeName, ex);}}}catch (BeansException ex) {beanCreation.tag("exception", ex.getClass().toString());beanCreation.tag("message", String.valueOf(ex.getMessage()));cleanupAfterBeanCreationFailure(beanName);throw ex;}finally {beanCreation.end();}}//转Object为Bean的T类型return adaptBeanInstance(name, beanInstance, requiredType);
}

创建对象的逻辑在后面会涉及到，这里就不作展开了。

六、执行Bean后置增强器

//【核心】注册所有的Bean的后置处理器 Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);

protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {// 主要方法在这里执行PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}

public static void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {// WARNING: Although it may appear that the body of this method can be easily// refactored to avoid the use of multiple loops and multiple lists, the use// of multiple lists and multiple passes over the names of processors is// intentional. We must ensure that we honor the contracts for PriorityOrdered// and Ordered processors. Specifically, we must NOT cause processors to be// instantiated (via getBean() invocations) or registered in the ApplicationContext// in the wrong order.//// Before submitting a pull request (PR) to change this method, please review the// list of all declined PRs involving changes to PostProcessorRegistrationDelegate// to ensure that your proposal does not result in a breaking change:// https://github.com/spring-projects/spring-framework/issues?q=PostProcessorRegistrationDelegate+is%3Aclosed+label%3A%22status%3A+declined%22// 获取到容器中所有的 BeanPostProcessor； Bean的后置处理器String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);// Register BeanPostProcessorChecker that logs an info message when// a bean is created during BeanPostProcessor instantiation, i.e. when// a bean is not eligible for getting processed by all BeanPostProcessors.int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));// Separate between BeanPostProcessors that implement PriorityOrdered,// Ordered, and the rest.List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();List<String> orderedPostProcessorNames = new ArrayList<>();List<String> nonOrderedPostProcessorNames = new ArrayList<>();for (String ppName : postProcessorNames) {if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {  // 获取所有实现了 PriorityOrdered 的 BeanPostProcessor// 从容器中获取组件，如果没有就创建，创建过程中也可能执行Bean后置处理器BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);priorityOrderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {orderedPostProcessorNames.add(ppName);}else {nonOrderedPostProcessorNames.add(ppName);}}// 首先，注册所有的实现了 PriorityOrdered 的 BeanPostProcessor ；就是添加到列表中，优先级越高越添加到前面  First, register the BeanPostProcessors that implement PriorityOrdered.sortPostProcessors(priorityOrderedPostProcessors, beanFactory);registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);// 接下来，注册所有的实现了 Ordered 的 BeanPostProcessor  Next, register the BeanPostProcessors that implement Ordered.List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>(orderedPostProcessorNames.size());for (String ppName : orderedPostProcessorNames) {BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); //获取后置处理器对象orderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}sortPostProcessors(orderedPostProcessors, beanFactory);registerBeanPostProcessors(beanFactory, orderedPostProcessors);// 最后，注册所有普通的 BeanPostProcessor ；Now, register all regular BeanPostProcessors.List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>(nonOrderedPostProcessorNames.size());for (String ppName : nonOrderedPostProcessorNames) {// 从容器中获取这个组件BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class); nonOrderedPostProcessors.add(pp);if (pp instanceof MergedBeanDefinitionPostProcessor) {internalPostProcessors.add(pp);}}registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);//最后，重新注册所有internal的BeanPostProcessors  Finally, re-register all internal BeanPostProcessors.sortPostProcessors(internalPostProcessors, beanFactory);registerBeanPostProcessors(beanFactory, internalPostProcessors);// 重新注册一下这个后置处理器 Re-register post-processor for detecting inner beans as ApplicationListeners,// 把他放到后置处理器的最后一位； moving it to the end of the processor chain (for picking up proxies etc).beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}

七、初始化国际化功能

//初始化事件多播功能（事件派发） Initialize event multicaster for this context.
initApplicationEventMulticaster();

一般情况下用不到。这里不介绍了。

八、初始化事件多播功能（事件派发）

//8初始化事件多播功能（事件派发） Initialize event multicaster for this context.
initApplicationEventMulticaster();

九、初始化特殊Bean

// 初始化特殊Bean
onRefresh();

// 可以重写以添加特定于上下文的刷新工作的模板方法。在单例实例化之前调用特殊 bean 的初始化。这里父类没有给出具体实现，由子类去完成。
protected void onRefresh() throws BeansException {// For subclasses: do nothing by default. 模板模式的实现
}

十、注册监听器

//注册监听器，从容器中获取所有的ApplicationListener； Check for listener beans and register them.
registerListeners();

protected void registerListeners() {//把所有监听器保存到多播器的集合中，初始为null Register statically specified listeners first.for (ApplicationListener<?> listener : getApplicationListeners()) {getApplicationEventMulticaster().addApplicationListener(listener);}// Do not initialize FactoryBeans here: We need to leave all regular beans// 获取ApplicationListener在ioc容器中注册的bean的名字 uninitialized to let post-processors apply to them!String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);for (String listenerBeanName : listenerBeanNames) {getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName); //获取所有的容器中的监听器，并保存他们的名字}//派发之前攒的一些早期事件 Publish early application events now that we finally have a multicaster...Set<ApplicationEvent> earlyEventsToProcess = this.earlyApplicationEvents;this.earlyApplicationEvents = null;if (!CollectionUtils.isEmpty(earlyEventsToProcess)) {for (ApplicationEvent earlyEvent : earlyEventsToProcess) {getApplicationEventMulticaster().multicastEvent(earlyEvent);}}
}

十一、初始化Bean

// Instantiate all remaining (non-lazy-init) singletons.
//【大核心】bean创建；完成 BeanFactory 初始化。（工厂里面所有的组件都好了）
finishBeanFactoryInitialization(beanFactory);

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {// 给工厂设置好 ConversionService【负责类型转换的组件服务】， Initialize conversion service for this context.if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {beanFactory.setConversionService(beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));}// 注册一个默认的值解析器（"${}"）  ；Register a default embedded value resolver if no BeanFactoryPostProcessor// (such as a PropertySourcesPlaceholderConfigurer bean) registered any before:// at this point, primarily for resolution in annotation attribute values.if (!beanFactory.hasEmbeddedValueResolver()) {beanFactory.addEmbeddedValueResolver(strVal -> getEnvironment().resolvePlaceholders(strVal));}// LoadTimeWeaverAware；aspectj：加载时织入功能【aop】。 Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);for (String weaverAwareName : weaverAwareNames) {getBean(weaverAwareName); //从容器中获取组件，有则直接获取，没则进行创建}// Stop using the temporary ClassLoader for type matching.beanFactory.setTempClassLoader(null);// Allow for caching all bean definition metadata, not expecting further changes.beanFactory.freezeConfiguration();// Instantiate all remaining (non-lazy-init) singletons.// 初始化所有的非懒加载的单实例Bean，核心在这里beanFactory.preInstantiateSingletons();
}

@Override
public void preInstantiateSingletons() throws BeansException {if (logger.isTraceEnabled()) {logger.trace("Pre-instantiating singletons in " + this);}// Iterate over a copy to allow for init methods which in turn register new bean definitions.// While this may not be part of the regular factory bootstrap, it does otherwise work fine.// 获取所有BeanNamesList<String> beanNames = new ArrayList<>(this.beanDefinitionNames);// 遍历并创建出所有的单实例Bean；Trigger initialization of all non-lazy singleton beans...for (String beanName : beanNames) {// 开始解析文件的时候每一个bean标签被解析封装成一个BeanDefinitionRootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {// 如果是FactoryBean则执行下面逻辑if (isFactoryBean(beanName)) { Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); //得到HelloFactoryif (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);}}}// 不是FactoryBean则执行这个,普通的单实例非懒加载bean的创建，下面会介绍getBean方法else { getBean(beanName);}}}// 触发 post-initialization 逻辑；  Trigger post-initialization callback for all applicable beans...for (String beanName : beanNames) {Object singletonInstance = getSingleton(beanName);if (singletonInstance instanceof SmartInitializingSingleton) {StartupStep smartInitialize = this.getApplicationStartup().start("spring.beans.smart-initialize").tag("beanName", beanName);SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;if (System.getSecurityManager() != null) {AccessController.doPrivileged((PrivilegedAction<Object>) () -> {smartSingleton.afterSingletonsInstantiated();return null;}, getAccessControlContext());}else {smartSingleton.afterSingletonsInstantiated();}smartInitialize.end();}}
}

@Override
public Object getBean(String name) throws BeansException {return doGetBean(name, null, null, false);
}

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)throws BeansException {String beanName = transformedBeanName(name); //转换Bean名字Object beanInstance;// 先检查单实例bean的缓存一级、二级、三级缓存 Eagerly check singleton cache for manually registered singletons.Object sharedInstance = getSingleton(beanName); //检查缓存中有没有，如果是第一次获取肯定是没有的if (sharedInstance != null && args == null) {if (logger.isTraceEnabled()) {if (isSingletonCurrentlyInCreation(beanName)) {logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +"' that is not fully initialized yet - a consequence of a circular reference");}else {logger.trace("Returning cached instance of singleton bean '" + beanName + "'");}}beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);}else { //默认第一次获取组件都会进入else环节// Fail if we're already creating this bean instance:// We're assumably within a circular reference.if (isPrototypeCurrentlyInCreation(beanName)) {throw new BeanCurrentlyInCreationException(beanName);}// 拿到整个beanFactory的父工厂；看父工厂没有，从父工厂先尝试获取组件； 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);}}if (!typeCheckOnly) {// 标记当前beanName的bean已经被创建markBeanAsCreated(beanName); }try {// 获取bean定义信息RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);checkMergedBeanDefinition(mbd, beanName, args);// Guarantee initialization of beans that the current bean depends on.// 获取当前定义信息所依赖的定义信息，先将依赖的Bean加载String[] dependsOn = mbd.getDependsOn();if (dependsOn != null) {for (String dep : dependsOn) { registerDependentBean(dep, beanName);//依赖了其他bean，就先获取其他的哪些beangetBean(dep); }}// 创建bean的实例；Create bean instance.if (mbd.isSingleton()) {// 核心方法是getSingletonsharedInstance = getSingleton(beanName, () -> {try {return createBean(beanName, mbd, args);  //创建bean对象的实例}}); //看当前bean是否是FactoryBeanbeanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);}// 创建多例Bean的实例else if (mbd.isPrototype()) {// It's a prototype -> create a new instance.Object prototypeInstance = null;try {beforePrototypeCreation(beanName);prototypeInstance = createBean(beanName, mbd, args);}finally {afterPrototypeCreation(beanName);}beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);}// 如果是其他作用域就调用其他作用域的方法else {String scopeName = mbd.getScope();Scope scope = this.scopes.get(scopeName);try {Object scopedInstance = scope.get(beanName, () -> {beforePrototypeCreation(beanName);try {return createBean(beanName, mbd, args);}finally {afterPrototypeCreation(beanName);}});beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);}}}finally {beanCreation.end();}}//转Object为Bean的T类型return adaptBeanInstance(name, beanInstance, requiredType);
}

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {synchronized (this.singletonObjects) {// 先从单例池中获取Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) { // 单实例池子里面没有当前对象（说明没有创建完成）// 单实例创建之前，没什么作用，让子类去重写的模板方法beforeSingletonCreation(beanName);boolean newSingleton = false;boolean recordSuppressedExceptions = (this.suppressedExceptions == null);if (recordSuppressedExceptions) {this.suppressedExceptions = new LinkedHashSet<>();}try {// 会调用lamda表达式的内容，真正创建对象，核心在这里singletonObject = singletonFactory.getObject();newSingleton = true;}finally {if (recordSuppressedExceptions) {this.suppressedExceptions = null;}afterSingletonCreation(beanName);}if (newSingleton) {// 添加到单例池中addSingleton(beanName, singletonObject);}}return singletonObject;}
}

sharedInstance = getSingleton(beanName, () -> {try {return createBean(beanName, mbd, args);  //创建bean对象的实例}
}); 

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {RootBeanDefinition mbdToUse = mbd;// Make sure bean class is actually resolved at this point, and// clone the bean definition in case of a dynamically resolved Class// which cannot be stored in the shared merged bean definition.Class<?> resolvedClass = resolveBeanClass(mbd, beanName);if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {mbdToUse = new RootBeanDefinition(mbd);mbdToUse.setBeanClass(resolvedClass);}// Prepare method overrides.// 准备方法覆盖try {mbdToUse.prepareMethodOverrides();}try {//（即使AOP的BeanPostProcessor都不会珍惜这个机会） 提前给我们一个机会，去返回组件的代理对象。 Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.// 如果有实现了InstantiationAwareBeanPostProcessor接口的类就会去执行，返回这个类中一个方法返回的对象替换Bean。Object bean = resolveBeforeInstantiation(beanName, mbdToUse);if (bean != null) {return bean;}}try { // Spring真正自己创建对象，核心方法Object beanInstance = doCreateBean(beanName, mbdToUse, args);return beanInstance;}
}

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)throws BeanCreationException {// Instantiate the bean.BeanWrapper instanceWrapper = null;if (mbd.isSingleton()) { // 从缓存中移除这个单例对象instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);}if (instanceWrapper == null) {// 创建Bean的实例,默认使用无参构造器创建的对象，组件的原始对象就创建了// 在这里SmartInstantiationAwareBeanPostProcessor起作用了，可以决定使用哪个构造器instanceWrapper = createBeanInstance(beanName, mbd, args);}Object bean = instanceWrapper.getWrappedInstance();Class<?> beanType = instanceWrapper.getWrappedClass();if (beanType != NullBean.class) {mbd.resolvedTargetType = beanType;}// 允许 后置处理器 再来修改下beanDefinition；// 这里到 MergedBeanDefinitionPostProcessor起作用了  MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition；；   Allow post-processors to modify the merged bean definition.synchronized (mbd.postProcessingLock) {if (!mbd.postProcessed) {try {applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);}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) {//三级缓存中的Bean也会被后置处理来增强，addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean)); }// Initialize the bean instance.Object exposedObject = bean;try {// 给创建好的对象每个属性进行赋值，@Autowired发生在这里// 在这里InstantiationAwareBeanPostProcessor起作用了，// 这里先调用Processor的postProcessAfterInstantiation方法// 之后赋值根据XML指定的，再之后就是Processor的postProcessProperties方法给属性自动注入赋值populateBean(beanName, mbd, instanceWrapper); // 初始化bean，在这里如果组件实现了XxxAware接口就会向里面注入值// 之后会执行BeanPostProcessor的postProcessBeforeInitialization方法// 之后会执行Bean的初始化方法afterPropertiesSet（如果实现了InitializingBean接口）// 最后会执行BeanPostProcessor的postProcessAfterInitialization方法exposedObject = initializeBean(beanName, exposedObject, mbd);}//早期单实例暴露if (earlySingletonExposure) {// 检查早期缓存中是否存在这个组件Object earlySingletonReference = getSingleton(beanName, false); if (earlySingletonReference != null) {if (exposedObject == bean) {exposedObject = earlySingletonReference;}else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {String[] dependentBeans = getDependentBeans(beanName);Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);for (String dependentBean : dependentBeans) {if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {actualDependentBeans.add(dependentBean);}}}}}// Register bean as disposable.try {registerDisposableBeanIfNecessary(beanName, bean, mbd);}// 返回这个实例，对象创建过程至此完毕return exposedObject;
}

十二、发布事件

//12发布事件 Last step: publish corresponding event.
finishRefresh();

protected void finishRefresh() {// Clear context-level resource caches (such as ASM metadata from scanning).clearResourceCaches();// Initialize lifecycle processor for this context.initLifecycleProcessor();//告诉LifecycleProcessor容器onRefresh Propagate refresh to lifecycle processor first.getLifecycleProcessor().onRefresh();//发布事件 Publish the final event.publishEvent(new ContextRefreshedEvent(this)); //发布上下文环境刷新完成的事件//jconsole（暴露MBean端点信息） Participate in LiveBeansView MBean, if active.if (!NativeDetector.inNativeImage()) {LiveBeansView.registerApplicationContext(this);}
}

其他问题

1、循环依赖的解决

spring解决循环依赖是通过缓存来实现的，我们假定类A与类B相互依赖，当容器给类A创建单例对象时首先根据默认无参构造器创建出来一个对象，这时候将这个对象a添加到缓存中，之后给a的属性赋值，赋值过程通过后置处理器来完成，其中给a的属性b赋值时也调用beanFactory.getBean(b)方法，之后也会利用无参构造器创建出来一个对象b，这时候将对象b添加到缓存中，之后给b的属性赋值，其中给属性a赋值时也会调用beanFactory.getBean(a)方法，这时候获取对象a时首先判断缓存中有没有，显然之前已经添加到缓存中了，所以我们可以直接获取对象a，这样就解决了循环依赖问题。

2、AOP功能的实现

实现AOP功能重要的是要在配置类上加入@EnableAspectJAutoProxy注解，之后在增强功能类上添加@Aspect注解代表这是一个切面，之后在切面中编写增强逻辑。代码如下：

@EnableAspectJAutoProxy //开启自动代理
@Configuration
public class AopOpenConfig {}

@Component  //切面也是容器中的组件
@Aspect //说明这是切面
public class LogAspect {public LogAspect(){System.out.println("LogAspect...");}//前置通知  增强方法/增强器@Before("execution(* com.atguigu.spring.aop.HelloService.sayHello(..))")public void logStart(JoinPoint joinPoint){String name = joinPoint.getSignature().getName();System.out.println("logStart()==>"+name+"....【args: "+ Arrays.asList(joinPoint.getArgs()) +"】");}//返回通知@AfterReturning(value = "execution(* com.atguigu.spring.aop.HelloService.sayHello(..))",returning = "result")public void logReturn(JoinPoint joinPoint,Object result){String name = joinPoint.getSignature().getName();System.out.println("logReturn()==>"+name+"....【args: "+ Arrays.asList(joinPoint.getArgs()) +"】【result: "+result+"】");}//后置通知@After("execution(* com.atguigu.spring.aop.HelloService.sayHello(..))")public void logEnd(JoinPoint joinPoint){String name = joinPoint.getSignature().getName();System.out.println("logEnd()==>"+name+"....【args: "+ Arrays.asList(joinPoint.getArgs()) +"】");}//异常@AfterThrowing(value = "execution(* com.atguigu.spring.aop.HelloService.sayHello(..))",throwing = "e")public void logError(JoinPoint joinPoint,Exception e){String name = joinPoint.getSignature().getName();System.out.println("logError()==>"+name+"....【args: "+ Arrays.asList(joinPoint.getArgs()) +"】【exception: "+e+"】");}
}

那么为什么我们在配置类中添加@EnableAspectJAutoProxy注解就开始了AOP功能呢，我们先看一下这个注解的组成

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {}

其中最重要的是我们向容器中添加了org.springframework.aop.config.InternalAutoProxyCreator类型（是一个BeanPostProcesser）的beanDefinition。这个添加过程是容器十二大步之工厂增强阶段解析配置类时添加的。

本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！