为什么需要整合SpringMVC

Spring和Mybatis以前已经整合过，这样能够更加方便的使用Mybatis,但为什么还需要整合SpringMVC呢？SpringMVC不是已经属性Spring的一部分了吗？为什么还需要整合？
是需要整合的，因为现在所有的Bean都在同一个容器里面。我们通常在Controller层调用Service层，Service层调用Dao层，如果在Service层也调用Controller层的代码，比如在Service层里面注入Controller，代码就会变得混乱。为了解决这个问题，我们需要从代码层面进行隔离，如果Controller层的代码放在一个容器、Service层的代码放在另一个容器里面，彼此容器相互隔离就好了，于是父子容器的方案就诞生啦。

相关准备和依赖

在实现父子容器方案前，我们需要对项目做准备工作

模型数据

  1. package com.lff.domain;
  3. public class Customer {
  4.     private Integer custId;
  5.     private String custName;
  6.     private String custAddress;
  7.     private String custCity;
  8.     private String custState;
  9.     private String custZip;
  10.     private String custCountry;
  11.     private String custContact;
  12.     private String custEmail;
  14.     //getter setter
  16. }

Dao层

  1. package com.lff.dao;
  3. import com.lff.domain.Customer;
  4. import org.apache.ibatis.annotations.Select;
  6. import java.util.List;
  8. public interface CustomerDao {
  9.     Boolean save(Customer customer);
  10.     Boolean update(Customer customer);
  11.     List<Customer> list();
  12.     Customer get(Integer id);
  13.     Boolean remove(Integer id);
  14. }

Service层

  1. package com.lff.service;
  2. import com.lff.domain.Customer;
  3. import java.util.List;
  5. public interface CustomerService {
  6.     Boolean save(Customer customer);
  7.     Boolean update(Customer customer);
  8.     List<Customer> list();
  9.     Customer get(Integer id);
  10. }

实现类

  1. package com.lff.service.impl;
  3. import com.lff.dao.CustomerDao;
  4. import com.lff.domain.Customer;
  5. import com.lff.service.CustomerService;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Component;
  9. import java.util.List;
  11. @Component
  12. public class CustomerServiceImpl implements CustomerService {
  13.     @Autowired
  14.     CustomerDao customerDao;
  15.     @Override
  16.     public Boolean save(Customer customer) {
  18.         return customerDao.save(customer);
  19.     }
  21.     @Override
  22.     public Boolean update(Customer customer) {
  24.         return customerDao.update(customer);
  25.     }
  27.     @Override
  28.     public List<Customer> list() {
  29.         return customerDao.list();
  30.     }
  32.     @Override
  33.     public Customer get(Integer id) {
  35.         return customerDao.get(id);
  36.     }
  37. }

Controller层

  1. package com.lff.controller;
  2. import com.lff.domain.Customer;
  3. import com.lff.service.CustomerService;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Controller;
  6. import org.springframework.web.bind.annotation.RequestMapping;
  7. import org.springframework.web.bind.annotation.ResponseBody;
  9. import java.util.List;
  11. @Controller
  12. @RequestMapping("/customers")
  13. public class CustomerController {
  14.     @Autowired
  15.     private CustomerService service;
  17.     public void setService(CustomerService service) {
  18.         this.service = service;
  19.     }
  21.     @RequestMapping("/list")
  22.     @ResponseBody
  23.     public List<Customer> list(){
  24.         return service.list();
  25.     }
  27.     @RequestMapping("/update")
  28.     @ResponseBody
  29.     public String  update() {
  30.         Customer customers1 = new Customer();
  31.         customers1.setCustId(1013);
  32.         customers1.setCustName("lffxxx");
  33.         customers1.setCustState("ss");
  34.         customers1.setCustCity("BJ");
  35.         customers1.setCustState("CN");
  36.         customers1.setCustZip("10001");
  37.         return service.update(customers1) ? "success":"error";
  38.     }
  40. }

Maven依赖配置

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>com.ff</groupId>
  8.     <artifactId>Demo5</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <!--打包方式默认是jar,web工程打包为war，Java工程打包为jar -->
  12.     <packaging>war</packaging>
  14.     <!--属性信息比如字符编码等 -->
  15.     <properties>
  16.         <!--字符编码 -->
  17.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  18.         <!--Maven项目的JDK版本 -->
  19.         <maven.compiler.source>8</maven.compiler.source>
  20.         <maven.compiler.target>8</maven.compiler.target>
  21.     </properties>
  23.     <!-- 依赖-->
  24.     <dependencies>
  25.         <!-- JavaEE基本依赖-->
  26.         <dependency>
  27.             <groupId>javax.servlet</groupId>
  28.             <artifactId>javax.servlet-api</artifactId>
  29.             <version>4.0.1</version>
  30.             <scope>provided</scope>
  31.         </dependency>
  32.         <dependency>
  33.             <groupId>javax.servlet</groupId>
  34.             <artifactId>jsp-api</artifactId>
  35.             <version>2.0</version>
  36.             <scope>provided</scope>
  37.         </dependency>
  39.         <!-- SpringMVC -->
  40.         <dependency>
  41.             <groupId>org.springframework</groupId>
  42.             <artifactId>spring-webmvc</artifactId>
  43.             <version>5.2.8.RELEASE</version>
  44.         </dependency>
  46. <!--        面向切面编程-->
  47.         <dependency>
  48.             <groupId>org.aspectj</groupId>
  49.             <artifactId>aspectjweaver</artifactId>
  50.             <version>1.9.6</version>
  51.         </dependency>
  52.         <dependency>
  53.             <groupId>org.aspectj</groupId>
  54.             <artifactId>aspectjrt</artifactId>
  55.             <version>1.9.6</version>
  56.         </dependency>
  59. <!--        mybatis相关包-->
  60.         <dependency>
  61.             <groupId>org.mybatis</groupId>
  62.             <artifactId>mybatis</artifactId>
  63.             <version>3.5.5</version>
  64.         </dependency>
  66.         <dependency>
  67.             <groupId>org.mybatis</groupId>
  68.             <artifactId>mybatis-spring</artifactId>
  69.             <version>2.0.5</version>
  70.         </dependency>
  71.         <dependency>
  72.             <groupId>org.springframework</groupId>
  73.             <artifactId>spring-jdbc</artifactId>
  74.             <version>5.2.8.RELEASE</version>
  75.         </dependency>
  77. <!--        数据库-->
  78.         <dependency>
  79.             <groupId>mysql</groupId>
  80.             <artifactId>mysql-connector-java</artifactId>
  81.             <version>5.1.49</version>
  82.         </dependency>
  84.         <!--        数据库连接池-->
  85.         <dependency>
  86.             <groupId>com.alibaba</groupId>
  87.             <artifactId>druid</artifactId>
  88.             <version>1.1.22</version>
  89.         </dependency>
  91.         <!-- 日志 -->
  92.         <dependency>
  93.             <groupId>ch.qos.logback</groupId>
  94.             <artifactId>logback-classic</artifactId>
  95.             <version>1.2.3</version>
  96.         </dependency>
  98.         <!-- 单元测试 -->
  99.         <dependency>
  100.             <groupId>junit</groupId>
  101.             <artifactId>junit</artifactId>
  102.             <version>4.13</version>
  103.             <scope>test</scope>
  104.         </dependency>
  107.         <!-- domain模型转JSON字符串 -->
  108.         <dependency>
  109.             <groupId>com.fasterxml.jackson.core</groupId>
  110.             <artifactId>jackson-databind</artifactId>
  111.             <version>2.11.0</version>
  112.         </dependency>
  114.         <!-- 解析Multipart类型参数 -->
  115.         <dependency>
  116.             <groupId>commons-fileupload</groupId>
  117.             <artifactId>commons-fileupload</artifactId>
  118.             <version>1.4</version>
  119.         </dependency>
  122.     </dependencies>
  125. </project>

设置打包资源

  1.     <!--构建信息比如插件配置等-->
  2.     <build>
  3.         <finalName>demo5</finalName>
  4.         <!-- 说明资源的位置（哪些东西算是资源） -->
  5.         <resources>
  6.             <!-- resources文件里面的内容要进行打包 -->
  7.             <resource>
  8.                 <directory>src/main/resources</directory>
  9.             </resource>
  10.             <!-- java文件里面的内容要进行打包 -->
  11.             <resource>
  12.                 <directory>src/main/java</directory>
  13.                 <includes>
  14.                     <include>**/*.properties</include>
  15.                     <include>**/*.xml</include>
  16.                 </includes>
  17.             </resource>
  18.         </resources>
  20.     </build>

父子容器

Spring、SpringMVC和Mybatis整合 - 图1

父容器和子容器相互隔离，可以存在相同名称的Bean。子容器可以访问父容器里面的Bean，父容器不能访问子容器的Bean，也就是控制器层可以注入Service的代码，Service不能注入Controller层的代码。当在子容器中查找Bean时，比如调用getBean方法会先在子容器里面查找，如果没有就会向父容器里面查找，直到查找到为止。

配置父子容器文件

新建子容器配置文件dispatcherServlet.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.        xmlns:mvc="http://www.springframework.org/schema/mvc"
  6.        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">
  8.     <context:component-scan base-package="com.lff.controller"/>
  10.     <mvc:annotation-driven />
  12. </beans>

注意此时扫描的包，确保只扫描SpringMVC的Bean，如Controller等

  1. <context:component-scan base-package="com.lff.controller"/>

父容器配置文件还是applicationContext.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" xmlns:tx="http://www.springframework.org/schema/tx"
  5.        xmlns:aop="http://www.springframework.org/schema/aop" xmlns:mvc="http://www.springframework.org/schema/mvc"
  6.        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/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop https://www.springframework.org/schema/aop/spring-aop.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd">
  9.     <context:component-scan base-package="com.lff.service"/>
  12.     <!-- 数据源（Druid） 当然可以使用其的数据源-->
  13.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
  14.         <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
  15.         <property name="url" value="jdbc:mysql://localhost:3306/customer_test"/>
  16.         <property name="username" value="root"/>
  17.         <property name="password" value="root"/>
  18.     </bean>
  20.     <!-- 创建SqlSessionFactory -->
  21.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  22.         <!-- 数据源 -->
  23.         <property name="dataSource" ref="dataSource"/>
  24.         <!-- 这个包底下的类会自动设置别名（一般是领域模型） -->
  25.         <property name="typeAliasesPackage" value="com.lff.domain"/>
  26.         <!-- 映射文件的位置 -->
  27. <!--        <property name="mapperLocations">-->
  28. <!--            <array>-->
  29. <!--                <value>classpath:mappers/*.xml</value>-->
  30. <!--            </array>-->
  31. <!--        </property>-->
  32.     </bean>
  34.     <!-- 扫描dao，生成Dao的代理对象 -->
  35.     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  36.         <!-- 设置SqlSessionFactoryBean的id -->
  37.         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
  38.         <!-- 设置dao的包 -->
  39.         <property name="basePackage" value="com.lff.dao"/>
  40.     </bean>
  42.     <!-- 事务管理器 -->
  43.     <bean id="transactionManager"
  44.           class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  45.         <!-- 数据源 -->
  46.         <property name="dataSource" ref="dataSource" />
  47.     </bean>
  49.     <!-- 附加代码：事务管理代码 -->
  50.     <tx:advice id="txAdvice" transaction-manager="transactionManager">
  51.         <tx:attributes>
  52.             <tx:method name="*"/>
  53.             <tx:method name="list*" read-only="true"/>
  54.             <tx:method name="get*" read-only="true"/>
  55.         </tx:attributes>
  56.     </tx:advice>
  58.     <!-- 切面 -->
  59.     <aop:config>
  60.         <aop:pointcut id="pc" expression="within(com.mj.service..*)"/>
  61.         <aop:advisor advice-ref="txAdvice" pointcut-ref="pc"/>
  62.     </aop:config>
  63. </beans>

注意父容器扫描的是Service层，千万不要扫描Controller层，一般扫描非SpringMVC共用的Bean

  1.  <context:component-scan base-package="com.lff.service"/>

上面的MyBatis配置文件中，我们并没有告诉Mapper文件的位置

  1.     <!-- 创建SqlSessionFactory -->
  2.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  3.         <!-- 数据源 -->
  4.         <property name="dataSource" ref="dataSource"/>
  5.         <!-- 这个包底下的类会自动设置别名（一般是领域模型） -->
  6.         <property name="typeAliasesPackage" value="com.lff.domain"/>
  7.         <!-- 映射文件的位置 -->
  8. <!--        <property name="mapperLocations">-->
  9. <!--            <array>-->
  10. <!--                <value>classpath:mappers/*.xml</value>-->
  11. <!--            </array>-->
  12. <!--        </property>-->
  13.     </bean>

因为我们可以把mapper文件放在和Dao相同的目录下，并且文件名称与Dao的类名保持一致。
image.png

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  6. <mapper namespace="com.lff.dao.CustomerDao">
  7.     <!--查询所有的顾客-->
  8.     <select id="list" resultMap="customerDomain">
  9.         SELECT * FROM Customers
  10.     </select>
  11.     <resultMap id="customerDomain" type="com.lff.domain.Customer">
  12.         <result property="custName" column="cust_name" />
  13.         <result property="custCity" column="cust_city" />
  14.     </resultMap>
  16.     <!--    移除一个顾客-->
  17.     <delete id="remove" parameterType="int">
  18.         DELETE FROM Customers WHERE cust_id = #{id}
  19.     </delete>
  21.     <update id="update" parameterType="com.lff.domain.Customer">
  22.         UPDATE Customers SET cust_name=#{custName},cust_address = #{custAddress},cust_city=#{custCity},cust_state=#{custState},cust_zip=#{custZip} where cust_id = #{custId}
  23.     </update>
  25.     <insert id="save" parameterType="com.lff.domain.Customer">
  26.         INSERT INTO Customers(cust_id,cust_name,cust_address,cust_city,cust_state,cust_zip) values (#{custId},#{custName},#{custAddress},#{custCity},#{custState},#{custZip})
  27.     </insert>
  30. </mapper>

当然还需要在Maven配置文件中加如下配置，因为Maven默认情况下是不会对我们的源代码文件里面的XML、Properties文件进行打包的

  1.     <!--构建信息比如插件配置等-->
  2.     <build>
  3.         <finalName>demo5</finalName>
  4.         <!-- 说明资源的位置（哪些东西算是资源） -->
  5.         <resources>
  6.             <!-- resources文件里面的内容要进行打包 -->
  7.             <resource>
  8.                 <directory>src/main/resources</directory>
  9.             </resource>
  10.             <!-- java文件里面的内容要进行打包 -->
  11.             <resource>
  12.                 <directory>src/main/java</directory>
  13.                 <includes>
  14.                     <include>**/*.properties</include>
  15.                     <include>**/*.xml</include>
  16.                 </includes>
  17.             </resource>
  18.         </resources>
  20.     </build>

这样才会把Mapper文件也打包进行去
image.png

加载父容器、子容器

在web.xml文件中进行加载父容器、子容器

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
  5.          version="4.0">
  7. <!--    使用SpringMVC提供的DispatcherServlet进行处理拦截客户端的请求-->
  8.     <servlet>
  9.         <servlet-name>springmvc</servlet-name>
  10.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
  12. <!--        加载Spring的配置文件，配置文件里面配置要扫描的类等-->
  13.         <init-param>
  14.             <param-name>contextConfigLocation</param-name>
  15. <!--            加载子容器-->
  16.             <param-value>classpath:dispatcherServlet.xml</param-value>
  17.         </init-param>
  18.         <!-- 项目部署到服务器，就会创建Servlet -->
  19.         <load-on-startup>0</load-on-startup>
  20.     </servlet>
  22.     <servlet-mapping>
  23.         <servlet-name>springmvc</servlet-name>
  24. <!-- 拦截客户端所有请求路径-->
  25.         <url-pattern>/</url-pattern>
  26.     </servlet-mapping>
  28. <!--    父容器的配置-->
  29.     <context-param>
  30.         <param-name>contextConfigLocation</param-name>
  31.         <param-value>classpath:applicationContext.xml</param-value>
  32.     </context-param>
  34. <!--    监听器监听到项目的部署就会加载上面的context-param，加载父容器applicationContext.xml-->
  35.     <listener>
  36.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
  37.     </listener>
  43. <!--    使用springMVC自带的过滤器处理post请求乱码问题-->
  44.     <filter>
  45.         <filter-name>characterEncodingFilter</filter-name>
  46.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
  47.         <init-param>
  48.             <param-name>encoding</param-name>
  49.             <param-value>UTF-8</param-value>
  50.         </init-param>
  51.     </filter>
  53.     <filter-mapping>
  54.         <filter-name>characterEncodingFilter</filter-name>
  55.         <url-pattern>/*</url-pattern>
  56.     </filter-mapping>
  58. </web-app>

这样在请求控制器层就可以了。

纯注解的方式实现SSM整合

做好上面准备和依赖后(Dao层、Service层、Controller层、Maven依赖)的处理步骤如下

web.xml的配置可以删除

当项目启动后会加载web.xml文件，我们可以使用如下方式替代

  1. package com.lff.config;
  3. import org.springframework.web.filter.CharacterEncodingFilter;
  4. import org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;
  6. import javax.servlet.FilterRegistration;
  7. import javax.servlet.ServletContext;
  8. import javax.servlet.ServletException;
  10. public class WebInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
  11.     /**
  12.      * 父容器的配置类
  13.      */
  14.     @Override
  15.     protected Class<?>[] getRootConfigClasses() {
  16.         return new Class[]{SpringConfig.class};
  17.     }
  19.     /**
  20.      * 子容器的配置类(SpringMVC相关的配置类)
  21.      */
  22.     @Override
  23.     protected Class<?>[] getServletConfigClasses() {
  24.         return new Class[]{SpringMVCConfig.class};
  25.     }
  27.     /**
  28.      * 配置DispatcherServlet的url-pattern
  29.      */
  30.     @Override
  31.     protected String[] getServletMappings() {
  32.         return new String[]{"/"};
  33.     }
  35.     @Override
  36.     public void onStartup(ServletContext servletContext) throws ServletException {
  37.         super.onStartup(servletContext);
  39.         // 添加Filter
  40.         FilterRegistration.Dynamic encodingFilter = servletContext.addFilter("CharacterEncodingFilter", new CharacterEncodingFilter("UTF-8"));
  41.         encodingFilter.addMappingForUrlPatterns(null, false, "/*");
  42.     }
  43. }

项目部署的时候，就会先看有没有实现WebApplicationInitializer接口，如果实现这个接口就会实例化实现该接口的类，创建该类的对象，调用onStartup方法。而上面AbstractAnnotationConfigDispatcherServletInitializer类的父类实现了WebApplicationInitializer接口

  1. public interface WebApplicationInitializer {
  2.     void onStartup(ServletContext var1) throws ServletException;
  3. }

有些项目也使用如下方式设置,直接实现WebApplicationInitializer接口

  1.     @Override
  2.     public void onStartup(ServletContext servletContext) throws ServletException {
  3.         // 父容器配置
  4.         AnnotationConfigWebApplicationContext springCtx = new AnnotationConfigWebApplicationContext();
  5.         springCtx.register(SpringConfig.class);
  6.         // 通过监听器加载配置信息
  7.         servletContext.addListener(new ContextLoaderListener(springCtx));
  9.         // 子容器配置
  10.         AnnotationConfigWebApplicationContext mvcCtx = new AnnotationConfigWebApplicationContext();
  11.         mvcCtx.register(SpringMVCConfig.class);
  13.         ServletRegistration.Dynamic servlet = servletContext.addServlet(
  14.                 "DispatcherServlet",
  15.                 new DispatcherServlet(mvcCtx));
  16.         servlet.setLoadOnStartup(0);
  17.         servlet.addMapping("/");
  19.         // filter
  20.         FilterRegistration.Dynamic encodingFilter = servletContext.addFilter(
  21.                 "CharacterEncodingFilter",
  22.                 new CharacterEncodingFilter("UTF-8"));
  23.         encodingFilter.addMappingForUrlPatterns(null, false, "/*");
  24.     }

没有必要使用这种方式，不够清晰直观，并且不好记忆。

父容器的配置

  1. package com.lff.config;
  4. import com.alibaba.druid.pool.DruidDataSource;
  5. import org.mybatis.spring.SqlSessionFactoryBean;
  6. import org.mybatis.spring.annotation.MapperScan;
  7. import org.springframework.beans.factory.annotation.Value;
  8. import org.springframework.context.annotation.Bean;
  9. import org.springframework.context.annotation.ComponentScan;
  10. import org.springframework.context.annotation.PropertySource;
  11. import org.springframework.core.io.ClassPathResource;
  12. import org.springframework.core.io.support.PathMatchingResourcePatternResolver;
  13. import org.springframework.jdbc.datasource.DataSourceTransactionManager;
  14. import org.springframework.transaction.annotation.EnableTransactionManagement;
  16. import javax.sql.DataSource;
  18. @ComponentScan({"com.lff.service","com.lff.converter"})
  19. @MapperScan("com.lff.dao")
  20. @EnableTransactionManagement
  21. public class SpringConfig {
  23.     //配置数据源
  24.     @Bean
  25.     public DataSource dataSource() {
  26.         DruidDataSource ds = new DruidDataSource();
  27.         ds.setDriverClassName("com.mysql.jdbc.Driver");
  28.         ds.setUrl("jdbc:mysql://localhost:3306/customer_test");
  29.         ds.setUsername("root");
  30.         ds.setPassword("root");
  31.         return ds;
  32.     }
  34.     //配置核心Mybatis核心工厂
  35.     @Bean
  36.     public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource) throws Exception {
  37.         SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
  38.         bean.setDataSource(dataSource);
  39.         bean.setTypeAliasesPackage("com.lff.domain");//设置实体类别名
  40.         PathMatchingResourcePatternResolver resolver = new PathMatchingResourcePatternResolver();
  41. //        bean.setMapperLocations(resolver.getResources("classpath:/mappers/*.xml"));//配置Mapper映射文件的路径
  42. //        如果有mybatis-config配置文件可以在这里设置，指定配置文件的位置
  43. //        bean.setConfigLocation(new ClassPathResource("mybatis-config.xml"));
  45.         return bean;
  46.     }
  48.     //配置事务管理器,替换配置里面的DataSourceTransactionManager
  49.     @Bean
  50.     public DataSourceTransactionManager dataSourceTransactionManager(DataSource dataSource){
  51.         DataSourceTransactionManager dm = new DataSourceTransactionManager();
  52.         dm.setDataSource(dataSource);
  53.         return dm;
  54.     }
  55. }

子容器的配置

  1. package com.lff.config;
  3. import com.lff.converter.DateConverter;
  4. import com.lff.interceptor.MyInterceptor;
  5. import org.springframework.beans.factory.annotation.Autowired;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.ComponentScan;
  8. import org.springframework.format.FormatterRegistry;
  9. import org.springframework.http.converter.HttpMessageConverter;
  10. import org.springframework.http.converter.StringHttpMessageConverter;
  11. import org.springframework.http.converter.json.MappingJackson2HttpMessageConverter;
  12. import org.springframework.web.multipart.commons.CommonsMultipartResolver;
  13. import org.springframework.web.servlet.config.annotation.DefaultServletHandlerConfigurer;
  14. import org.springframework.web.servlet.config.annotation.EnableWebMvc;
  15. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  16. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  17. import org.springframework.web.servlet.view.InternalResourceViewResolver;
  19. import java.nio.charset.StandardCharsets;
  20. import java.util.List;
  22. //思路：如果想配置一个东西又不知道怎么配置可以查看该类的父类都可以配置哪些东西
  23. @ComponentScan({"com.lff.controller", "com.lff.interceptor"})
  24. @EnableWebMvc //一定要加这个注解，不要问为什么，否则不好使
  25. public class SpringMVCConfig implements WebMvcConfigurer {
  27.     @Autowired
  28.     private MyInterceptor myInterceptor;
  29.     @Autowired
  30.     private DateConverter dateConverter;
  32. //    可以在这里设置路径前缀、后缀
  33.     @Bean
  34.     public InternalResourceViewResolver viewResolver() {
  35.         InternalResourceViewResolver resolver = new InternalResourceViewResolver();
  36.         resolver.setPrefix("/WEB-INF/page/");
  37.         resolver.setSuffix(".jsp");
  38.         return resolver;
  39.     }
  41. //    文件上传配置
  42.     @Bean
  43.     public CommonsMultipartResolver multipartResolver() {
  44.         CommonsMultipartResolver resolver = new CommonsMultipartResolver();
  45.         resolver.setDefaultEncoding("UTF-8");
  46.         return resolver;
  47.     }
  49. //    如果需要拦截器，在这里添加拦截器配置
  50.     @Override
  51.     public void addInterceptors(InterceptorRegistry registry) {
  52.         registry.addInterceptor(myInterceptor)
  53.                 .addPathPatterns("/**")
  54.                 .excludePathPatterns("/asset/**");
  55.     }
  57.     //    如果需要转换器，在这里配置，比如日期格式转换等
  58.     @Override
  59.     public void addFormatters(FormatterRegistry registry) {
  60.         registry.addConverter(dateConverter);
  61.     }
  63.     /**
  64.      * 相当于<mvc:default-servlet-handler/>
  65.      * 用以处理静态资源
  66.      */
  67.     @Override
  68.     public void configureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) {
  69.         configurer.enable();
  70.     }
  72. //    用于处理字符编码乱码问题
  73.     @Override
  74.     public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
  75.         // 设置返回的普通字符串的编码
  76.         StringHttpMessageConverter stringConverter = new StringHttpMessageConverter();
  77.         stringConverter.setDefaultCharset(StandardCharsets.UTF_8);
  78.         converters.add(stringConverter);
  80.         // 设置返回的JSON数据的编码
  81.         MappingJackson2HttpMessageConverter jsonConverter = new MappingJackson2HttpMessageConverter();
  82.         jsonConverter.setDefaultCharset(StandardCharsets.UTF_8);
  83.         converters.add(jsonConverter);
  84.     }
  85. }

上面如果不使用拦截器和转换器可以去掉，根据情况在配置文件里面添加内容。
当配置一项的时候，要想清楚是属于Service层的东西还是属于Controller层的东西，Service层的东西就在父容器里面配置，Controller层的东西就在子容器里面配置，如果都需要就配置在父容器里面。