Spring学习(三十五)-Spring容器创建流程-05

╰半夏微凉° 2024-02-19 16:14 12阅读 0赞

11.finishBeanFactoryInitialization(beanFactory);

初始化所有剩下的单实例bean,单例bean在初始化容器时创建,懒加载在调用的时候创建。

//初始化所有剩下的单实例bean
    protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    	。。。。。。。。。。。。。。。
    	//初始化 LoadTimeWeaverAware信息
    	// Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early.
    	String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
    	for (String weaverAwareName : weaverAwareNames) {
    		//创建LoadTimeWeaverAware对象
    		getBean(weaverAwareName);
    	}
         。。。。。。。。。。。。。。。
    	// 初始化后剩下的单实例bean
    	beanFactory.preInstantiateSingletons();
    }
    @Override
    public void preInstantiateSingletons() throws BeansException {
    	if (this.logger.isDebugEnabled()) {
    		this.logger.debug("Pre-instantiating singletons in " + this);
    	}
    
    	//获取Bean的定义信息；RootBeanDefinition
    	List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);
    
    	// Trigger initialization of all non-lazy singleton beans...
    	for (String beanName : beanNames) {
    		RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
    		//判断是否是FactoryBean；是否是实现FactoryBean接口的Bean；
    		if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
    			if (isFactoryBean(beanName)) {
    				final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
    				boolean isEagerInit;
    				if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
    					isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
    						@Override
    						public Boolean run() {
    							return ((SmartFactoryBean<?>) factory).isEagerInit();
    						}
    					}, getAccessControlContext());
    				}
    				else {
    					isEagerInit = (factory instanceof SmartFactoryBean &&
    							((SmartFactoryBean<?>) factory).isEagerInit());
    				}
    				if (isEagerInit) {
    					//获取bean
    					getBean(beanName);
    				}
    			}
    			else {
    				//不是工厂Bean。利用getBean(beanName);创建对象
    				getBean(beanName);
    			}
    		}
    	}
    
    	// 触发所有适用bean的初始化后回调。..
    	for (String beanName : beanNames) {
    		。。。。。。。。。。。。。。。。。。
    	}
    }
    //获取bean
    @Override
    public Object getBean(String name) throws BeansException {
    	return doGetBean(name, null, null, false);
    }
    //获取bean
    protected <T> T doGetBean(
    			final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
    			throws BeansException {
    
    	final String beanName = transformedBeanName(name);
    	Object bean;
    
    	//先获取缓存中保存的单实例Bean。如果能获取到说明这个Bean之前被创建过（所有创建过的单实例Bean都会被缓存起来）
    	Object sharedInstance = getSingleton(beanName);
    	if (sharedInstance != null && args == null) {
    		if (logger.isDebugEnabled()) {
    			if (isSingletonCurrentlyInCreation(beanName)) {
    				logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
    						"' that is not fully initialized yet - a consequence of a circular reference");
    			}
    			else {
    				logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
    			}
    		}
    		bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    	}
    
    	else {
    		// Fail if we're already creating this bean instance:
    		// We're assumably within a circular reference.
    		if (isPrototypeCurrentlyInCreation(beanName)) {
    			throw new BeanCurrentlyInCreationException(beanName);
    		}
    
    		// 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 (args != null) {
    				// Delegation to parent with explicit args.
    				return (T) parentBeanFactory.getBean(nameToLookup, args);
    			}
    			else {
    				// No args -> delegate to standard getBean method.
    				return parentBeanFactory.getBean(nameToLookup, requiredType);
    			}
    		}
    
    		if (!typeCheckOnly) {
    			markBeanAsCreated(beanName);
    		}
    
    		try {
    			
    			final 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) {
    					if (isDependent(beanName, dep)) {
    						throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    								"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
    					}
    					registerDependentBean(dep, beanName);
    					getBean(dep);
    				}
    			}
    
    			//判断是否是单实例
    			if (mbd.isSingleton()) {
    				sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
    					@Override
    					public Object getObject() throws BeansException {
    						try {
    							//创建单实例对象
    							return createBean(beanName, mbd, args);
    						}
    						catch (BeansException ex) {
    							//销毁单实例
    							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 {
    					afterPrototypeCreation(beanName);
    				}
    				bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
    			}
    
    			else {
    				String scopeName = mbd.getScope();
    				final 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, new ObjectFactory<Object>() {
    						@Override
    						public Object getObject() throws BeansException {
    							beforePrototypeCreation(beanName);
    							try {
    								
    								return createBean(beanName, mbd, args);
    							}
    							finally {
    								afterPrototypeCreation(beanName);
    							}
    						}
    					});
    					bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
    				}
    				catch (IllegalStateException ex) {
    					throw new BeanCreationException(beanName,
    							"Scope '" + scopeName + "' is not active for the current thread; consider " +
    							"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
    							ex);
    				}
    			}
    		}
    		catch (BeansException ex) {
    			cleanupAfterBeanCreationFailure(beanName);
    			throw ex;
    		}
    	}
        //检查类型匹配
    	// Check if required type matches the type of the actual bean instance.
    	if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
    		try {
    			return getTypeConverter().convertIfNecessary(bean, requiredType);
    		}
    		。。。。。。。
    	}
    	return (T) bean;
    }
    创建单实例对象
    @Override
    protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    	if (logger.isDebugEnabled()) {
    		logger.debug("Creating instance of bean '" + beanName + "'");
    	}
    	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();
    	}
    	catch (BeanDefinitionValidationException ex) {
    		throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
    				beanName, "Validation of method overrides failed", ex);
    	}
    
    	try {
    		//让BeanPostProcessor先拦截返回代理对象，
    		Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
    		//对象存在执行对象后置处理器，返回对象。
    		if (bean != null) {
    			return bean;
    		}
    	}
    	catch (Throwable ex) {
    		throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
    				"BeanPostProcessor before instantiation of bean failed", ex);
    	}
        //如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象；调用doCreateBean）
    	//创建bean对象 进行初始化
    	Object beanInstance = doCreateBean(beanName, mbdToUse, args);
    	if (logger.isDebugEnabled()) {
    		logger.debug("Finished creating instance of bean '" + beanName + "'");
    	}
    	return beanInstance;
    }
    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.
    		if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
    			Class<?> targetType = determineTargetType(beanName, mbd);
    			if (targetType != null) {
    				//先触发：postProcessBeforeInstantiation()；
    				bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
    				if (bean != null) {
    					//如果有返回值：触发postProcessAfterInitialization()；
    					bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
    				}
    			}
    		}
    		mbd.beforeInstantiationResolved = (bean != null);
    	}
    	return bean;
    }
    //初始化之前的后置处理器
    protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
    	for (BeanPostProcessor bp : getBeanPostProcessors()) {
    		if (bp instanceof InstantiationAwareBeanPostProcessor) {
    			InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
    			//bean后置处理器
    			Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
    			if (result != null) {
    				return result;
    			}
    		}
    	}
    	return null;
    }
    //初始化之后的后置处理器
    @Override
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
    		throws BeansException {
    
    	Object result = existingBean;
    	for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
    		//bean后置处理器
    		result = beanProcessor.postProcessAfterInitialization(result, beanName);
    		if (result == null) {
    			return result;
    		}
    	}
    	return result;
    }
    //创建bean对象 进行初始化
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
    		throws BeanCreationException {
    
    	// Instantiate the bean.
    	BeanWrapper instanceWrapper = null;
    	if (mbd.isSingleton()) {
    		//利用工厂方法创建出Bean实例
    		instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    	}
    	if (instanceWrapper == null) {
    		//利用对象的构造器创建出Bean实例
    		instanceWrapper = createBeanInstance(beanName, mbd, args);
    	}
    	final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    	Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
    	mbd.resolvedTargetType = beanType;
    
    	// Allow post-processors to modify the merged bean definition.
    	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.isDebugEnabled()) {
    			logger.debug("Eagerly caching bean '" + beanName +
    					"' to allow for resolving potential circular references");
    		}
    		addSingletonFactory(beanName, new ObjectFactory<Object>() {
    			@Override
    			public Object getObject() throws BeansException {
    				return getEarlyBeanReference(beanName, mbd, bean);
    			}
    		});
    	}
    
    	// Initialize the bean instance.
    	Object exposedObject = bean;
    	try {
    		//Bean属性赋值
    		populateBean(beanName, mbd, instanceWrapper);
    		if (exposedObject != null) {
    			//初始化
    			exposedObject = initializeBean(beanName, exposedObject, mbd);
    		}
    	}
    	。。。。。。。。。。。。。。。
    	}
       //将创建的Bean添加到缓存中singletonObjects；
    	if (earlySingletonExposure) {
    		。。。。。。。。。。
    	}
    
    	// Register bean as disposable.
    	try {
    		//注册bean是一次性的
    		registerDisposableBeanIfNecessary(beanName, bean, mbd);
    	}
    	catch (BeanDefinitionValidationException ex) {
    		throw new BeanCreationException(
    				mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    	}
    
    	return exposedObject;
    }
    protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
    	if (System.getSecurityManager() != null) {
    		 //规则验证
    		AccessController.doPrivileged(new PrivilegedAction<Object>() {
    			@Override
    			public Object run() {
    				invokeAwareMethods(beanName, bean);
    				return null;
    			}
    		}, getAccessControlContext());
    	}
    	else {
    		invokeAwareMethods(beanName, bean);
    	}
    
    	Object wrappedBean = bean;
    	if (mbd == null || !mbd.isSynthetic()) {
    		//赋值之前：执行后置处理器初始化之前
    		wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    	}
    
    	try {
    		//执行初始化方法
    		invokeInitMethods(beanName, wrappedBean, mbd);
    	}
    	catch (Throwable ex) {
    		throw new BeanCreationException(
    				(mbd != null ? mbd.getResourceDescription() : null),
    				beanName, "Invocation of init method failed", ex);
    	}
    
    	if (mbd == null || !mbd.isSynthetic()) {
    		//赋值之后   执行后置处理器初始化之后
    		wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    	}
    	return wrappedBean;
    }
    //【执行Aware接口方法】invokeAwareMethods(beanName, bean);执行xxxAware接口的方法
    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) {
    			((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
    		}
    		if (bean instanceof BeanFactoryAware) {
    			((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
    		}
    	}
    }
    //执行初始化方法
    protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
    			throws Throwable {
        //是否是InitializingBean接口的实现；执行接口规定的初始化
    	boolean isInitializingBean = (bean instanceof InitializingBean);
    	if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
    		if (logger.isDebugEnabled()) {
    			logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
    		}
    		if (System.getSecurityManager() != null) {
    			try {
    				AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
    					@Override
    					public Object run() throws Exception {
    						((InitializingBean) bean).afterPropertiesSet();
    						return null;
    					}
    				}, getAccessControlContext());
    			}
    			catch (PrivilegedActionException pae) {
    				throw pae.getException();
    			}
    		}
    		else {
    			((InitializingBean) bean).afterPropertiesSet();
    		}
    	}
         //是否自定义初始化方法
    	if (mbd != null) {
    		String initMethodName = mbd.getInitMethodName();
    		if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
    				!mbd.isExternallyManagedInitMethod(initMethodName)) {
    			invokeCustomInitMethod(beanName, bean, mbd);
    		}
    	}
    }

总结：

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();  
1、doGetBean(name, null, null, false);  
2、先获取缓存中保存的单实例Bean。如果能获取到说明这个Bean之前被创建过（所有创建过的单实例Bean都会被缓存起来）  
从private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);获取的  
3、缓存中获取不到，开始Bean的创建对象流程；  
4、标记当前bean已经被创建  
5、获取Bean的定义信息；  
6、【获取当前Bean依赖的其他Bean;如果有按照getBean()把依赖的Bean先创建出来；】  
7、启动单实例Bean的创建流程；  
1）、createBean(beanName, mbd, args);  
2）、Object bean = resolveBeforeInstantiation(beanName, mbdToUse);让BeanPostProcessor先拦截返回代理对象；  
【InstantiationAwareBeanPostProcessor】：提前执行；  
先触发：postProcessBeforeInstantiation()；  
如果有返回值：触发postProcessAfterInitialization()；  
3）、如果前面的InstantiationAwareBeanPostProcessor没有返回代理对象；调用4）  
4）、Object beanInstance = doCreateBean(beanName, mbdToUse, args);创建Bean  
1）、【创建Bean实例】；createBeanInstance(beanName, mbd, args);  
利用工厂方法或者对象的构造器创建出Bean实例；  
2）、applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);  
调用MergedBeanDefinitionPostProcessor的postProcessMergedBeanDefinition(mbd, beanType, beanName);  
3）、【Bean属性赋值】populateBean(beanName, mbd, instanceWrapper);  
赋值之前：  
1）、拿到InstantiationAwareBeanPostProcessor后置处理器；  
postProcessAfterInstantiation()；  
2）、拿到InstantiationAwareBeanPostProcessor后置处理器；  
postProcessPropertyValues()；  
=====赋值之前：===  
3）、应用Bean属性的值；为属性利用setter方法等进行赋值；  
applyPropertyValues(beanName, mbd, bw, pvs);  
4）、【Bean初始化】initializeBean(beanName, exposedObject, mbd);  
1）、【执行Aware接口方法】invokeAwareMethods(beanName, bean);执行xxxAware接口的方法  
BeanNameAware\\BeanClassLoaderAware\\BeanFactoryAware  
2）、【执行后置处理器初始化之前】applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);  
BeanPostProcessor.postProcessBeforeInitialization（）;  
3）、【执行初始化方法】invokeInitMethods(beanName, wrappedBean, mbd);  
1）、是否是InitializingBean接口的实现；执行接口规定的初始化；  
2）、是否自定义初始化方法；  
4）、【执行后置处理器初始化之后】applyBeanPostProcessorsAfterInitialization  
BeanPostProcessor.postProcessAfterInitialization()；  
5）、注册Bean的销毁方法；  
5）、将创建的Bean添加到缓存中singletonObjects；  
 ioc容器就是这些Map；很多的Map里面保存了单实例Bean，环境信息。。。。；所有Bean都利用getBean创建完成以后；检查所有的Bean是否是SmartInitializingSingleton接口的；如果是；就执行afterSingletonsInstantiated()；

12.finishRefresh();：完成BeanFactory的初始化创建工作，IOC容器就创建完成；

protected void finishRefresh() {
    	//初始化和生命周期有关的后置处理器；LifecycleProcessor
    	initLifecycleProcessor();
    
    	// 回调实现了LifecycleProcessor接口的自类方法： onRefresh()。
       //回调生命周期处理器
    	getLifecycleProcessor().onRefresh();
    
    	// 发布容器刷新完成事件；ContextRefreshedEvent
    	publishEvent(new ContextRefreshedEvent(this));
    
    	// Participate in LiveBeansView MBean, if active.
    	LiveBeansView.registerApplicationContext(this);
    }
    //初始化生命周期的后置处理器
    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.isDebugEnabled()) {
    			logger.debug("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.isDebugEnabled()) {
    			logger.debug("Unable to locate LifecycleProcessor with name '" +
    					LIFECYCLE_PROCESSOR_BEAN_NAME +
    					"': using default [" + this.lifecycleProcessor + "]");
    		}
    	}
    }	
    LifecycleProcessor getLifecycleProcessor() throws IllegalStateException {
    	if (this.lifecycleProcessor == null) {
    		throw new IllegalStateException("LifecycleProcessor not initialized - " +
    				"call 'refresh' before invoking lifecycle methods via the context: " + this);
    	}
    	return this.lifecycleProcessor;
    }
    //发布事件
    protected void publishEvent(Object event, ResolvableType eventType) {
    	Assert.notNull(event, "Event must not be null");
    	if (logger.isTraceEnabled()) {
    		logger.trace("Publishing event in " + getDisplayName() + ": " + event);
    	}
    
    	// Decorate event as an ApplicationEvent if necessary
    	ApplicationEvent applicationEvent;
    	if (event instanceof ApplicationEvent) {
    		applicationEvent = (ApplicationEvent) event;
    	}
    	else {
    		applicationEvent = new PayloadApplicationEvent<Object>(this, event);
    		if (eventType == null) {
    			eventType = ((PayloadApplicationEvent)applicationEvent).getResolvableType();
    		}
    	}
    
    	// Multicast right now if possible - or lazily once the multicaster is initialized
    	if (this.earlyApplicationEvents != null) {
    		this.earlyApplicationEvents.add(applicationEvent);
    	}
    	else {
    		//发布容器刷新完成事件
    		getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
    	}
    
    	// Publish event via parent context as well...
    	if (this.parent != null) {
    		if (this.parent instanceof AbstractApplicationContext) {
    			((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
    		}
    		else {
    			this.parent.publishEvent(event);
    		}
    	}
    }
    //注册上下文容器，用于后续使用
    static void registerApplicationContext(ConfigurableApplicationContext applicationContext) {
    	//String MBEAN_DOMAIN_PROPERTY_NAME = "spring.liveBeansView.mbeanDomain";
    	String mbeanDomain = applicationContext.getEnvironment().getProperty(MBEAN_DOMAIN_PROPERTY_NAME);
    	if (mbeanDomain != null) {
    		synchronized (applicationContexts) {
    			if (applicationContexts.isEmpty()) {
    				try {
    					MBeanServer server = ManagementFactory.getPlatformMBeanServer();
    					applicationName = applicationContext.getApplicationName();
    					server.registerMBean(new LiveBeansView(),
    							new ObjectName(mbeanDomain, MBEAN_APPLICATION_KEY, applicationName));
    				}
    				catch (Throwable ex) {
    					throw new ApplicationContextException("Failed to register LiveBeansView MBean", ex);
    				}
    			}
    			applicationContexts.add(applicationContext);
    		}
    	}
    }

总结：

12、finishRefresh();完成BeanFactory的初始化创建工作；IOC容器就创建完成；  
1）、initLifecycleProcessor();初始化和生命周期有关的后置处理器；LifecycleProcessor  
默认从容器中找是否有lifecycleProcessor的组件【LifecycleProcessor】；如果没有new DefaultLifecycleProcessor();  
加入到容器；  
  
写一个LifecycleProcessor的实现类，可以在BeanFactory  
void onRefresh();  
void onClose();  
2）、 getLifecycleProcessor().onRefresh();  
拿到前面定义的生命周期处理器（BeanFactory）；回调onRefresh()；  
3）、publishEvent(new ContextRefreshedEvent(this));发布容器刷新完成事件；  
4）、liveBeansView.registerApplicationContext(this);

Spring容器创建完成：

总结：

（1）、Spring容器在启动的时候，先会保存所有注册进来的Bean的定义信息；
         1）、xml注册bean；<bean>
         2）、注解注册Bean；@Service、@Component、@Bean、xxx
    （2）、Spring容器会合适的时机创建这些Bean
         1）、用到这个bean的时候；利用getBean创建bean；创建好以后保存在容器中；
         2）、统一创建剩下所有的bean的时候；finishBeanFactoryInitialization()；
    （3）、后置处理器；BeanPostProcessor
         1）、每一个bean创建完成，都会使用各种后置处理器进行处理；来增强bean的功能；
              AutowiredAnnotationBeanPostProcessor:处理自动注入
              AnnotationAwareAspectJAutoProxyCreator:来做AOP功能；
              xxx....
             增强的功能注解：
               AsyncAnnotationBeanPostProcessor
            ....
    （4）、事件驱动模型；
        ApplicationListener；事件监听；
        ApplicationEventMulticaster；事件派发：