Spring、SpringMVC、MyBatis三大框架整合(超详细讲解)

我们都知道SSM框架是Java中使用非常多的框架，虽然现在流行SpringBoot框架。但是SSM框架依旧有公司在用，这篇博客也是为了刚刚学习SSM框架的Java开发者后期整合做准备，也是我回顾SSM框架整合流程的一个总结。

SSM整合就是将Spring与Mybatis整合，SM需要中间件充当整合的桥梁。Spring与SpringMVC整合，SS整合不需要中间件。
在Java中，中间件就是一堆具有某个功能的jar包，因为Java都是类class，而jar包又是类的集合。

这里使用Maven来创建Web工程，这样方便我们管理项目中所需要的依赖。那么接下来我们就开始整合SSM框架。

SSM整合所需要的依赖

我们先引入日志依赖，因为每个项目都需要日志来记录项目中的任何事情。不管是开发中在控制台打印日志，还是上线后将日志输出到文件中
这里日志类库我们采用sl4j + log4j2，所需的依赖如下：

<dependency>
  <groupId>org.apache.logging.log4jgroupId>
  <artifactId>log4j-slf4j-implartifactId>
  <version>2.7version>
dependency>
<dependency>
  <groupId>org.apache.logging.log4jgroupId>
  <artifactId>log4j-webartifactId>
  <version>2.7version>
dependency>

接下来我们引入数据库相关的依赖：mysql驱动包，Druid数据库连接池，mybatis框架包，spring整合mybatis的桥梁jar包

<dependency>
    <groupId>mysqlgroupId>
    <artifactId>mysql-connector-javaartifactId>
    <version>5.1.47version>
    <scope>runtimescope>
dependency>

<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>druidartifactId>
    <version>1.1.20version>
dependency>

<dependency>
    <groupId>org.mybatisgroupId>
    <artifactId>mybatisartifactId>
    <version>3.5.2version>
dependency>

<dependency>
    <groupId>org.mybatisgroupId>
    <artifactId>mybatis-springartifactId>
    <version>2.0.2version>
dependency>

然后我们引入spring框架的依赖

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-webmvcartifactId>
    <version>5.1.10.RELEASEversion>
dependency>

哎，spring框架不是有很多jar包吗，这里为啥只引入一个，我们通过下面一张图来解释…

我们知道Maven的一个作用就是依赖管理，引入一个依赖就会把它所依赖的jar包也引进来，所以我们无需把spring的每个依赖都引一遍。
上面我们看到AOP的依赖也引入进来，但是要使用AOP技术，还是要其他jar包的支持

<!--spring AOP和aspectj框架整合的模块-->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.1.10.RELEASE</version>
</dependency>

接下来引入spring jdbc和事务相关的依赖

<dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-jdbcartifactId>
    <version>5.1.10.RELEASEversion>
dependency>

然后我们再引入javaweb相关依赖

<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>3.1.0</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet.jsp</groupId>
    <artifactId>jsp-api</artifactId>
    <version>2.2</version>
    <scope>provided</scope>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>jstl</artifactId>
    <version>1.2</version>
</dependency>

最后我们把springmvc默认解析json的jar包和文件上传的jar包引进来

<!-- spring-json依赖 -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.8</version>
</dependency>
<!--文件上传-->
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.3</version>
</dependency>

这样我们就把ssm整合基本需要的jar包都引进来了，整合时只需要把上面的jar包归总即可。
我也看过其他ssm整合的博客，都是把spring全部的依赖都加进来，虽然不影响功能的实现。毕竟我们使用了Maven管理项目，所以尽可能的理清每个依赖所关联的依赖，而不是把全部的spring依赖都加进来。

依赖搞定了，接下来我们就开始配置文件的编写，不得不说ssm最大弊病就是配置文件太多，写错一点配置就可能查找半天原因。这也是为什么springboot这么火的原因–零XML配置等其他特性。

log4j2.xml

上面引入的日志类库需要配置文件的支持才能生效

<configuration>
    
    <appenders>
        
        <console name="Console" target="SYSTEM_OUT">
            
            
            <patternlayout pattern="[%p] %m %n"/>
        console>
    appenders>
    
    
    <loggers>
        <root level="DEBUG">
            
            <appender-ref ref="Console"/>
        root>
        
    loggers>
configuration>

db.properties

我们把数据源的相关配置单独放在一个文件中

jdbc.username=root
jdbc.password=root用户的密码
jdbc.url=jdbc:mysql://127.0.0.1:3306/ssm?useSSL=false&serverTimezone=Asia/Shanghai
jdbc.driverClassName=com.mysql.jdbc.Driver
#初始化连接数大小
jdbc.initialSize=5

applicationContext.xml

这是spring的核心配置文件，把数据源，sqlSessionFactory交给了spring IOC容器管理，以及开启了注解式事务。

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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">

    
    <context:component-scan base-package="cn.zwq.ssm.service"/>

    
    <context:property-placeholder location="classpath:application.properties"/>

    
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="initialSize" value="${jdbc.initialSize}"/>
    bean>

    
    <bean name="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        
        <property name="dataSource" ref="dataSource"/>
        
        <property name="mapperLocations" value="classpath:mapper/*/*Mapper.xml"/>
    bean>

    
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        
        <property name="basePackage" value="cn.zwq.ssm.mapper"/>
        
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
    bean>

    
    <bean name="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        
        <property name="dataSource" ref="dataSource"/>
    bean>

    
    <tx:annotation-driven transaction-manager="txManager"/>
beans>

springmvc.xml

这是springmvc的配置文件，配置了视图解析器，文件上传，以及开放所有的静态资源

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context.xsd
		http://www.springframework.org/schema/mvc
		http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    
    <context:component-scan base-package="cn.zwq.ssm.controller"/>

    
    <mvc:annotation-driven/>

    
    <mvc:default-servlet-handler/>

    
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <property name="suffix" value=".jsp"/>
    bean>

    
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        
        <property name="maxUploadSize" value="209715200" />
        
        <property name="maxUploadSizePerFile" value="2019152"/>
        
        <property name="defaultEncoding" value="UTF-8" />
        
        <property name="resolveLazily" value="true" />
    bean>

beans>

web.xml

在web.xml中配置了初始化spring容器的监听器，以及前端控制器和编码过滤器

<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">

    
    <context-param>
        <param-name>contextConfigLocationparam-name>
        <param-value>classpath:applicationContext.xmlparam-value>
    context-param>
    
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
    listener>

    
    <servlet>
        <servlet-name>dispatcherServletservlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
        <init-param>
            <param-name>contextConfigLocationparam-name>
            <param-value>classpath:springmvc.xmlparam-value>
        init-param>
    servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServletservlet-name>
        <url-pattern>/url-pattern>
    servlet-mapping>

    
    <filter>
        <filter-name>characterEncodingFilterfilter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
        <init-param>
            <param-name>encodingparam-name>
            <param-value>UTF-8param-value>
        init-param>
        <init-param>
            <param-name>forceEncodingparam-name>
            <param-value>trueparam-value>
        init-param>
    filter>
    <filter-mapping>
        <filter-name>characterEncodingFilterfilter-name>
        <url-pattern>/*url-pattern>
    filter-mapping>
web-app>

这样ssm整合的基本配置已经完成了，接下来我们对用户表进行增删改查，来验证我们ssm整合是否正确可行。
我们上面在配置数据源的时候，指定连接到ssm数据库，所有我们先创建ssm数据库，再在其中创建用户表。

用户表语句

我们通过下面sql语句创建用户表并插入6条记录

create database if no exist `ssm`;
use `ssm`;
CREATE TABLE `users` (
  `uid` int(10) NOT NULL AUTO_INCREMENT COMMENT '用户id',
  `uname` varchar(255) DEFAULT NULL COMMENT '用户姓名',
  `pwd` varchar(255) DEFAULT NULL COMMENT '用户密码',
  `sex` int(1) DEFAULT NULL COMMENT '用户性别，1：男，0：女',
  `age` int(3) DEFAULT NULL COMMENT '用户年龄',
  PRIMARY KEY (`uid`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

INSERT INTO users VALUES(1,"张三","zs",1,21);
INSERT INTO users VALUES(2,"李四","ls",0,18);
INSERT INTO users VALUES(3,"王五","ww",0,20);
INSERT INTO users VALUES(4,"赵六","zl",1,26);
INSERT INTO users VALUES(5,"十七","sq",0,22);
INSERT INTO users VALUES(6,"阿什","as",1,25);

用户实体类

在类上面我们使用Lombok的@Data注解帮我们简化代码，该注解会自动生成getter、setter、toString等方法

@Data
public class User {
    private Integer uid;
    private String uname;
    private String pwd;
    private Integer sex;
    private Integer age;
}

UserMapper

这是操作用户表数据的持久化接口，使用注解的方式实现，

public interface UserMapper  {
    
    //查询全部用户
    @Select("select * from users")
    List<User> selectAll();

    //根据id查询用户
    @Select("select *  from users where uid = #{uid}")
    User selectByPrimaryKey(Integer uid);
    
    //根据id修改用户
    void updateByPrimaryKeySelective(User user);
    
    //保存用户
    void insertSelective(User user);
    
    //根据id删除用户
    @Delete("delete from users where uid = #{uid}")
    void deleteByPrimaryKey(Integer uid);
}

UserService与UserServiceImpl

UserService

public interface UserService {
    /*查询所有用户*/
    List<User> queryAllUser();

    /*根据用户id查询用户*/
    User queryUserByUid(Integer uid);

    /*根据用户id修改用户信息*/
    void updateUserByUid(User user);

    /*添加用户*/
    void addUser(User user);

    /*根据用户id删除用户*/
    void deleteUserByUids(Integer[] uids);
}

UserServiceImpl
我们在类上加入@Transactional表明启动注解式事务

@Service
@Transactional
public class UserServiceImpl implements UserService {

    @Autowired
    private UserMapper userMapper;

    @Override
    public List<User> queryAllUser() {
        return userMapper.selectAll();
    }

    @Override
    public User queryUserByUid(Integer uid) {
        return userMapper.selectByPrimaryKey(uid);
    }

    @Override
    public void updateUserByUid(User user) {
        userMapper.updateByPrimaryKeySelective(user);
    }

    @Override
    public void addUser(User user) {
        userMapper.insertSelective(user);
    }

    /*根据用户id删除用户*/
    @Override
    public void deleteUserByUids(Integer[] uids) {
        /*Stream流+方法引用+lambda表达式简化删除代码*/
        Stream.of(uids).forEach(userMapper::deleteByPrimaryKey);
    }
}

UserController

我们知道在类上加入@Controller注解表示该类是控制器，用来接收并响应客户端的请求。
而@RestController是由@Controller和@ResponseBody组成，表示该类中的所有方法都是返回Json数据。

@RestController
@RequestMapping("/user")
public class UserController {

    @Autowired
    private UserService userService;

    /*查询所有用户*/
    @RequestMapping("/queryAllUser")
    public List<User> queryAllUser() {
        return userService.queryAllUser();
    }

    /*根据用户id查询用户*/
    @RequestMapping("/queryUserByUid/{uid}")
    public User queryUserByUid(@PathVariable("uid") Integer uid) {
        return userService.queryUserByUid(uid);
    }

    /*根据用户id修改用户信息*/
    @RequestMapping("/updateUserByUid")
    public boolean updateUserByUid(User user) {
        try {
            userService.updateUserByUid(user);
            return true;
        }catch (Exception e){
            return false;
        }
    }

    /*添加用户*/
    @RequestMapping("/addUser")
    public Boolean addUser(User user) {
        try {
            userService.addUser(user);
            return true;
        }catch (Exception e){
            return false;
        }
    }

    /*根据用户id删除用户*/
    @RequestMapping("/deleteUserByUids")
    public Boolean deleteUserByUids(Integer[] uids) {
        try {
            userService.deleteUserByUids(uids);
            return true;
        }catch (Exception e){
            return false;
        }
    }
}

我们使用postman工具来测试我们上面方法的效果。Postman工具是专门用来向服务器发起请求，然后得到最原始的响应数据。

我们先测试查询全部用户的接口：http://localhost:8080/ssm/user/queryAllUser

剩下的几个方法也测试过，是的。这样我们就把ssm整合完毕，并且通过对用户模块的操作验证了是可行的，以后需要使用ssm框架的时候，也可以拿这个来当ssm框架的基本骨架。
这次整合ssm框架的源码