Spring源码探究：容器

结合源码分析 Spring 容器与 SpringMVC 容器之间的关系

问题

问题描述：项目中发现，自定义切面注解在 Controller 层正常工作，在 Service 层却无法正常工作。为了便于分析，去掉代码中的业务逻辑，只留下场景。

自定义注解，打印时间

/**
 * Description: 自定义打印时间的注解
 * Created by jiangwang3 on 2018/5/9.
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface PrintTime {
}

注解解析器

/**
 *Description:打印时间注解的解析器
 * @author jiangwang
 * @date 11:28 2018/5/14
 */
@Aspect
public class PrintTimeProcessor {
    private Logger LOGGER = LoggerFactory.getLogger(getClass());
    @Pointcut("@annotation(com.foo.service.annotation.PrintTime)")
    public void printTimePoint() {
    }
    @Around("printTimePoint()")
    public Object process(ProceedingJoinPoint jp) throws Throwable{
        System.out.println();
        LOGGER.error("开始运行程序。。。Start==>");
        Object proceed = jp.proceed();
        LOGGER.error("结束啦，运行结束==>");
        System.out.println();
        return proceed;
    }
}

Controller层

/**
 * @author jiangwang
 * @date  2018/5/14
 */
@RestController
@RequestMapping(value = "/user")
public class UserController {
    private Logger logger = LoggerFactory.getLogger(getClass());
    @Resource
    private UserService userService;
    @RequestMapping(value = "/serviceAspect", method={RequestMethod.GET})
    public  String serviceAspect(){
        return userService.serviceAspect();
    }
    @RequestMapping(value = "/controllerAspect", method={RequestMethod.GET})
    @PrintTime
    public  String name(){
        logger.info("Controller层----测试切面");
        return "controllerAspect";
    }
}

Service层

/**
 * @author jiangwang
 * @date 11:34 2018/5/14
 */
@Service
public class UserService {
    private Logger logger = LoggerFactory.getLogger(getClass())
    @PrintTime
    public String serviceAspect(){
        logger.info("Service层---测试切面");
        return "serviceAspect";
    }
}

spring.xml 配置文件，主要部分

<context:annotation-config />
<!-- 动态代理开启 -->
<aop:aspectj-autoproxy proxy-target-class="true" />
<context:component-scan base-package="com.foo" >
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
</context:component-scan>
<!-- 公共配置引入 -->
<import resource="classpath:spring/spring-config-dao.xml" />

springmvc.xml 配置文件，主要部分

<mvc:annotation-driven />
<mvc:default-servlet-handler />
<!-- 动态代理开启 -->
<aop:aspectj-autoproxy proxy-target-class="true" />
<!-- mvc controller -->
<context:component-scan base-package="com.foo.web.controller" use-default-filters="false">
    <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service" />
</context:component-scan>
<bean class="com.foo.service.processor.PrintTimeProcessor"/>

以上为主要代码。项目运行之后，发现在 Service 层的注解切面未生效，而在 Controller 层正常。而当我将 springmvc.xml 中的

<bean class="com.foo.service.processor.PrintTimeProcessor"/>

迁移至 spring.xml 中，发现 Service 层与 Controller 层的注解切面均可正常运行。 WHY???

从源码的角度探究该问题

由于源码中的方法较长，所以只贴出 重点 且与 主题相关 的代码。建议结合本地源码一起看。

为了说清楚这个问题，咱们先看一下Spring容器是如何实现 Bean 自动注入（简化版）

Web 项目的入口是 web.xml，所以咱们从它开始。

web.xml 配置文件，主要部分

<!-- Spring Config -->
<listener>
  <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<context-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>classpath:spring/spring-config.xml</param-value>
</context-param>

<!-- SpringMvc Config -->
<servlet>
  <servlet-name>springMvc</servlet-name>
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  <init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:spring/spring-mvc.xml</param-value>
  </init-param>
  <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
  <servlet-name>springMvc</servlet-name>
  <url-pattern>/*</url-pattern>
</servlet-mapping>

Spring 容器 Bean 加载流程

从 Spring 配置部分可以看出，ContextLoaderListener 监听器是 Spring 容器的入口，进入该文件：

public class ContextLoaderListener extends ContextLoader implements ServletContextListener {
    public ContextLoaderListener() {
    }
    public ContextLoaderListener(WebApplicationContext context) {
        super(context);
    }
    @Override
    public void contextInitialized(ServletContextEvent event) {
        initWebApplicationContext(event.getServletContext());
    }
    @Override
    public void contextDestroyed(ServletContextEvent event) {
        closeWebApplicationContext(event.getServletContext());
        ContextCleanupListener.cleanupAttributes(event.getServletContext());
    }
}

ContextLoaderListener监听器一共有四个方法，可以很容易地判断出来，进入该监听器后，会进入初始化方法： contextInitialized 。继而进入  initWebApplicationContext  方法，方法注释中  “Initialize Spring’s web application context for the given servlet context” ，明确表明了该方法的目的是 初始化 Spring Web 应用 。这段代码中有两句话比较关键：

this.context = createWebApplicationContext(servletContext);

创建 Web 应用容器，即创建了 Spring 容器；

configureAndRefreshWebApplicationContext(cwac, servletContext);

配置并刷新Spring容器。后续发生的所有事，都是从它开始的。进入，里面的重点代码是：

wac.refresh();

refresh() 方法是spring容器注入bean的核心方法，每一行代码都很重要。代码结构也非常优美，每一行代码背后都完成了一件事，代码结构比较容易理解。由于内容较多，只讲里面跟主题相关的两句话：

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

获取 Bean 工厂，把你配置文件中的内容，放在 Bean 工厂中，留着后面创建 Bean 时用。

finishBeanFactoryInitialization(beanFactory);

开始创建 Bean，即实现 Spring 中的自动注入功能。进入该方法后，末尾有这么一句话：

beanFactory.preInstantiateSingletons();

继续跟进，贴出该方法中的重点代码：

getBean(beanName);

我们在 preInstantiateSingletons() 方法中，会发现有多个地方出现了 getBean() 方法，究竟咱们贴出来的是哪一句？无关紧要。跟进去之后，

@Override
public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
}

这里调用了 doGetBean() 方法，Spring 中只要以 do  命名的方法，都是真正干活的。重点代码分段贴出分析：

// Eagerly check singleton cache for manually registered singletons.
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);
}

直接获取 单例 Bean ，若没有取到，继续往下走：

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

这一段代码单独看，不知所云，里面提到了一个词：Parent。 暂且跳过，后续会回来分析这一段。 继续：

// Create bean instance.
if (mbd.isSingleton()) {
       sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
            @Override
             public Object getObject() throws BeansException {
                 try {
                     return createBean(beanName, mbd, args);
                  }
                  catch (BeansException ex) {
                      // Explicitly remove instance from singleton cache: It might have been put there
                      // eagerly by the creation process, to allow for circular reference resolution.
                      // Also remove any beans that received a temporary reference to the bean.
                      destroySingleton(beanName);
                      throw ex;
                 }
                }
         });
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}

这段代码中有 createBean，咱们的目的是分析 Bean 的创建过程，此处出现了 create ，毫不犹豫地跟进，进入实现类中的方法，有这么一句：

Object beanInstance = doCreateBean(beanName, mbdToUse, args);

刚才咱们提了，Spring 中有 do  命名的方法，是真正干活的。跟进：

instanceWrapper = createBeanInstance(beanName, mbd, args);

这句话是初始化 Bean，即创建了 Bean，等价于调用了一个类的空构造方法。此时，已经成功地创建了对象，下文需要做的是，给该对象注入需要的属性；

populateBean(beanName, mbd, instanceWrapper);

填充 Bean 属性，就是刚才咱们提的，初始化一个对象后，只是一个空对象，需要给它填充属性。跟进，看 Spring 是如何为对象注入属性的，或者说，看一下 Spring 是如何实现 Bean 属性的自动注入：

pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);

继续进入 AutowiredAnnotationBeanPostProcessor 的 postProcessPropertyValues 方法：

metadata.inject(bean, beanName, pvs);

这句话中，出现了 inject ，这个词的意思是 “注入” 。咱们可以断定，Spring 的自动注入，八成跟它有关了。进入该方法：

<code>element.inject(target, beanName, pvs); </code>

与上一句一样，只是做了一些参数处理，并没有开始注入。继续跟进看：

Field field = (Field) this.member;
ReflectionUtils.makeAccessible(field);
field.set(target, getResourceToInject(target, requestingBeanName));

看到这里，大概明白了 Spring 是如何自动注入了。 Java 反射 相关的代码，通过反射的方式给 field 赋值。这里的  field  是 Bean 中的某一个属性，例如咱们开始时的 UserController 类中的  userService 。getResourceToInject，获取需要赋予的值了，其实这里会重新进入 getBean 方法，获取 Bean 值（例如 UserController 对象中需要注入 userService。），然后赋予 field。至此，Spring容器已经初始化完成，Spring Bean注入的大概流程，咱们也已经熟悉了。回到开始初始化 Spring 容器的地方，ContextLoader 类 initWebApplicationContext 方法，

servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

初始化 Spring 容器之后，将其放入了 servletContext 中。

咱们的问题是，“ 在项目中，自定义切面注解在 Controller 层正常工作，却在 Service 层无法正常工作？” 看完这个，其实并没有解答该问题，咱们下面继续看 SpringMVC Bean的加载流程，看完 SpringMVC 后，答案会自动浮出水面。

SpringMVC 容器 Bean 加载流程

同样，从 web.xml 中的 SpringMVC 配置出发，里面有 DispatcherServlet，这是 SpringMVC 的入口，跟进之后发现方法较多，无法知道会执行哪个方法。但是咱们要记住， DispatcherServlet  本质上是一个 Servlet ，通过它的继承关系图也可以证明：

DispatcherServlet继承关系图

看一下 Servlet 的接口：

public interface Servlet {
    public void init(ServletConfig config) throws ServletException;
    public ServletConfig getServletConfig();
    public void service(ServletRequest req, ServletResponse res)
            throws ServletException, IOException;
    public String getServletInfo();
    public void destroy();
}

从 Servlet 接口方法中可以看出，Servlet 的入口是 init  方法，层层跟进（一定要根据 DispatcherServlet 继承图跟进），进入到了 FrameworkServlet 的  initServletBean()  方法，进入方法，贴出重点代码：

this.webApplicationContext = initWebApplicationContext();

字面理解，初始化 SpringMVC Web容器，进入探究：

WebApplicationContext rootContext = WebApplicationContextUtils.getWebApplicationContext(getServletContext());

前面咱们提到，Spring 容器初始化完成之后，放入了 servletContext  中。这里又从 servletContext 获取到了  Spring 容器 ；

wac = createWebApplicationContext(rootContext);

字面理解创建 Web 应用容器，且参数是 Spring 容器。跟进方法：

ConfigurableWebApplicationContext wac = (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);

创建web应用容器，即咱们所理解的 SpringMVC 容器 在此创建了；

wac.setParent(parent);

这里是重点，SpringMVC 容器将 Spring 容器设置成了自己的 父容器 。

configureAndRefreshWebApplicationContext(wac);

这个方法刚才在分析 Spring Bean 加载流程时，分析过了。其中有一段，前面说， “暂且跳过，后续会回来分析这一段” 。现在开始分析：

在 AbstractBeanFactory 类 doGetBean 方法，有这么一段：

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

这里其实是在获取父容器中的 Bean，若获取到，直接拿到 Bean，这个方法就结束了。 结论：子容器可以使用父容器里的 Bean，反之则不行。

现在来解答咱们的问题

<bean class="com.foo.service.processor.PrintTimeProcessor"/>

当上门这句话放在 springmvc.xml 中时，名为 “printTimeProcessor”  的 Bean 会存在于 SpringMVC 容器，那么 Spring 容器是无法获取它的。而 Service 层恰巧是存在于 Spring 容器中，所以  “printTimeProcessor”  切面对 Service 层不起作用。而 Controller 层本身存在于 SpringMVC 容器，所以 Controller 层可以正常工作。而当它放在 spring.xml 中时，”printTimeProcessor” 是存在于 Spring 容器中，SpringMVC 容器是 Spring 容器的子容器，子容器可以获取到父容器的 Bean，所以 Controller 层与 Service 层都能获取到该 Bean，所有都能正常使用它。