前情回顾

到本文，我们已经学习了 SSM 框架中的 MyBatis 和 Spring 两大核心内容，本文介绍如何将两者结合起来在项目中使用，这也是实际开发中常用的操作，必须掌握，下面开始撸码~

集成步骤

第一步：创建数据库、数据表

数据库各位跟随自己爱好建就行，数据表我这里是 programmer，字段有这几个：

  • id 主键，varchar(64)、自动增长、不为null
  • name 姓名，varchar(125)
  • age 年龄，int

第二步：新建项目，完成基本配置

新建基于 maven 的 Java项目，完成如下配置：

pom.xml 文件中主要是依赖：

  1. <?xml version="1.0" encoding="UTF-8"?>
  3. <project xmlns="http://maven.apache.org/POM/4.0.0" 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.javafirst</groupId>
  8.     <artifactId>spring-mybatis</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <properties>
  12.         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
  13.         <maven.compiler.source>1.8</maven.compiler.source>
  14.         <maven.compiler.target>1.8</maven.compiler.target>
  15.     </properties>
  17.     <dependencies>
  18.         <dependency>
  19.             <groupId>junit</groupId>
  20.             <artifactId>junit</artifactId>
  21.             <version>4.11</version>
  22.         </dependency>
  24.         <!-- MySQL驱动-->
  25.         <dependency>
  26.             <groupId>mysql</groupId>
  27.             <artifactId>mysql-connector-java</artifactId>
  28.             <version>8.0.25</version>
  29.         </dependency>
  31.         <!--MyBatis依赖-->
  32.         <dependency>
  33.             <groupId>org.mybatis</groupId>
  34.             <artifactId>mybatis</artifactId>
  35.             <version>3.5.7</version>
  36.         </dependency>
  38.         <!--    Spring依赖    -->
  39.         <dependency>
  40.             <groupId>org.springframework</groupId>
  41.             <artifactId>spring-context</artifactId>
  42.             <version>5.3.14</version>
  43.         </dependency>
  45.         <!--    MyBatis集成Spring    -->
  46.         <dependency>
  47.             <groupId>org.mybatis</groupId>
  48.             <artifactId>mybatis-spring</artifactId>
  49.             <version>1.3.3</version>
  50.         </dependency>
  52.         <!-- Spring事务-->
  53.         <dependency>
  54.             <groupId>org.springframework</groupId>
  55.             <artifactId>spring-tx</artifactId>
  56.             <version>5.3.14</version>
  57.         </dependency>
  58.         <dependency>
  59.             <groupId>org.springframework</groupId>
  60.             <artifactId>spring-jdbc</artifactId>
  61.             <version>1.2.6</version>
  62.         </dependency>
  64.         <!--     阿里数据库连接池 druid  -->
  65.         <dependency>
  66.             <groupId>com.alibaba</groupId>
  67.             <artifactId>druid</artifactId>
  68.             <version>1.2.8</version>
  69.         </dependency>
  70.     </dependencies>
  72.     <build>
  73.         <resources>
  74.             <resource>
  75.                 <directory>src/main/java</directory>
  76.                 <includes>
  77.                     <include>**/*.properties</include>
  78.                     <include>**/*.xml</include>
  79.                 </includes>
  80.                 <filtering>false</filtering>
  81.             </resource>
  82.         </resources>
  83.     </build>
  84. </project>

以上配置基本是固定的，用到什么依赖就在这里配置即可。

第三步：创建实体类

这个和我们之前学习过，就是创建和表中字段对应Java实体类对象，代码如下：

  1. package com.javafirst.daomain;
  3. /**
  4.  * desc: 数据表 对应的 实体类
  5.  * <p>
  6.  * author: 推荐学java
  7.  * <p>
  8.  * weChat: studyingJava
  9.  */
  10. public class Programmer {
  12.     private Integer id;
  13.     private String name;
  14.     private Integer age;
  16.     public Integer getId() {
  17.         return id;
  18.     }
  20.     public void setId(Integer id) {
  21.         this.id = id;
  22.     }
  24.     public String getName() {
  25.         return name;
  26.     }
  28.     public void setName(String name) {
  29.         this.name = name;
  30.     }
  32.     public Integer getAge() {
  33.         return age;
  34.     }
  36.     public void setAge(Integer age) {
  37.         this.age = age;
  38.     }
  40.     @Override
  41.     public String toString() {
  42.         return "Programmer信息：{" +
  43.                 "id=" + id +
  44.                 ", name='" + name + '\'' +
  45.                 ", age=" + age +
  46.                 '}';
  47.     }
  48. }

第四步：创建dao接口和mapper文件

这一步其实还属于 MyBatis 的配置，需要注意的是我这里将接口和对应的 mapper 文件没有放在同一个目录（package）下，这里不同会引起MyBatis 配置文件中给JavaBean对象起别名的配置有区别，看个人习惯，我习惯将class和xml分开。

ProgrammerDao.java 代码如下：

  1. /**
  2.  * desc: MyBatis 对应的 dao 层,操作SQL使用
  3.  * <p>
  4.  * author: 推荐学java
  5.  * <p>
  6.  * weChat: studyingJava
  7.  */
  8. public interface ProgrammerDao {
  10.     int addProgrammer(Programmer programmer);
  12.     List<Programmer> selectAllProgrammer();
  14. }

这个应该不陌生，使我们学习 MyBatis 的时候用到的，这里定义的接口，实际会映射到去执行 Mapper 中的 SQL 语句。

ProgrammerMapper.xml 代码如下：

  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.javafirst.dao.ProgrammerDao">
  8.     <insert id="addProgrammer">
  9.         insert into programmer(`name`,age) values (#{name},#{age})
  10.     </insert>
  12.     <select id="selectAllProgrammer" resultType="com.javafirst.daomain.Programmer">
  13.         select * from programmer
  14.     </select>
  16. </mapper>

该类在 resource 目录下的 mapper 文件夹下。

第五步：完成MyBatis主配置文件

这个文件的位置在 resource 目录下，名为 mybatis-config.xml ，其代码如下：

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE configuration
  3.         PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  5. <configuration>
  7.     <!--  日志  -->
  8.     <settings>
  9.         <setting name="logImpl" value="STDOUT_LOGGING"/>
  10.     </settings>
  12.     <typeAliases>
  13.         <typeAlias type="com.javafirst.daomain.Programmer" alias="programmerDao"/>
  15.         <!--    要求 dao接口和mapper文件在同一文件夹下    -->
  16.         <!--        <package name="com.javafirst.daomain"/>-->
  17.     </typeAliases>
  19.     <mappers>
  20.         <mapper resource="mapper/ProgrammerMapper.xml"/>
  21.     </mappers>
  22. </configuration>

第四步中提到的不同之处就在这里的 <typeAliases> 标签里面的内容了，各位看注释或者看往期文章就明白了。

接下来的操作就和 Spring 相关了，可能细心的同学已经有疑惑了，我们的数据源去哪了，也就是连接数据库的配置去哪了？能想到这一点，说明我们对学过的内容记忆的很好，其实，MyBatis 和 Spring 结合使用的时候，数据源是交给 Spring容器来处理的，相对我们单独使用 MyBatis 更简单轻松了，快往下看：

第六步：创建 Service 接口和实现类

定义 ProgrammerService 接口代码如下：

  1. public interface ProgrammerService {
  3.     int insertProgrammer(Programmer programmer);
  5.     List<Programmer> queryProgrammers();
  6. }

这步操作其实就是我们学习 Spring 的流程，会动态创建 Java 对象，然后通过相关设置方式来赋值。

实现类代码：

  1. /**
  2.  * desc:
  3.  * author: 推荐学java
  4.  * <p>
  5.  * weChat: studyingJava
  6.  */
  7. public class ProgrammerServiceImpl implements ProgrammerService {
  9.     private ProgrammerDao programmerDao;
  11.     public void setProgrammerDao(ProgrammerDao programmerDao) {
  12.         this.programmerDao = programmerDao;
  13.     }
  15.     @Override
  16.     public int insertProgrammer(Programmer programmer) {
  17.         return programmerDao.addProgrammer(programmer);
  18.     }
  20.     @Override
  21.     public List<Programmer> queryProgrammers() {
  23.         return programmerDao.selectAllProgrammer();
  24.     }
  26. }

这里可以理解为代理对象的作用。

第七步：创建 Spring 的配置文件

这个应该很熟悉了，名为 applicationContext.xml 在 resource 目录下，不同前面我们使用的是，这里的内容有所变化：

  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.     <!--  使用属性文件 配置数据源中数据库链接信息  -->
  8.     <context:property-placeholder location="jdbc.properties"/>
  10.     <!-- 声明数据源-->
  11.     <bean id="myDataSource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
  12.         <!--        <property name="driver" value="com.mysql.jdbc.Driver"/>-->
  13.         <property name="url" value="${jdbc.url}"/>
  14.         <property name="username" value="${jdbc.username}"/>
  15.         <property name="password" value="${jdbc.password}"/>
  16.     </bean>
  18.     <!--  声明 SQLSessionFactoryBean  -->
  19.     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
  20.         <property name="dataSource" ref="myDataSource"/>
  21.         <property name="configLocation" value="classpath:mybatis-config.xml"/>
  22.     </bean>
  24.     <!--  声明 MapperScannerConfigurer  -->
  25.     <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
  26.         <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
  28.         <!--指定包名，包名是dao接口所在的包名
  29.             MapperScannerConfigurer 会扫描 basePackage 给定包中的所有接口，把每个接口都执行
  30.             一次getMapper()方法，得到每个接口的dao对象
  31.             创建好的dao对象放入到spring的容器中
  33.             dao默认对象的名称：是接口名字的首字母小写
  34.         -->
  36.         <property name="basePackage" value="com.javafirst.dao"/>
  37.         <!--    多个包下有实体,使用,分割    -->
  38.         <!--        <property name="basePackage" value="com.javafirst.dao,com.javafirst.dao2"/>-->
  39.     </bean>
  41.     <!--  注册自定义Service  -->
  42.     <bean id="programmerService" class="com.javafirst.service.impl.ProgrammerServiceImpl">
  43.         <property name="programmerDao" ref="programmerDao"/>
  44.     </bean>
  45. </beans>

这里其实主要有四小步工作，且这四步基本都是固定模式，我们在理解的基础上把流程记下来就行，后面用就知道为什么这么写了。

为了方便，我这里将数据库相关的配置信息放在了外部文件 jdbc.properties 中，这和我们前面学习 MyBatis 的时候引用外部配置文件是一样的用法，该文件在 resource 目录下，Spring配置文件中引用就是这里的第一句代码。

jdbc.properties 文件内容如下：

  1. jdbc.url=jdbc:mysql://localhost:3306/spring_demo
  2. jdbc.username=root
  3. jdbc.password=root

下面说这四小步都代表什么意思：

  • 声明数据源 ：其实就是和数据库建立链接，这个过程交给了 Spring容器来管理
  • 声明 SQLSessionFactoryBean ：这个工作的意思就是读取 MyBatis 主配置文件，讲声明的 javaBean 对象映射到 SqlSessionFactoryBean 管理器中。
  • 声明 MapperScannerConfigurer ：会扫描给定包下的接口对象，将所有接口执行一次 getMapper() 后得到接口的 dao 对象，将这些对象交给 Spring容器管理。
  • 注册自定义Service ：这是我们自定义的东西，也就是我们自己的业务层。

第八步：测试

到这里其实有两种测试可以进行，一种是测试Dao层是否能访问数据库，并进行相关操作，不经过我们的业务层。

  1. @Test
  2. public void test_addProgrammer() {
  3.     String config = "applicationContext.xml";
  4.     ApplicationContext context = new ClassPathXmlApplicationContext(config);
  6.     ProgrammerDao programmerDao = (ProgrammerDao) context.getBean("programmerDao");
  8.     Programmer programmer = new Programmer();
  9.     programmer.setName("王重阳");
  10.     programmer.setAge(102);
  12.     programmerDao.addProgrammer(programmer);
  13. }

这一步测试不需要我们前面配置中的自定义Service 即可进行。需要注意的是Spring中添加记录，已经不需要我们手动commit() 了。

第二种测试，就是我们 Spring 和 MyBatis 集成后的测试，代码如下：

  1. @Test
  2. public void test_addProgrammer_spring() {
  3.     String config = "applicationContext.xml";
  4.     ApplicationContext context = new ClassPathXmlApplicationContext(config);
  6.     ProgrammerService programmerService = (ProgrammerService) context.getBean("programmerService");
  8.     Programmer programmer = new Programmer();
  9.     programmer.setName("周伯通");
  10.     programmer.setAge(112);
  12.     int row = programmerService.insertProgrammer(programmer);
  13.     System.out.println("插入结果：" + row);
  14. }

结果大家自行验证，看下数据表中这里插入的值：

推荐学java——Spring集成MyBatis - 图1

我们还定义了一个查询功能，测试代码如下：

  1. /**
  2.  * Spring方式 查询记录
  3.  */
  4. @Test
  5. public void test_selectProgrammers_spring() {
  6.     String config = "applicationContext.xml";
  7.     ApplicationContext context = new ClassPathXmlApplicationContext(config);
  9.     ProgrammerService programmerService = (ProgrammerService) context.getBean("programmerService");
  11.     List<Programmer> programmers = programmerService.queryProgrammers();
  13.     System.out.println("查询结果：" + programmers);
  14. }

结果各位自己验证哈，一般前面流程跑通，到这里不会有问题。

最后，再看下我的项目结构：

推荐学java——Spring集成MyBatis - 图2

总结

本文将前面学习的 MyBatis 和 Spring 结合起来使用，掌握其流程和原理很重要，其实思考一下，结合起来反倒简单多了，可能第一次接触的时候，被各种流程性的东西搞的有点懵，但这并不妨碍我们后面的顺利上手。

学编程，推荐首选Java语言，小编创建了一个专注Java的原创公众号推荐学java，各位可以在微信搜索javaFirst 关注，一起开启Java旅途！