⭐表示重要。

第一章：提出问题

  • 目前情况：DispatchServlet 加载 springmvc.xml ，此时整个 WEB 应用只创建一个 IOC 容器。将来整合 Mybatis 、配置声明式事务等，全都在 springmvc.xml 配置文件中配置其实也是可以的。但是，这样会导致配置文件太长，不容易维护。
  • 希望将配置文件分开：
    • 处理浏览器请求相关：springmvc.xml 配置文件。
    • 声明式事务和整合 Mybatis 相关：spring-persist.xml 配置文件。
  • 配置文件分开之后，可以让 DispatcherServlet 加载多个配置文件：
  1. <servlet>
  2.     <servlet-name>dispatcherServlet</servlet-name>
  3.     <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  4.     <init-param>
  5.         <param-name>contextConfigLocation</param-name>
  6.         <param-value>classpath:spring*.xml</param-value>
  7.     </init-param>
  8.     <load-on-startup>1</load-on-startup>
  9. </servlet>
  • 但是，如果希望上面的两个配置文件使用不同的机制来加载：
    • DispatchServlet 加载 springmvc.xml 配置文件：处理浏览器请求相关。
    • ContextLoaderListener 加载 spring-persist.xml 配置文件：不需要处理浏览器请求，需要配置持久化层相关功能。
  • 此时，会带来一个新的问题：在 WEB 应用中就会出现两个 IOC 容器：
    • DispatchServlet 创建一个 IOC 容器。
    • ContextLoaderListener 创建一个 IOC 容器。

注意：这个技术方案并不是 『必须』 这样做，而仅仅是 『可以』 这样做。

第二章：配置 ContextLoaderListener

2.1 创建 spring-persist.xml

创建 spring-persist.xml 文件.png

2.2 配置 ContextLoaderListener

  • web.xml
  1. <!-- 配置监听器 -->
  2. <listener>
  3.     <!-- 指定全类名 -->
  4.     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  5. </listener>
  7. <!-- 通过全局初始化参数指定 Spring 配置文件的位置 -->
  8. <context-param>
  9.     <param-name>contextConfigLocation</param-name>
  10.     <param-value>classpath:spring-persist.xml</param-value>
  11. </context-param>
  • 完整的 web.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
  5.                   http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
  6.          version="4.0">
  8.     <filter>
  9.         <filter-name>CharacterEncodingFilter</filter-name>
  10.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  11.         <init-param>
  12.             <param-name>encoding</param-name>
  13.             <param-value>UTF-8</param-value>
  14.         </init-param>
  15.         <init-param>
  16.             <param-name>forceRequestEncoding</param-name>
  17.             <param-value>true</param-value>
  18.         </init-param>
  19.         <init-param>
  20.             <param-name>forceResponseEncoding</param-name>
  21.             <param-value>true</param-value>
  22.         </init-param>
  23.     </filter>
  24.     <filter-mapping>
  25.         <filter-name>CharacterEncodingFilter</filter-name>
  26.         <url-pattern>/*</url-pattern>
  27.     </filter-mapping>
  29.     <filter>
  30.         <filter-name>hiddenHttpMethodFilter</filter-name>
  31.         <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
  32.     </filter>
  33.     <filter-mapping>
  34.         <filter-name>hiddenHttpMethodFilter</filter-name>
  35.         <url-pattern>/*</url-pattern>
  36.     </filter-mapping>
  38.     <!-- 配置监听器 -->
  39.     <listener>
  40.         <!-- 指定全类名 -->
  41.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  42.     </listener>
  44.     <!-- 通过全局初始化参数指定 Spring 配置文件的位置 -->
  45.     <context-param>
  46.         <param-name>contextConfigLocation</param-name>
  47.         <param-value>classpath:spring-persist.xml</param-value>
  48.     </context-param>
  50.     <!-- 配置SpringMVC中负责处理请求的核心Servlet，也被称为SpringMVC的前端控制器 -->
  51.     <servlet>
  52.         <servlet-name>dispatcherServlet</servlet-name>
  53.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  54.         <init-param>
  55.             <param-name>contextConfigLocation</param-name>
  56.             <param-value>classpath:springmvc.xml</param-value>
  57.         </init-param>
  58.         <load-on-startup>1</load-on-startup>
  59.     </servlet>
  60.     <servlet-mapping>
  61.         <servlet-name>dispatcherServlet</servlet-name>
  62.         <url-pattern>/</url-pattern>
  63.     </servlet-mapping>
  65. </web-app>

2.3 ContextLoaderListener

ContextLoaderListener.png

方法名 执行时机 作用
contextInitialized() Web 应用启动时执行 创建并初始化 IOC 容器
contextDestroyed() Web 应用卸载时执行 关闭 IOC 容器

2.4 ContextLoader

  • ContextLoader 是 ContextLoaderListener 的父类。

  • ① 指定配置文件位置的参数名： 

  1. public class ContextLoader {
  2.     ...
  4.     /**
  5.      * Name of servlet context parameter (i.e., {@value}) that can specify the
  6.      * config location for the root context, falling back to the implementation's
  7.      * default otherwise.
  8.      * @see org.springframework.web.context.support.XmlWebApplicationContext#DEFAULT_CONFIG_LOCATION
  9.      */
  10.     public static final String CONFIG_LOCATION_PARAM = "contextConfigLocation";
  11. }
  • ② 初始化 IOC 容器：
  1. public class ContextLoader {
  2.     ...
  3.     /**
  4.      * Initialize Spring's web application context for the given servlet context,
  5.      * using the application context provided at construction time, or creating a new one
  6.      * according to the "{@link #CONTEXT_CLASS_PARAM contextClass}" and
  7.      * "{@link #CONFIG_LOCATION_PARAM contextConfigLocation}" context-params.
  8.      * @param servletContext current servlet context
  9.      * @return the new WebApplicationContext
  10.      * @see #ContextLoader(WebApplicationContext)
  11.      * @see #CONTEXT_CLASS_PARAM
  12.      * @see #CONFIG_LOCATION_PARAM
  13.      */
  14.     public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
  15.         if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
  16.             throw new IllegalStateException(
  17.                     "Cannot initialize context because there is already a root application context present - " +
  18.                     "check whether you have multiple ContextLoader* definitions in your web.xml!");
  19.         }
  21.         servletContext.log("Initializing Spring root WebApplicationContext");
  22.         Log logger = LogFactory.getLog(ContextLoader.class);
  23.         if (logger.isInfoEnabled()) {
  24.             logger.info("Root WebApplicationContext: initialization started");
  25.         }
  26.         long startTime = System.currentTimeMillis();
  28.         try {
  29.             // Store context in local instance variable, to guarantee that
  30.             // it is available on ServletContext shutdown.
  31.             if (this.context == null) {
  32.                 this.context = createWebApplicationContext(servletContext);
  33.             }
  34.             if (this.context instanceof ConfigurableWebApplicationContext) {
  35.                 ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
  36.                 if (!cwac.isActive()) {
  37.                     // The context has not yet been refreshed -> provide services such as
  38.                     // setting the parent context, setting the application context id, etc
  39.                     if (cwac.getParent() == null) {
  40.                         // The context instance was injected without an explicit parent ->
  41.                         // determine parent for root web application context, if any.
  42.                         ApplicationContext parent = loadParentContext(servletContext);
  43.                         cwac.setParent(parent);
  44.                     }
  45.                     configureAndRefreshWebApplicationContext(cwac, servletContext);
  46.                 }
  47.             }
  48.             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
  50.             ClassLoader ccl = Thread.currentThread().getContextClassLoader();
  51.             if (ccl == ContextLoader.class.getClassLoader()) {
  52.                 currentContext = this.context;
  53.             }
  54.             else if (ccl != null) {
  55.                 currentContextPerThread.put(ccl, this.context);
  56.             }
  58.             if (logger.isInfoEnabled()) {
  59.                 long elapsedTime = System.currentTimeMillis() - startTime;
  60.                 logger.info("Root WebApplicationContext initialized in " + elapsedTime + " ms");
  61.             }
  63.             return this.context;
  64.         }
  65.         catch (RuntimeException | Error ex) {
  66.             logger.error("Context initialization failed", ex);
  67.             servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
  68.             throw ex;
  69.         }
  70.     }    
  71. }
  • ③ 创建 IOC 容器：
  1. public class ContextLoader {
  2.     ...
  3.     /**
  4.      * Instantiate the root WebApplicationContext for this loader, either the
  5.      * default context class or a custom context class if specified.
  6.      * <p>This implementation expects custom contexts to implement the
  7.      * {@link ConfigurableWebApplicationContext} interface.
  8.      * Can be overridden in subclasses.
  9.      * <p>In addition, {@link #customizeContext} gets called prior to refreshing the
  10.      * context, allowing subclasses to perform custom modifications to the context.
  11.      * @param sc current servlet context
  12.      * @return the root WebApplicationContext
  13.      * @see ConfigurableWebApplicationContext
  14.      */
  15.     protected WebApplicationContext createWebApplicationContext(ServletContext sc) {
  16.         Class<?> contextClass = determineContextClass(sc);
  17.         if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
  18.             throw new ApplicationContextException("Custom context class [" + contextClass.getName() +
  19.                     "] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");
  20.         }
  21.         return (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
  22.     }    
  23. }

第三章：探讨两个 IOC 容器之间的关系

  • 打印两个 IOC 容器对象的 toString() 方法：
  1. package com.github.fairy.era.handler;
  3. import com.github.fairy.era.service.HelloWorldService;
  4. import org.slf4j.Logger;
  5. import org.slf4j.LoggerFactory;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Controller;
  8. import org.springframework.ui.Model;
  9. import org.springframework.web.bind.annotation.GetMapping;
  10. import org.springframework.web.context.WebApplicationContext;
  11. import org.springframework.web.servlet.FrameworkServlet;
  13. import javax.servlet.ServletContext;
  15. /**
  16.  * @author 许大仙
  17.  * @version 1.0
  18.  * @since 2021-11-20 07:18
  19.  */
  20. @Controller
  21. public class HelloWorldHandler {
  23.     private Logger logger = LoggerFactory.getLogger(this.getClass());
  25.     @Autowired
  26.     private HelloWorldService helloWorldService;
  28.     @Autowired
  29.     private ServletContext servletContext;
  31.     @GetMapping("/hello/world")
  32.     public String helloWorld(Model model) {
  34.         String message = helloWorldService.getMessage();
  36.         model.addAttribute("message", message);
  38.         Object springMVCIOC = servletContext.getAttribute(FrameworkServlet.SERVLET_CONTEXT_PREFIX + "dispatcherServlet");
  39.         logger.info("springMVCIOC = {}", springMVCIOC);
  41.         Object springIOC = servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);
  42.         logger.info("springIOC = {}", springIOC);
  44.         return "target";
  45.     }
  47. }
  • 日志如下：
  1. 07:51:13.727] [INFO ] [http-nio-8080-exec-4] [com.github.fairy.era.handler.HelloWorldHandler] [springMVCIOC = WebApplicationContext for namespace 'dispatcherServlet-servlet', started on Sat Nov 20 07:51:08 CST 2021, parent: Root WebApplicationContext]
  2. [07:51:13.727] [INFO ] [http-nio-8080-exec-4] [com.github.fairy.era.handler.HelloWorldHandler] [springIOC = Root WebApplicationContext, started on Sat Nov 20 07:51:08 CST 2021]
  • 结论：两个组件分别创建的 IOC 容器是父子关系。
    • 父容器：ContextLoaderListener 创建的 IOC 容器。
    • 子容器：DispatchServlet 创建的 IOC 容器。
  • 父子关系是如何确定的？
    • Tomcat 在读取 web.xml 之后，加载组件的顺序就是监听器、过滤器、Servlet。
    • ContextLoaderListener 初始化时如果检查到有已经存在的根级别 IOC 容器，那么会抛出异常。
    • DispatcherServlet 创建的 IOC 容器会在初始化时先检查当前环境下是否存在已经创建好的 IOC 容器。
      • 如果有：则将已存在的这个 IOC 容器设置为自己的父容器。
      • 如果没有：则将自己设置为 root 级别的 IOC 容器。
  • DispatcherServlet 创建的 IOC 容器设置父容器的源码：
    • 所在类：org.springframework.web.servlet.FrameworkServlet
    • 所在方法：createWebApplicationContext()
  1. public abstract class FrameworkServlet extends HttpServletBean implements ApplicationContextAware {
  2.     ...
  3.     protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
  4.         Class<?> contextClass = this.getContextClass();
  5.         if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
  6.             throw new ApplicationContextException("Fatal initialization error in servlet with name '" + this.getServletName() + "': custom WebApplicationContext class [" + contextClass.getName() + "] is not of type ConfigurableWebApplicationContext");
  7.         } else {
  8.             ConfigurableWebApplicationContext wac = (ConfigurableWebApplicationContext)BeanUtils.instantiateClass(contextClass);
  9.             wac.setEnvironment(this.getEnvironment());
  10.             // 设置父子关系
  11.             wac.setParent(parent);
  12.             String configLocation = this.getContextConfigLocation();
  13.             if (configLocation != null) {
  14.                 wac.setConfigLocation(configLocation);
  15.             }
  17.             this.configureAndRefreshWebApplicationContext(wac);
  18.             return wac;
  19.         }
  20.     }    
  21. }

第四章：两个 IOC 容器之间 bean 的互相访问

  • EmpDao.java
  1. package com.github.fairy.era.dao;
  3. import org.springframework.stereotype.Repository;
  5. /**
  6.  * @author 许大仙
  7.  * @version 1.0
  8.  * @since 2021-11-20 18:07
  9.  */
  10. @Repository
  11. public class EmpDao {
  13.     public String getMessage() {
  14.         return "你好啊";
  15.     }
  17. }
  • EmpService.java
  1. package com.github.fairy.era.service;
  3. import com.github.fairy.era.dao.EmpDao;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Service;
  7. /**
  8.  * @author 许大仙
  9.  * @version 1.0
  10.  * @since 2021-11-20 18:08
  11.  */
  12. @Service
  13. public class EmpService {
  15.     @Autowired
  16.     private EmpDao empDao;
  19.     public String getMessage() {
  20.         return empDao.getMessage();
  21.     }
  23. }
  • EmpHandler.java
  1. package com.github.fairy.era.handler;
  3. import com.github.fairy.era.service.EmpService;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Controller;
  6. import org.springframework.ui.Model;
  7. import org.springframework.web.bind.annotation.GetMapping;
  9. /**
  10.  * @author 许大仙
  11.  * @version 1.0
  12.  * @since 2021-11-20 18:08
  13.  */
  14. @Controller
  15. public class EmpHandler {
  17.     @Autowired
  18.     private EmpService empService;
  20.     @GetMapping("/message")
  21.     public String message(Model model) {
  23.         model.addAttribute("message", empService.getMessage());
  25.         return "target";
  26.     }
  28. }
  • springmvc.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.        xmlns:context="http://www.springframework.org/schema/context"
  4.        xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns="http://www.springframework.org/schema/beans"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
  7.     <!-- 自动扫描包 -->
  8.     <context:component-scan base-package="com.github.fairy.era.handler"></context:component-scan>
  10.     <!-- 配置视图解析器 -->
  11.     <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
  12.         <property name="order" value="1"/>
  13.         <property name="characterEncoding" value="UTF-8"/>
  14.         <property name="templateEngine">
  15.             <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
  16.                 <property name="templateResolver">
  17.                     <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
  18.                         <!-- 物理视图：视图前缀+逻辑视图+视图后缀 -->
  19.                         <!-- 视图前缀 -->
  20.                         <property name="prefix" value="/WEB-INF/templates/"/>
  21.                         <!-- 视图后缀 -->
  22.                         <property name="suffix" value=".html"/>
  23.                         <property name="templateMode" value="HTML5"/>
  24.                         <property name="characterEncoding" value="UTF-8"/>
  25.                     </bean>
  26.                 </property>
  27.             </bean>
  28.         </property>
  29.     </bean>
  31.     <mvc:annotation-driven/>
  33.     <mvc:default-servlet-handler/>
  35.     <mvc:view-controller path="/" view-name="portal"/>
  37. </beans>
  • spring-presist.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  7.     <context:component-scan base-package="com.github.fairy.era.service,com.github.fairy.era.dao"/>
  9. </beans>
  • bean 所属 IOC 容器的关系：
    • 父容器：
      • EmpService。
      • EmpDao。
    • 子容器：
      • EmpController。
  • 结论：子容器中的 EmpHandler 装配父容器中的 EmpService 能够正常工作，说明子容器可以访问父容器中的 bean 。
  • 分析：子可父用，父不能子用的根本原因是子容器中有一个属性 getParent() 方法可以获取到父容器的这个对应的引用。
  • 源码分析：
    • ① 在 AbstractApplicationContext 类中，有 parent 属性。
    • ② 在 AbstractApplicationContext 类中，有获取 parent 属性的 getParent() 方法。
    • ③ 子容器可以通过 getParent() 方法获取到父容器对象的引用，进而调用父容器中类似 “getBean()” 这样的方法获取到需要的 bean 完成装配。
    • ④ 父容器中并没有类似 getChildren() 这样的方法，所以没法拿到子容器对象的引用。

两个 IOC 容器之间 bean 的互相访问.png

第五章：提出和解决重复创建对象的问题

5.1 提出有可能重复创建对象的问题

  • 修改 logback.xml ，将日志级别改为 DEBUG
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <configuration debug="true">
  3.     <!-- 指定日志输出的位置 -->
  4.     <appender name="STDOUT"
  5.               class="ch.qos.logback.core.ConsoleAppender">
  6.         <encoder>
  7.             <!-- 日志输出的格式 -->
  8.             <!-- 按照顺序分别是：时间、日志级别、线程名称、打印日志的类、日志主体内容、换行 -->
  9.             <pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger] [%msg]%n</pattern>
  10.             <charset>UTF-8</charset>
  11.         </encoder>
  12.     </appender>
  14.     <!-- 设置全局日志级别。日志级别按顺序分别是：DEBUG、INFO、WARN、ERROR -->
  15.     <!-- 指定任何一个日志级别都只打印当前级别和后面级别的日志。 -->
  16.     <root level="DEBUG">
  17.         <!-- 指定打印日志的appender，这里通过“STDOUT”引用了前面配置的appender -->
  18.         <appender-ref ref="STDOUT" />
  19.     </root>
  21.     <!-- 根据特殊需求指定局部日志级别 -->
  22.     <logger name="org.springframework.web.servlet.DispatcherServlet" level="DEBUG" />
  24. </configuration>
  • spring-persist.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  7.     <context:component-scan base-package="com.github.fairy.era"/>
  9. </beans>
  • springmvc.xml
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.        xmlns:context="http://www.springframework.org/schema/context"
  4.        xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns="http://www.springframework.org/schema/beans"
  5.        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
  7.     <!-- 自动扫描包 -->
  8.     <context:component-scan base-package="com.github.fairy.era"></context:component-scan>
  10.     <!-- 配置视图解析器 -->
  11.     <bean id="viewResolver" class="org.thymeleaf.spring5.view.ThymeleafViewResolver">
  12.         <property name="order" value="1"/>
  13.         <property name="characterEncoding" value="UTF-8"/>
  14.         <property name="templateEngine">
  15.             <bean class="org.thymeleaf.spring5.SpringTemplateEngine">
  16.                 <property name="templateResolver">
  17.                     <bean class="org.thymeleaf.spring5.templateresolver.SpringResourceTemplateResolver">
  18.                         <!-- 物理视图：视图前缀+逻辑视图+视图后缀 -->
  19.                         <!-- 视图前缀 -->
  20.                         <property name="prefix" value="/WEB-INF/templates/"/>
  21.                         <!-- 视图后缀 -->
  22.                         <property name="suffix" value=".html"/>
  23.                         <property name="templateMode" value="HTML5"/>
  24.                         <property name="characterEncoding" value="UTF-8"/>
  25.                     </bean>
  26.                 </property>
  27.             </bean>
  28.         </property>
  29.     </bean>
  31.     <mvc:annotation-driven/>
  33.     <mvc:default-servlet-handler/>
  35.     <mvc:view-controller path="/" view-name="portal"/>
  37. </beans>
  • 日志：
  1. ...
  2. [20:37:48.766] [DEBUG] [RMI TCP Connection(3)-127.0.0.1] [org.springframework.beans.factory.support.DefaultListableBeanFactory] [Creating shared instance of singleton bean 'empDao']
  3. [20:37:48.772] [DEBUG] [RMI TCP Connection(3)-127.0.0.1] [org.springframework.beans.factory.support.DefaultListableBeanFactory] [Creating shared instance of singleton bean 'empHandler']
  4. [20:37:48.791] [DEBUG] [RMI TCP Connection(3)-127.0.0.1] [org.springframework.beans.factory.support.DefaultListableBeanFactory] [Creating shared instance of singleton bean 'empService']
  6. ...
  8. [20:37:49.185] [DEBUG] [RMI TCP Connection(3)-127.0.0.1] [org.springframework.beans.factory.support.DefaultListableBeanFactory] [Creating shared instance of singleton bean 'empDao']
  9. [20:37:49.186] [DEBUG] [RMI TCP Connection(3)-127.0.0.1] [org.springframework.beans.factory.support.DefaultListableBeanFactory] [Creating shared instance of singleton bean 'empHandler']
  10. [20:37:49.187] [DEBUG] [RMI TCP Connection(3)-127.0.0.1] [org.springframework.beans.factory.support.DefaultListableBeanFactory] [Creating shared instance of singleton bean 'empService']

5.2 重复创建对象的问题

  • ① 浪费内存空间。
  • ② 两个 IOC 容器能力是不同的：
    • springmvc.xml：仅配置和处理请求相关的功能，所以不能给 service 类附加声明式事务功能。
      • 结论：基于 springmvc.xml 配置文件创建的 EmpService 的 bean 不带有声明式事务的功能。
      • 影响：DispatcherServlet 处理浏览器请求时会调用自己创建的 EmpController，然后再调用自己创建的EmpService，而这个 EmpService 是没有事务的，所以处理请求时 没有事务功能的支持。
    • spring-persist.xml：配置声明式事务，所以可以给 service 类附加声明式事务功能。
      • 结论：基于 spring-persist.xml 配置文件创建的 EmpService 有声明式事务的功能。
      • 影响：由于 DispatcherServlet 的 IOC 容器会优先使用自己创建的 EmpController，进而装配自己创建的EmpService，所以基于 spring-persist.xml 配置文件创建的有声明式事务的 EmpService 用不上。

5.3 解决重复创建对象的问题

5.3.1 解决方案一（建议使用）

  • 让两个配置文件配置自动扫描的包时，各自扫描各自的组件：
  • ① SpringMVC 就扫描 XxxHandler、XXXController 。
  • ② Spring 扫描 XxxService 和 XxxDao 。

5.3.2 解决方案二

  • 如果由于某种原因，必须扫描同一个包，确实存在重复创建对象的问题，可以采取下面的办法处理。
    • springmvc.xml 配置文件在整体扫描的基础上进一步配置：仅包含被 @Controller 注解标记的类。
    • spring-persist.xml 配置在整体扫描的基础上进一步配置：排除被 @Controller 注解标记的类。
  • 具体 springmvc.xml 配置文件中的配置方式如下：
  1. <!-- 两个Spring的配置文件扫描相同的包 -->
  2. <!-- 为了解决重复创建对象的问题，需要进一步制定扫描组件时的规则 -->
  3. <!-- 目标：『仅』包含@Controller注解标记的类 -->
  4. <!-- use-default-filters="false"表示关闭默认规则，表示什么都不扫描，此时不会把任何组件加入IOC容器；
  5.         再配合context:include-filter实现“『仅』包含”效果 -->
  6. <context:component-scan base-package="com.github.spring.component" use-default-filters="false">
  8.     <!-- context:include-filter标签配置一个“扫描组件时要包含的类”的规则，追加到默认规则中 -->
  9.     <!-- type属性：指定规则的类型，根据什么找到要包含的类，现在使用annotation表示基于注解来查找 -->
  10.     <!-- expression属性：规则的表达式。如果type属性选择了annotation，那么expression属性配置注解的全类名 -->
  11.     <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
  12. </context:component-scan>
  • 具体 spring-persist.xml 配置文件中的配置方式如下：
  1. <!-- 两个Spring的配置文件扫描相同的包 -->
  2. <!-- 在默认规则的基础上排除标记了@Controller注解的类 -->
  3. <context:component-scan base-package="com.github.spring.component">
  5.     <!-- 配置具体排除规则：把标记了@Controller注解的类排除在扫描范围之外 -->
  6.     <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
  7. </context:component-scan>