Spring源代码分析（8)---ClassPathXmlApplicationContext（工厂换新颜）

正如你所疑惑的那样，BeanFactory我们已经束之高阁多年啦，我们正在使用威力更加强大的ApplicationContext为我们服务，我们来看下这个新东西，到底如何为我们提供面貌一新的服务；

要了解ApplicationContext比BeanFactory功能强大在哪里，我们就必须来分析ApplicationContext接口的实现，因为功能及方法是通过interface来设定的，我们来看一下ApplicationContext的接口类图；



从这里我们可以看出来，我们的ApplicationContext比BeanFactory多实现了这两个接口

1. public interface MessageSource {
3.     String getMessage(String code, Object[] args, String defaultMessage, Locale locale);
5.     
6.     String getMessage(String code, Object[] args, Locale locale) throws NoSuchMessageException;
8.     
9.     String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException;
11. }

这个接口可以通过参数从特定的多语言文件中获取信息；
其中：
code:消息键；
args[]:参数；
defaultMessage:默认消息；
locale:语言区域；

1. public interface ApplicationEventPublisher {
2.     
3.     
4.     void publishEvent(ApplicationEvent event);
6. }

应用信息广播接口，广播信息；
我们看一下具体的实现：

1.     public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh) throws BeansException {
2.         this.configLocations = configLocations;
3.         if (refresh) {
4.             refresh();
5.         }
6.     }

这是ClassPathXmlApplicationContext的初始化函数，在refresh函数里面，调用了refreshBeanFactory();这个函数如下：

2.     protected final void refreshBeanFactory() throws BeansException {
3.         // Shut down previous bean factory, if any.
4.         if (this.beanFactory != null) {
5.             this.beanFactory.destroySingletons();
6.             this.beanFactory = null;
7.         }
9.         // Initialize fresh bean factory.
10.         try {
11.             DefaultListableBeanFactory beanFactory = createBeanFactory();
12.             loadBeanDefinitions(beanFactory);
13.             this.beanFactory = beanFactory;
14.             if (logger.isInfoEnabled()) {
15.                 logger.info("Bean factory for application context [" + getDisplayName() + "]: " + beanFactory);
16.             }
17.         }
18.         catch (IOException ex) {
19.             throw new ApplicationContextException(
20.                     "I/O error parsing XML document for application context [" + getDisplayName() + "]", ex);
21.         }
22.     }

将一个BeanFactory设定ApplicationContext的属性，然后，我们可见:
ApplicationContext将原来BeanFactory接口的方法全部委托给BeanFacroty，在这里我们可以把这个看做适配器和装饰模式的一种结合应用；这样，既复用了以前遗留的功能，有将现有系统的功能得到了扩展；

1. public Object getBean(String name) throws BeansException {
2.         return getBeanFactory().getBean(name);
3.     }
5.     public Object getBean(String name, Class requiredType) throws BeansException {
6.         return getBeanFactory().getBean(name, requiredType);
7.     }
9.     public boolean containsBean(String name) {
10.         return getBeanFactory().containsBean(name);
11.     }
13.     public boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
14.         return getBeanFactory().isSingleton(name);
15.     }
17.     public Class getType(String name) throws NoSuchBeanDefinitionException {
18.         return getBeanFactory().getType(name);
19.     }
21.     public String[] getAliases(String name) throws NoSuchBeanDefinitionException {
22.         return getBeanFactory().getAliases(name);
23.     }

1.     protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws IOException {
2.         // Create a new XmlBeanDefinitionReader for the given BeanFactory.
3.         XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);
5.         // Configure the bean definition reader with this context's
6.         // resource loading environment.
7.         beanDefinitionReader.setResourceLoader(this);
8.         if (getClassLoader() != null) {
9.             beanDefinitionReader.setBeanClassLoader(getClassLoader());
10.         }
11.         beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));
13.         // Allow a subclass to provide custom initialization of the reader,
14.         // then proceed with actually loading the bean definitions.
15.         initBeanDefinitionReader(beanDefinitionReader);
16.         loadBeanDefinitions(beanDefinitionReader);
17.     }

同时，MessageSource功能的实现也是委托给配置的MessageSource文件的；

1.     public String getMessage(String code, Object args[], String defaultMessage, Locale locale) {
2.         return getMessageSource().getMessage(code, args, defaultMessage, locale);
3.     }
5.     public String getMessage(String code, Object args[], Locale locale) throws NoSuchMessageException {
6.         return getMessageSource().getMessage(code, args, locale);
7.     }
9.     public String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException {
10.         return getMessageSource().getMessage(resolvable, locale);
11.     }

这是策略模式的应用；通过MessageSource之间的组合关系，实现了算法之间的更换，可以在配置文件中更换MessageSource的实现，从而利用不同的NessageSource之间的功能切换；

现在，我们再来看看事件发布的实现代码：

1.             // Invoke factory processors registered as beans in the context.
2.             invokeBeanFactoryPostProcessors();
4.             // Register bean processors that intercept bean creation.
5.             registerBeanPostProcessors();
7.             // Initialize message source for this context.
8.             initMessageSource();
10.             // Initialize event multicaster for this context.
11.             initApplicationEventMulticaster();
13.             // Initialize other special beans in specific context subclasses.
14.             onRefresh();
16.             // Check for listener beans and register them.
17.             registerListeners();
19.             // Instantiate singletons this late to allow them to access the message source.
20.             beanFactory.preInstantiateSingletons();
22.             // Last step: publish corresponding event.
23.             publishEvent(new ContextRefreshedEvent(this));
24.         }
25.     }

在这段refresh代码中，我们可以看见：

initApplicationEventMulticaster();

1. private void initApplicationEventMulticaster() throws BeansException {
2.         if (containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
3.             this.applicationEventMulticaster = (ApplicationEventMulticaster)
4.                     getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
5.             if (logger.isDebugEnabled()) {
6.                 logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
7.             }
8.         }
9.         else {
10.             this.applicationEventMulticaster = new SimpleApplicationEventMulticaster();
11.             if (logger.isDebugEnabled()) {
12.                 logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
13.                         APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
14.                         "': using default [" + this.applicationEventMulticaster + "]");
15.             }
16.         }
17.     }

在ApplicationContext中存在 ApplicationEventMulticaster，这其实是一个典型的观察者模式的运用，对于事件的广播我们都很容易的联想到了观察着，对！ ApplicationEventMulticaster这里就是一个主题,在这段代码中，我们可见，我们可以在配置文件中重写这个 ApplicationEventMulticaster类，如果我们没有配置这个类的话，那么就会默认实现一个：

1. public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {
2. 
   
3.     public void multicastEvent(ApplicationEvent event) {
4.         for (Iterator it = getApplicationListeners().iterator(); it.hasNext();) {
5.             ApplicationListener listener = (ApplicationListener) it.next();
6.             listener.onApplicationEvent(event);
7.         }
8.     }
9. 
   
10. }

这是一个notifyAll的方法，调用所有监听者的onApplicationEvent()方法；

我们来看看这个 multicastEvent方法是在什么时候调用的：

1.     public void publishEvent(ApplicationEvent event) {
2.         Assert.notNull(event, "Event must not be null");
3.         if (logger.isDebugEnabled()) {
4.             logger.debug("Publishing event in context [" + getDisplayName() + "]: " + event);
5.         }
6.         getApplicationEventMulticaster().multicastEvent(event);
7.         if (this.parent != null) {
8.             this.parent.publishEvent(event);
9.         }
10.     }

可见，我们的真正的主题类是ApplicationContext类，只是他把管理监听者队列和消息广播的功能委托给了 SimpleApplicationEventMulticaster,然后再在ApplicationContext里面实现setChange（）方法，这是对观察着模式的灵活运用，他很好的符合了单一职责原则，方便了 SimpleApplicationEventMulticaster的复用，很好，很强大！


如在refresh最后，我们调用了：
 publishEvent( new  ContextRefreshedEvent( this ));
通知系统中的监听者对象；