Spring源码---ApplicationContext的抽象实现

导语

接着上一篇，继续看看spring源码，再菜也要坚持看完！

ConfigurationApplicationContext

CAC接口中的属性和方法：

从上图可以看出，属性和方法基本都是对上下文的配置和系统自带bean 的名字，值得注意的是getBeanFactroy()方法与AC接口的方法同名，同参，返回值类型不同但具有继承关系。还有就是refresh()方法，看了看方法上的注释，大致是想我们使用这个方法通过配置文件来加载或来刷新 persistent representation (大概就是配置的bean吧)。

AbstractApplicationContext

AAC是第一个实现spring上下文接口的抽象类，由于接口中累积了大量的方法，本着单一职责的设计思路，把功能细化，然后通过代理模式分配出去，而自身主要是对CAC和AC本身的方法进行实现。我们暂且忽略被代理出去的方法，因为在本类中也无法看出其具体实现，先看看类中的属性：

可以看出现在spring的上下文已经具备一些实质性的东西了，也就是上面的这些属性，实现的接口也基本基于这些属性的操作方法。由于类中方法数太多，绝大部分分都是通过代理或组合模式来实现的，就不进行截图也暂且丢一边，主要看refresh()方法的实现。

 // Prepare this context for refreshing. prepareRefresh(); // Tell the subclass to refresh the internal bean factory. ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory(); // Prepare the bean factory for use in this context. prepareBeanFactory(beanFactory); // Allows post-processing of the bean factory in context subclasses. postProcessBeanFactory(beanFactory); // Invoke factory processors registered as beans in the context. invokeBeanFactoryPostProcessors(beanFactory); // Register bean processors that intercept bean creation. registerBeanPostProcessors(beanFactory); // Initialize message source for this context. initMessageSource(); // Initialize event multicaster for this context. initApplicationEventMulticaster(); // Initialize other special beans in specific context subclasses. onRefresh(); // Check for listener beans and register them. registerListeners(); // Instantiate all remaining (non-lazy-init) singletons. finishBeanFactoryInitialization(beanFactory); // Last step: publish corresponding event. finishRefresh();

上面是refresh()方法的主要代码，里面调用的方法名称跟其目的是一致的，perpareRefresh()是设置active，closed，startTime属性和初始化earlyApplicationEventj集合用于准备工作。由于BeanFactory使用是抽象代理，并没有明确到具体实例，obtainFreshBeanFactroy()则是告诉子类，要开始refresh了你得准备一下并把BeanFactory返回给我。从子类中得到BeanFactory后，perpareBeanFactory()开始对BeanFactory添加一些标准化设置及注册系统bean,截取方法中的注释。

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { // Tell the internal bean factory to use the context's class loader etc. // Configure the bean factory with context callbacks. // BeanFactory interface not registered as resolvable type in a plain factory. // MessageSource registered (and found for autowiring) as a bean.; // Register early post-processor for detecting inner beans as ApplicationListeners. // Detect a LoadTimeWeaver and prepare for weaving, if found. if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { // Set a temporary ClassLoader for type matching. } // Register default environment beans. }

到这里，BeanFactory的准备工作和初始化设置基本完成了，spring的容器也就已经准备好了，对于容器这个概念，也比较抽象，我也只是简单的将其理解为里面存放了很多类的实例对象，当你需要的时候就只需要去容器中拿，显然这些对象应该是无状态的。容器存在与context中的，context则是借助容器来实现对对象实例的共享管理。
BeanFactory创建好了，我们还需要往里面注册processors，用于对bean进行操作处理，毕竟工厂是工厂，有工人之后工厂才能发挥其能力。同时，消息资源和事件监听和推送也是属于共享且无状态的对象，也可以初始化后放入容器中，这些操作便在registerBeanPostProcessors(),initMessageSource(),initApplicationEventMulticaster()。

/** * Modify the application context's internal bean factory after its standard * initialization. All bean definitions will have been loaded, but no beans * will have been instantiated yet. This allows for registering special * BeanPostProcessors etc in certain ApplicationContext implementations. * @param beanFactory the bean factory used by the application context */ protected void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) { }

postProcessBeanFactory()方法并没有一行代码，注释中也表明，在BeanFactory标准化后允许子类覆盖这个方法，来使BeanFactory能操作自定义或特殊的Bean。

/** * Template method which can be overridden to add context-specific refresh work. * Called on initialization of special beans, before instantiation of singletons. * <p>This implementation is empty. * @throws BeansException in case of errors * @see #refresh() */ protected void onRefresh() throws BeansException { // For subclasses: do nothing by default. }

onfresh()方法也是空，这部分也将陪分配到子类中，具体解释看注释吧。

protected void registerListeners() { // Register statically specified listeners first. // Do not initialize FactoryBeans here: We need to leave all regular beans // uninitialized to let post-processors apply to them! // Publish early application events now that we finally have a multicaster... } protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) { // Initialize conversion service for this context. // Register a default embedded value resolver if no bean post-processor // (such as a PropertyPlaceholderConfigurer bean) registered any before: // at this point, primarily for resolution in annotation attribute values. // Initialize LoadTimeWeaverAware beans early to allow for registering their transformers early. // Stop using the temporary ClassLoader for type matching. // Allow for caching all bean definition metadata, not expecting further changes. // Instantiate all remaining (non-lazy-init) singletons. } protected void finishRefresh() { // Clear context-level resource caches (such as ASM metadata from scanning). // Initialize lifecycle processor for this context. // Propagate refresh to lifecycle processor first. // Publish the final event. // Participate in LiveBeansView MBean, if active. }

终于，在这个时候知道注释有多么的重要，特别是在大型的应用中，功能将被拆到多个类，多个方法中，真的无法凭记忆去感觉。在子类的onRefresh()执行之后，BeaFactory的工作也收尾了。也许还记得earlyApplicationEvent这个属性，因为在创建前没有消息的发布者(muticaster),context创建前的事件都被存到该集合，直到registerListener()后，再将其发布。finishBeanFactoryInitialization()则是开始实例话bean了，finishRefresh()则是清空resource case，classLoader等缓存。最后发布一个ContextRefreshedEvent事件，宣布上下文创建或刷新已经完成了。。（掌声！！）

AbstractRefreshableApplicationContext

ARAC继承自AAC,对一个R,也代表了它多一个Refreshable属性。但是在AAC中也有refresh，只不过AAC中的refresh只是对context的标准化，而ARAC是刷新BeanFactroy。

从上图看，ARAC完成了一个关键的操作，创建了BeanFactory,终于看到了BeanFactory的真身了，还为期定义了两个allow属性：

protected DefaultListableBeanFactory createBeanFactory() { return new DefaultListableBeanFactory(getInternalParentBeanFactory()); }

有了BeanFactory后，ARAC就得完成其父亲AAC的叮嘱，为AAC先刷新好BeanFactory（还记得// Tell the subclass to refresh the internal bean factory. 这个注释吗？）。

@Override protected final void refreshBeanFactory() throws BeansException { if (hasBeanFactory()) { destroyBeans(); closeBeanFactory(); } try { DefaultListableBeanFactory beanFactory = createBeanFactory(); beanFactory.setSerializationId(getId()); customizeBeanFactory(beanFactory); loadBeanDefinitions(beanFactory); synchronized (this.beanFactoryMonitor) { this.beanFactory = beanFactory; } } catch (IOException ex) { throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex); } } 

以上便是刷新BeanFactory的操作，里面没有注释是不是说这很j简单？确实，就连核心操作loadBeanDefinition都是抽象方法。好吧，我们也跳过这个类，感谢它带来的BeanFactoy和定义的几个刷新方法，还有两个allowsh属性。

AbstractRefreshableConfigApplicationContext

好吧，现在的context可以有自定义的配置文件了。
但还是注意一下，ARCAC还实现了BeanNameAware，InitializingBean两个接口。

/** * Triggers {@link #refresh()} if not refreshed in the concrete context's * constructor already. */ @Override public void afterPropertiesSet() { if (!isActive()) { refresh(); } }

上面是InitializingBean中的方法，大致是触发自动刷新，目前还没看见具体触发机制的实现。

AbstractXmlApplicationContext

AXAC是对context的最后一层抽象，实现了其父类最后一个为实现的抽象方法：

@Override protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException { // 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. beanDefinitionReader.setEnvironment(this.getEnvironment()); 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. initBeanDefinitionReader(beanDefinitionReader); loadBeanDefinitions(beanDefinitionReader); }

因为配置文件加载的次数有限，loadBeanFactory()也是直接new 一个对象来完成使命。现在的AXAC中并没有任何抽象方法，按理可以写成一个普通类，依旧定义成抽象类也决定了AXAC无法被实例化，设计的目的为何？

结尾

到此，从定义的接口到全部的实现，context这个巨大的角色框架基本已经清楚了，我们也看到了巨型角色构建的设计艺术。大致上从AAC对职责的划分，分配到各个代理中，再定义了一个总体的refresh对策，把核心的自定义配置加载（obtainFreshBeanFactory()），自定义刷新BeanFactory （onRefresh()）功能抽象出去，分别让ARCAC和ARAC实现，最后由AXAC统一大业，不得不佩服AAC抽象类的设计。