版本：spring-framework-3.0.5.RELEASE

接上篇继续

一、首先看ConfigurableBeanFactory接口

本接口继承了HierarchicalBeanFactory和SingletonBeanRegistry，接口代码如下：

String SCOPE_SINGLETON = "singleton";
String SCOPE_PROTOTYPE = "prototype";

void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;

void setBeanClassLoader(ClassLoader beanClassLoader);
ClassLoader getBeanClassLoader();

void setTempClassLoader(ClassLoader tempClassLoader);
ClassLoader getTempClassLoader();

void setCacheBeanMetadata(boolean cacheBeanMetadata);
boolean isCacheBeanMetadata();

void setBeanExpressionResolver(BeanExpressionResolver resolver);
BeanExpressionResolver getBeanExpressionResolver();

void setConversionService(ConversionService conversionService);
ConversionService getConversionService();

void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);

void registerCustomEditor(Class requiredType, Class<? extends PropertyEditor> propertyEditorClass);

void copyRegisteredEditorsTo(PropertyEditorRegistry registry);

void setTypeConverter(TypeConverter typeConverter);
TypeConverter getTypeConverter();

void addEmbeddedValueResolver(StringValueResolver valueResolver);
String resolveEmbeddedValue(String value);

void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
int getBeanPostProcessorCount();

void registerScope(String scopeName, Scope scope);
String[] getRegisteredScopeNames();
Scope getRegisteredScope(String scopeName);

AccessControlContext getAccessControlContext();

void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;
void resolveAliases(StringValueResolver valueResolver);

BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;

boolean isCurrentlyInCreation(String beanName);

void registerDependentBean(String beanName, String dependentBeanName);

String[] getDependentBeans(String beanName);
String[] getDependenciesForBean(String beanName);

void destroyBean(String beanName, Object beanInstance);
void destroyScopedBean(String beanName);
void destroySingletons();

• 前面两行是定义了spring里bean的两个作用域名称：singleton和prototype，基本两个的区别就是一为单例模式的一个对象，spring对其生命周期负责；二为每次请求都会生成新的对象，spring只负责创建，并不负责其生命周期管理。具体的作用域相关详细分析请查看  spring作用域分析
• 第4行设置ParentBeanFactory
• 第6-19行是标准的Javabean模板的Getter/Setter方法了，分别是对beanClassLoader（类加载器）,tempClassLoader（临时加载器）,cacheBeanMetadata（是否缓存bean的元数据）,BeanExpressionResolver（表达式语言处理器）,conversionService（数据转换服务）的操作
• 第21行为添加bean属性编辑器的管理器
• 第23行注册某个类型requiredType的属性编辑器为propertyEditorClass
• 第25行将所有当前已经注册的属性编辑器类型初始化并注册到输入参数registry中
• 第27-28行是typeConverter的Getter/Setter方法，这个对象是bean属性的转换器，会覆盖propertyEditor机制
• 第30行添加字符串解析器，主要用于嵌入式的属性解析，例如注解中的属性
• 第31行进行字符串属性解析，使用的就是上面添加的字符串解析器
• 第33行注册一个BeanPostProcessor
• 第34行获取已经注册的BeanPostProcessor的数量
• 第36-38行分别为注册bean的作用域，获取所有作用域名称，根据名称获取作用域对象
• 第40行获取安全管理上下文对象
• 第42行从传入的otherFactory中获取所有配置信息（BeanPostProcessors，作用域等），但不包括具体的bean定义信息
• 第44行注册bean别名
• 第45行是使用传入的valueResolver对别名进行处理
• 第47行根据beanName获取bean定义信息对象
• 第49行判断指定name的bean是否为FactoryBean
• 第51行判断指定name的bean是否正在创建中
• 第53行注册dependentBeanName为beanName的依赖bean，在销毁beanName对应的bean之前必须要先销毁dependentBeanName对应的bean
• 第55-56行获取所有依赖于beanName的bean名称，以及获取所有beanName依赖的bean名称。
• 第58行销毁bean实例
• 第59行把bean从其作用域中移除并销毁
• 第60行销毁所有单例bean

二、ConfigurableListableBeanFactory接口

本接口继承了ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory，代码如下：

void ignoreDependencyType(Class type);
void ignoreDependencyInterface(Class ifc);

void registerResolvableDependency(Class dependencyType, Object autowiredValue);

boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
        throws NoSuchBeanDefinitionException;

BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

void freezeConfiguration();
boolean isConfigurationFrozen();

void preInstantiateSingletons() throws BeansException;

• 第1行忽略指定类型的自动装配，默认为空
• 第2行忽略指定接口的自动装配，默认只忽略BeanFactoryAware接口
• 第4行这个还没有弄清楚，弄清楚了再补上……
• 第6行判断bean的依赖是否自动装配
• 第9行根据beanname获取bean的定义信息对象
• 第11行第锁住所有bean定义信息，锁住后将不允许对其修改
• 第12行判断bean定义对象是否被锁住
• 最后一行是确保对所有非延迟加载的单例bean进行初始化，也就是说在这里会对所有没有初始化的非延迟加载单例bean进行初始化。

三、ApplicationContext接口

本接口继承了ListableBeanFactory, HierarchicalBeanFactory,MessageSource, ApplicationEventPublisher, ResourcePatternResolver，其中ListableBeanFactory是bean相关的列表功能，HierarchicalBeanFactory代表了它本身有层级支持，MessageSource代表了spring的国际化信息支撑，ApplicationEventPublisher代表了spring的事件处理支撑，ResourcePatternResolver则是资源处理相关的支撑。接口代码如下：

String getId();

String getDisplayName();

long getStartupDate();

ApplicationContext getParent();

AutowireCapableBeanFactory getAutowireCapableBeanFactory() throws IllegalStateException;

• 这个代码就很简单了，基本上的功能都是在几个父接口里，特殊的地方就是多几个属性id，displayName，startupDate，parentApplicationContext，autowireCapableBeanFactory的get或set方法

这里简单说下ApplicationContext虽然它是BeanFactory的子接口，但是可以认为它不是一个BeanFactory，ApplicationContext对象里面包含了一个BeanFactory对象，相关bean基本功能是调用了其内部的一个BeanFactory对象来实现的，而不是自己进行的实现，它对BeanFactory进行了一定的封装扩展，另外国际化支持，事件监听等都集成在了里面。

评论 (2)     查看全文    

版本：spring-framework-3.0.5.RELEASE

Spring的最核心的部分就是BeanFactory了，当然我们现在很少直接使用这个类而是通过ApplicationContext来使用了，本篇我们就对BeanFactory接口的核心方法、BeanFactory的子接口及其实现类以及ApplicationContext相关做一个详细的分析和了解。关于实现代码牵扯到的东西太多了，这里只分析接口的功能及继承关系，暂时不做实现类的分析。

一、我们首先看下BeanFactory接口的代码：

public interface BeanFactory {
    String FACTORY_BEAN_PREFIX = "&";

    Object getBean(String name) throws BeansException;
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    <T> T getBean(Class<T> requiredType) throws BeansException;
    Object getBean(String name, Object... args) throws BeansException;

    boolean containsBean(String name);
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String name, Class targetType) throws NoSuchBeanDefinitionException;

    Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    String[] getAliases(String name);
}

1. 首先第2行是一个字符串常量，值为"&"，这个是用在FactoryBean那部分，假如有一个FactoryBean的name=foo，则使用name=&foo去取bean对象的时候取到的就是foo的工厂而不是foo本身。
2. 第4行根据bean的name去查找bean，在当前BeanFactory查找不到的时候会去查找parent的BeanFactory，返回为一个Object对象需用户自行转换其原本的类型。
3. 第5行也是根据name查找bean，但是多了一个参数requiredType，查找bean并要求结果符合这个类型，如果requiredType为null，则同上个方法一样只根据name查找，另外这里使用了泛型，返回对象类型会直接是requiredType。
4. 第6行是根据requiredType查找bean，查找一个符合这个类型的bean，同样返回类型为requiredType。
5. 第7行根据name查找bean，同时有一个参数组args，这个主要是用来给给工厂类创建bean对象的时候调用的，所以如果args不为空则意味着这里查找的是一个prototype的bean。
6. 第9-12行分别是几个判断方法：判断是否存在bean；是否是单例bean；是否是prototype的bean,bean是否符合类型requiredType。
7. 第13行是根据bean的name获取bean的类型。
8. 最后是根据bean的name获取指向该bean的所有别名，如果输入的name本身就是别名，那返回的将包括bean的最初name，并且这个name在返回的数组中第一个元素。
    

二、现在我们看下BeanFactory的子接口

BeanFactory一共有3个子接口一个实现类，其中实现类SimpleJndiBeanFactory主要是jndi相关，我们这里暂不讨论，下面看3个接口

2.1、HierarchicalBeanFactory接口：主要定义BeanFactory的分层的支撑，所谓分层也就是parentBeanFactory概念

2.1.1、首先看下代码：

public interface HierarchicalBeanFactory extends BeanFactory {
    BeanFactory getParentBeanFactory();
    boolean containsLocalBean(String name);
}

1. getParentBeanFactory()方法获取parentBeanFactory；
2. containsLocalBean()则类似containsBean()只不过这个方法只在当前BeanFactory查找bean，如果没有不再去parent里查找了。
    

2.1.2、这个接口有两个子接口：ApplicationContext和ConfigurableBeanFactory，关于这两个子接口下面独立做分析，因为他们已经不只是HierarchicalBeanFactory的子接口了。

2.2、ListableBeanFactory接口：主要是获取bean的定义和配置信息相关的支撑接口

2.2.1、代码如下：

public interface ListableBeanFactory extends BeanFactory {
    boolean containsBeanDefinition(String beanName);
    int getBeanDefinitionCount();
    String[] getBeanDefinitionNames();
    String[] getBeanNamesForType(Class type);
    String[] getBeanNamesForType(Class type, boolean includeNonSingletons, boolean allowEagerInit);
    <T> Map<String, T> getBeansOfType(Class<T> type) throws BeansException;
    <T> Map<String, T> getBeansOfType(Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
            throws BeansException;
    Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType)
            throws BeansException;
    <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType);
}

• containsBeanDefinition()方法判断是否存在指定beanName的定义信息
• getBeanDefinitionCount()获取bean定义的总数
• getBeanDefinitionNames()获取所有bean定义的name数组
• getBeanNamesForType()获取所有指定类型的bean的name数组
• 第2个getBeanNamesForType()方法多了两个餐厨，可以指定是否单例，是否渴望初始化
• 两个getBeansOfType()和getBeanNamesForType()的参数一样，只不过这个返回的是name为key，bean对象为value的map集合
• getBeansWithAnnotation()方法获取包含指定注解annotationType所有bean的map集合
• 最后findAnnotationOnBean()方法获取指定beanName的指定注解的注解信息对象
   

2.1.2、这个接口有两个子接口：ApplicationContext和ConfigurableListableBeanFactory，关于这两个子接口同样放到下面独立做分析。

注：该接口还有一个静态实现类StaticListableBeanFactory，没发现哪里在使用，代码上也很简单就是把bean的定义放到一个map集合beans里面，实现一个基本的本接口功能，暂不做分析。
 

2.3、AutowireCapableBeanFactory接口：主要是spring的自动装配相关功能支撑接口

2.3.1、代码如下：

public interface AutowireCapableBeanFactory extends BeanFactory {
    int AUTOWIRE_NO = 0;
    int AUTOWIRE_BY_NAME = 1;
    int AUTOWIRE_BY_TYPE = 2;
    int AUTOWIRE_CONSTRUCTOR = 3;
    int AUTOWIRE_AUTODETECT = 4;

    <T> T createBean(Class<T> beanClass) throws BeansException;
    Object createBean(Class beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

    Object configureBean(Object existingBean, String beanName) throws BeansException;
    Object initializeBean(Object existingBean, String beanName) throws BeansException;
    Object autowire(Class beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
    void autowireBean(Object existingBean) throws BeansException;
    void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
            throws BeansException;
    void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;
    Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
            throws BeansException;
    Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
            throws BeansException;
    Object resolveDependency(DependencyDescriptor descriptor, String beanName) throws BeansException;
    Object resolveDependency(DependencyDescriptor descriptor, String beanName,
            Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException;
}

这个接口的主要实现代码都在AbstractAutowireCapableBeanFactory类中，暂时也没有发现其他地方用到这个接口，查看这些方法的实现可以去看这个类。

• 首先是5个常量代表自动装配的类型：不自动装配、按name、按类型、根据自省完全自动装配（不推荐，已在3.0中过时）。
• 两个创建Bean的方法，一个是根据类型，另外一个多了两个参数自动装配类型和是否检查依赖
• configureBean()是一个用来主动的配置装配的，就是在需要的时候把existingBean自动装配给beanName对应的bean
• initializeBean()是bean的初始化方法在这里主要调用了几个工厂级回调（BeanNameAware、BeanClassLoaderAware和BeanFactoryAware），并处理了所有BeanPostProcessor的两个调用
• autowire()方法创建一个类型为beanClass的bean对象，并根据自动装配类型autowireMode进行自动装配，dependencyCheck则代表是否做依赖检查
• autowireBean()方法暂时没有很清楚，只知道和普通的按name按类型装配不同，和注解相关，以后分析清楚了再补充。
• autowireBeanProperties方法()和上面的方法类似，只不过省略了bean创建的步骤，直接穿入一个bean对象进行自动装配
• applyBeanPropertyValues()应用bean定义中明确定义的属性值，区别于autowireBeanProperties（会装配所有属性）。
• applyBeanPostProcessorsBeforeInitialization()和applyBeanPostProcessorsAfterInitialization()两个方法处理BeanPostProcessor的两种回调，上面的initializeBean()方法的实现中就是调用这两个
• 两个resolveDependency()方法也没有搞清楚，是跟bean的依赖相关的，以后清楚了再补充。

2.3.2、这个接口的继承结构也很清晰，一个子接口ConfigurableListableBeanFactory，一个实现类AbstractAutowireCapableBeanFactory。

下一篇：ConfigurableBeanFactory、ConfigurableListableBeanFactory、ApplicationContext

评论 (1)     查看全文    

refresh()方法中在上篇看完了MessageSource及时间监听器等初始话处理，这篇继续往下看。

注：refresh()的代码就不再次列举了，请看spring源码中AbstractApplicationContext类。

一、finishBeanFactoryInitialization(beanFactory)这个方法将完成BeanFactory的初始化，主要做的事就是初始化除了之前处理过的特殊bean之外的所有单例bean，代码如下：

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));
}

beanFactory.setTempClassLoader(null);
beanFactory.freezeConfiguration();
beanFactory.preInstantiateSingletons();

• 第1-5行判断如果定义了名为conversionService并且类型为ConversionService的bean，则把其设置为beanFactory的conversionService属性。这个主要是用来提供数据转化服务的
• 销毁之前在prepareBeanFactory()中生成的临时ClassLoader
• freezeConfiguration()的代码如下：

  this.configurationFrozen = true;
  synchronized (this.beanDefinitionMap) {
      this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);
  }

  这个方法就是代表bean定义等配置已经可以缓存了，不会再有其他地方对其做修改了
• 最后一行就是对所有非延迟加载的单例bean进行初始化了我们来看下这个方法的代码：

  if (this.logger.isInfoEnabled()) {
      this.logger.info("Pre-instantiating singletons in " + this);
  }
  synchronized (this.beanDefinitionMap) {
      for (String beanName : this.beanDefinitionNames) {
          RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
          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>() {
                          public Boolean run() {
                              return ((SmartFactoryBean) factory).isEagerInit();
                          }
                      }, getAccessControlContext());
                  }
                  else {
                      isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean) factory).isEagerInit(); 
                  }
                  if (isEagerInit) {
                      getBean(beanName);
                  }
              }
              else {
                  getBean(beanName);
              }
          }
      }
  }

  首先是一行info级别的日志，然后在对象beanDefinitionMap的同步下循环所有bean的name分别进行初始化
  首先获取bean定义信息对象bd，然后进行判断，这里只对非抽象bean（抽象bean是用于继承定义配置等信息的不可初始化）、单例、非延迟加载的bean进行处理
  判断如果是FactoryBean则进行下面的处理，如果不是直接调用getBean(beanName)，这个方法调用会进行这个bean的初始化，关于这个方法还是放到BeanFactory的单独分析里面这里就不往里看了。
  对于FactoryBean的获取，要在beanname前加上一个&，然后会先判断是否是SmartFactoryBean并且渴望初始化（EagerInit），如果是才调用getBean(beanName)，否则这个应该是在第一次调用工厂的getObject的时候才初始化
  注：对于这中间AccessController.doPrivileged的运用没有搞明白，留待以后分析，不知道为什么要在这里使用这个

二、最后的一个处理是finishRefresh()方法，代码如下：

initLifecycleProcessor();
getLifecycleProcessor().onRefresh();
publishEvent(new ContextRefreshedEvent(this));

1.先看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的

• 如果用户定义了名为lifecycleProcessor类型为LifecycleProcessor的LocalBean，则赋值给当前ApplicationContext的lifecycleProcessor属性
• 如果用户没有定义，则初始化默认的生命周期管理器DefaultLifecycleProcessor，注册单例bean，并赋值给lifecycleProcessor属性

2.initLifecycleProcessor()方法之后则是对生命周期管理器的触发，LifecycleProcessor有两个触发点onRefresh()和onClose()，当前正处于refresh所以调用其onRefresh()方法

3.调用publishEvent()方法发布ContextRefreshedEvent事件，publishEvent()的代码也很简单就不介绍了，就是调用当前上下文及parent的ApplicationEventMulticaster的multicastEvent()方法，这个放到分析事件处理模块时再去详细分析。

三、最后分析一下在整个try代码块中如果抛出异常的处理，可以看到分为了两个方法调用：

1.destroyBeans()代码很简单，就是调用BeanFactory的destroySingletons()方法销毁所有单例bean。还是暂不细看放到BeanFactory专项分析里去

2.cancelRefresh()这个方法代码看一下：

synchronized (this.activeMonitor) {
    this.active = false;
}

就是在同步下设置状态值而已，但是有个小细节，这个方法在AbstractRefreshableApplicationContext和GenericApplicationContext两个子类中进行了重写，但是也很简单，就是增加了一个beanFactory.setSerializationId(null)然后依旧调用上面super中的方法进行修改状态

关于ApplicationContext的基本初始化的过车这就分析完了，中间碰到了很多问题，也还有很多地方需要详细研究，下面列举备忘一下，后面挨个分析：

1. bean定义的加载
2. bean的初始化
3. BeanFactory的一些核心方法
4. BeanFactory和ApplictionContext的关系以及各自的类继承框架
5. 扩展点BeanFactoryPostProcessor及BeanPostProcessor
6. 事件监听器ApplicationListener
7. 信息管理器MessageSource
8. 属性编辑器PropertyEditor
9. 生命周期管理器LifecycleProcessor
10. 还有几个小细节例如LoadTimeWeaver、MergedBeanDefinitionPostProcessor、AccessController.doPrivileged等

评论 (1)     查看全文    

refresh()方法中在上篇看完了对PostProcessors的处理，这篇继续往下看。

注：refresh()的代码就不再次列举了，请看spring源码中AbstractApplicationContext类。

一、initMessageSource()，这个方法是对spring的MessageSource初始化，代码如下：

ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(MESSAGE_SOURCE_BEAN_NAME)) {
    //第1部分
}
else {
    //第2部分
}

• 首先获取beanFactory对象，然后判断是否定义了名为messageSource的localbean，如果有则执行第1部分，否则执行第2部分，分别来看两部分代码
  注：localbean实际上就是指查找的时候不会去parent查找这个bean，只从当前beanfactory去查找，很多地方有这个就不一一注明了

第1部分：

this.messageSource = beanFactory.getBean(MESSAGE_SOURCE_BEAN_NAME, MessageSource.class);
if (this.parent != null && this.messageSource instanceof HierarchicalMessageSource) {
    HierarchicalMessageSource hms = (HierarchicalMessageSource) this.messageSource;
    if (hms.getParentMessageSource() == null) {
        hms.setParentMessageSource(getInternalParentMessageSource());
    }
}
if (logger.isDebugEnabled()) {
    logger.debug("Using MessageSource [" + this.messageSource + "]");
}

• 第1行获取名为messageSource的bean赋值给当前ApplicationContext对象的messageSource属性
• 第2行判断如果当前ApplicationContext的parent不为null；并且messageSource对象继承了HierarchicalMessageSource接口则进行如下处理：
      进行判断如果messageSource的parentMessageSource为空，则设置为getInternalParentMessageSource()方法的返回值。getInternalParentMessageSource()方法的代码也很简单
      (getParent() instanceof AbstractApplicationContext) ? ((AbstractApplicationContext) getParent()).messageSource : getParent()
      如果当前ApplicationContext的parent对象是AbstractApplicationContext或其子类类型则返回它的messageSource，否则直接返回其parent对象
• 最后是打印一行debug级别日志表示当前应用的messageSource

第2部分：

DelegatingMessageSource dms = new DelegatingMessageSource();
dms.setParentMessageSource(getInternalParentMessageSource());
this.messageSource = dms;
beanFactory.registerSingleton(MESSAGE_SOURCE_BEAN_NAME, this.messageSource);
if (logger.isDebugEnabled()) {
    logger.debug("Unable to locate MessageSource with name '" + MESSAGE_SOURCE_BEAN_NAME +
            "': using default [" + this.messageSource + "]");
}

• 第1行创建一个DelegatingMessageSource对象dms
• 第2行类似上面，设置dms的parentMessageSource为getInternalParentMessageSource()返回值
• 第3行设置当前ApplicationContext的messageSource属性为dms
• 第4行把这个对象注册一个名为messageSource的单例bean
• 打印一行debut日志表示无用户定义messageSource，使用默认

二、紧接着处理完messageSource的初始化后下一行代码：initApplicationEventMulticaster()，主要是对spring的事件监听器的管理器的初始话，代码如下：

ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
    this.applicationEventMulticaster =
            beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
    if (logger.isDebugEnabled()) {
        logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
    }
}
else {
    this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
    beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
    if (logger.isDebugEnabled()) {
        logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
                APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
                "': using default [" + this.applicationEventMulticaster + "]");
    }
}

• 和messageSource的处理类似，首先取得beanFactory对象，
• 判断如果用户主动定义了applicationEventMulticaster的bean，则把这个bean设置给applicationEventMulticaster属性
• 如果没有则初始话一个默认的SimpleApplicationEventMulticaster，注册bean并赋值给对应属性
• 不同情况分别打印不同的日志，源代码中的日志打印最好也稍微注意一下有个印象，这样在看spring的日志时会更清晰

三、接下来是一个模板方法onRefresh()，第一篇中提到过这个是在处理messageSource、applicationEventMulticaster等特殊bean后，普通单例bean没初始话之前，为ApplicationContext子类提供扩展去处理一些类似的特殊bean。

    举个例子AbstractRefreshableWebApplicationContext、GenericWebApplicationContext、StaticWebApplicationContext中都有一个themeSource，这个就要放在这个方法里去初始化。这个themeSource是spring的主题功能，可以实现根据不同主题加载不同资源文件等功能。

四、上面处理了事件监听器的管理器初始化，现在开始做时间监听器的注册：registerListeners()，这个方法的代码如下：

for (ApplicationListener listener : getApplicationListeners()) {
    getApplicationEventMulticaster().addApplicationListener(listener);
}

String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String lisName : listenerBeanNames) {
    getApplicationEventMulticaster().addApplicationListenerBean(lisName);
}

• 上面3行是处理当前ApplicationContext中的静态特殊监听器集合，循环调用applicationEventMulticaster的addApplicationListener()方法注册到applicationEventMulticaster中
• 后面的一部分首先取出所有类型为ApplicationListener的bean的name集合，然后循环调用applicationEventMulticaster的addApplicationListenerBean()方法注册到applicationEventMulticaster中
• 注意上面两个注册方法的不同，分别会注册到applicationEventMulticaster.defaultRetriever的不同集合中

本篇分别看到了messageSource、applicationEventMulticaster和applicationListener以及中间提到的主题themeSource的初始化，这里主要介绍初始话，所以后续再对spring的这几个功能模块做分别详细的分析。

评论 (2)     查看全文