Spring源码阅读（一）——浅析ApplicationContext

一、IOC与DI

很多人学习Spring框架都是从IOC入手的， IOC（Inversion of Control）译为“控制反转”，基于这一概念，可以衍生出下面几个问题：

谁控制了谁？
控制了什么？
为什么是反转？

首先，我们来回答第一个问题：传统模式下，我们通常使用new来创建对象。而使用Spring，我们调用getBean(String name, Class type)就可以直接获得对象。因此，IOC容器控制了对象。

那么，Spring容器控制了对象的什么呢？要回答这个问题，我们可以直接把IOC的定义搬过来：

所谓 IOC ，就是由 Spring IOC 容器来负责对象的生命周期和对象之间的关系。

为什么是反转？通过new来创建对象，对象的生命周期以及对象间的依赖都由程序员自己控制，这是正转。而反转刚好倒过来，由容器来对对象进行管理，我们可以直接从容器中获得对象及其依赖。

DI（Dependency Injection），即“依赖注入”，是指容器在运行时决定组件之间的依赖，这是容器管理对象的另一个说法。它并非是为系统添加新的功能，而是提升了组件的重用性。

二、ApplicationContext

也许大家从零零星星的文章中了解到，ApplicationContext是一个高级的BeanFactory，它在BeanFactory的基础上扩展了很多功能。至于它有哪些功能，我们接下来细细道来。

ApplicationContext.png

从ApplicationContext的类图中可以看到，它除了简接地继承了BeanFactory之外，还继承了MessageSource、ResourceLoader、ApplicationEventPublisher和EnvironmentCapable接口，言外之意是它包含了这几个接口定义的所有功能。

2.1 MessageSource

MessageSource是一个解析消息的策略接口，它支持参数化与国际化。也许大家并不是很理解这句话，下面我们一步步地解析这句话的含义。

/**
 * 用于解析消息的策略接口，支持此类消息的参数化和国际化
 */
public interface MessageSource {

    /**
     * 解析消息，如果没找到code对应的消息就返回defaultMessage
     */
    @Nullable
    String getMessage(String code, @Nullable Object[] args, @Nullable String defaultMessage, Locale locale);

    /**
     * 解析消息，如果没找到code对应的消息就抛异常
     
     */
    String getMessage(String code, @Nullable Object[] args, Locale locale) throws NoSuchMessageException;

    /**
     * 使用MessageSourceResolvable中的所有属性解析消息
     * MessageSourceResolvable用code[]是啥意思呢？？？
     */
    String getMessage(MessageSourceResolvable resolvable, Locale locale) throws NoSuchMessageException;
}

从MessageSource的源码可以看到，它定义了三个getMessage方法，根据Locale指定的地区解析code对应的消息，并用args参数替换消息中的占位符，最终返回解析后的消息。

为了帮助大家理解，我举个简单的例子：

在Spring配置文件spring.xml中定义properties文件的前缀


    
        
            messages

新建几个以messages为前缀的properties文件，内容和文件名如下：

message=我只是个{0}   #messages_zh_CN.properties
message=I am just a {0}  #messages_en.properties

解析并获取解析后的消息

ApplicationContext context=new ClassPathXmlApplicationContext("spring.xml");
String message1=context.getMessage("message", new String[]{"小孩"}, Locale.CHINA);
String message2=context.getMessage("message", new String[]{"child"}, Locale.ENGLISH);
        
System.out.println("message1=" + message1);
System.out.println("message2=" + message2);

打印输出

message1=我只是个小孩
message2=I am just a child

通过这个例子，大家应该理解参数化和国际化的意思了吧~~
我们继续回到ApplicationContext，它继承了MessageSource接口，说明它具有解析参数化和国际化消息的功能。

2.2 BeanFactory

要实现IOC容器，BeanFactory是不可或缺的一环，它负责bean的创建和管理。从ApplicationContext的类图中可以看出，ApplicationContext并不是直接继承BeanFactory接口，而是继承了BeanFactory的子接口：ListableBeanFactory和HierarchicalBeanFactory。

2.2.1 BeanFactory

/**
 * 创建、获取bean以及一些bean相关的其他操作
 */
public interface BeanFactory {

    /**
     * FactoryBean的前缀
     */
    String FACTORY_BEAN_PREFIX = "&";

    /**
     * 返回name对应的bean对象
     */
    Object getBean(String name) throws BeansException;

    /**
     * 返回指定type和name的bean对象
     */
     T getBean(String name, Class requiredType) throws BeansException;

    /**
     * 返回现有对象或者用传入的args创建对象，非原型模式传入args会报错
     */
    Object getBean(String name, Object... args) throws BeansException;

    /**
     * 只能返回指定类型的唯一对象，大于小于一个都报错
     */
     T getBean(Class requiredType) throws BeansException;

    /**
     * 返回requiredType对应的bean对象或者用传入的args创建对象，非原型模式传入args会报错
     */
     T getBean(Class requiredType, Object... args) throws BeansException;

    /**
     * 获取requiredType类型的ObjectProvider
     */
     ObjectProvider getBeanProvider(Class requiredType);

    /**
     * 获取requiredType类型的ObjectProvider
     */
     ObjectProvider getBeanProvider(ResolvableType requiredType);

    /**
     * 是否存在名字为name的bean
     */
    boolean containsBean(String name);

    /**
     * 名字为name的bean是否单例bean
     */
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

    /**
     * 是否原型bean
     */
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

    /**
     * 指定bean是否该类型
     */
    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

    /**
     * 指定bean是否该类型
     */
    boolean isTypeMatch(String name, Class typeToMatch) throws NoSuchBeanDefinitionException;

    /**
     * 获取指定bean的类型
     */
    @Nullable
    Class getType(String name) throws NoSuchBeanDefinitionException;

    /**
     * 获取指定bean的别名
     */
    String[] getAliases(String name);
}

从BeanFactory的源码中可以看出，BeanFactory定义了一些对bean的基本操作。继承BeanFactory，ApplicationContext就有了对bean进行操作的行为。

2.2.2 ListableBeanFactory

上面BeanFactory定义的都是对单个bean进行的操作，而ListableBeanFactory定义的操作大多数都是返回多个bean或者bean相关元素。从“Listable”就可以看出来，它定义了一些对bean进行列表化的操作。因此，ApplicationContext也可以对bean进行一些列表化操作。

/**
 * 可以枚举所有bean实例，而不是按客户端的请求逐个尝试按名称查找bean
 */
public interface ListableBeanFactory extends BeanFactory {

    /**
     * 是否存在指定name的BeanDefinition
     */
    boolean containsBeanDefinition(String beanName);

    /**
     * 获取BeanFactory中BeanDefinition的数量
     */
    int getBeanDefinitionCount();

    /**
     * 获取所有BeanDefinition的名字
     */
    String[] getBeanDefinitionNames();

    /**
     * 获取指定类型的beanName数组
     */
    String[] getBeanNamesForType(ResolvableType type);

    /**
     * 获取指定类型的beanName数组
     */
    String[] getBeanNamesForType(@Nullable Class type);

    /**
     * 获取指定类型的beanName数组，加了是否包含单例和非懒加载这几个限制
     */
    String[] getBeanNamesForType(@Nullable Class type, boolean includeNonSingletons, boolean allowEagerInit);

    /**
     * 获取指定类型的所有bean
     */
     Map getBeansOfType(@Nullable Class type) throws BeansException;

    /**
     * 获取指定类型的所有bean，加了是否包含单例和非懒加载这几个限制
     */
     Map getBeansOfType(@Nullable Class type, boolean includeNonSingletons, boolean allowEagerInit)
            throws BeansException;

    /**
     * 获取指定注解类型的beanNames
     */
    String[] getBeanNamesForAnnotation(Class annotationType);

    /**
     * 获取指定类型的bean对象
     */
    Map getBeansWithAnnotation(Class annotationType) throws BeansException;

    /**
     * 根据beanName和指定注解类型获取注解bean对象
     */
    @Nullable
     A findAnnotationOnBean(String beanName, Class annotationType)
            throws NoSuchBeanDefinitionException;
}

2.2.3 HierarchicalBeanFactory

HierarchicalBeanFactory定义的方法相对少点，它定义了对BeanFactory分级的一些操作，比如返回父BeanFactory。

/**
 * 定义了对BeanFactory层次结构的操作
 */
public interface HierarchicalBeanFactory extends BeanFactory {

    /**
     * Return the parent bean factory, or {@code null} if there is none.
     */
    @Nullable
    BeanFactory getParentBeanFactory();

    /**
     * 当前context（不包含祖先context）是否含有指定name的bean
     */
    boolean containsLocalBean(String name);
}

2.3 ResourceLoader

ResourceLoader是一个资源加载的策略接口，继承这个接口说明ApplicationContext有资源加载的功能，这也是Spring容器的第一步操作——加载配置文件。因为配置文件定义了bean以及bean之间的关系，所以只有把配置文件加载进来才能创建、管理bean。

/**
 * 资源加载的策略接口
 */
public interface ResourceLoader {

    /** Pseudo URL prefix for loading from the class path: "classpath:". */
    String CLASSPATH_URL_PREFIX = ResourceUtils.CLASSPATH_URL_PREFIX;


    /**
     * 返回指定路径的资源，这里只返回一个，说明不支持模式匹配
     */
    Resource getResource(String location);

    /**
     * 返回统一的ClassLoader，而不是依赖于线程上下文ClassLoader
     */
    @Nullable
    ClassLoader getClassLoader();
}

2.3.1 ResourcePatternResolver

从名字就可以看出来，ResourcePatternResolver对ResourceLoader进行了扩展，它支持解析模式匹配的路径。

/**
  * 解析模式匹配的路径，加载资源
  */
public interface ResourcePatternResolver extends ResourceLoader {

    /**
     * classpath url的前缀
     */
    String CLASSPATH_ALL_URL_PREFIX = "classpath*:";

    /**
     * 解析模式匹配的路径，返回多个Resource
     */
    Resource[] getResources(String locationPattern) throws IOException;

}

2.4 ApplicationEventPublisher

ApplicationEventPublisher定义了事件发布的功能，可以将事件发布给注册了此应用所有匹配的监听器。由此可见，ApplicationContet也可以发布事件。

/**
 * 定义了事件发布功能
 */
@FunctionalInterface
public interface ApplicationEventPublisher {

    default void publishEvent(ApplicationEvent event) {
        publishEvent((Object) event);
    }

    /**
     * 通知在此应用程序中注册的所有匹配的listeners
     */
    void publishEvent(Object event);
}

2.5 EnvironmentCapable

EnvironmentCapable中只定义了getEnvironment的方法，向外界暴露了Environment接口。Environment是Spring运行时的环境，它包含了profiles和properties。
在一个软件的开发过程中，我们往往要经过很多步骤，而这些执行步骤往往要将项目部署在不同的环境，比如测试时部署在测试环境、上线时部署在生产环境。profile正是起到了区分环境的作用，容器只会加载当前active的profile环境所定义的bean及其他配置。
properties是指当前应用的属性，它可以在System环境变量、properties文件等多个地方进行配置。

三、小结

ApplicationContext是一个BeanFactory，它包含了创建bean以及其他管理bean的功能，除此之外它还有下列功能：

解析参数化和国际化消息；
资源加载；
事件发布；
暴露环境。