Spring整合MyBatis详细教程

1. 为什么需要Spring？Spring可以带来哪些变化？

将对象创建这个过程交给Spring（IOC），不再需要硬编码在程序中，配置xml文件或注解即可；另外Spirng还提供了数据库的事务管理、日志等功能（AOP）。最直观的变化就是：可以不再使用MyBatis配置文件以及不用再手动new SqlSessionFactory、SqlSession等对象

2. 回顾MyBatis

首先来回顾在MyBatis中如何操作数据库。以操作的数据库名为mybatis，表名employee为例，employee表中拥有字段id、lastName、gender、email

2.1 创建表对应的POJO(Bean)

package com.domain;
public class Employee {
    private Integer id;
    private String lastName;
    private String gender;
    private String email;
    public Employee() {
    }
    public Employee(Integer id, String lastName, String gender, String email) {
        this.id = id;
        this.lastName = lastName;
        this.gender = gender;
        this.email = email;
    }
    ......get set方法省略

2.2 创建接口DAO

package com.dao;
public interface EmployeeDao {
	//以通过id查employee为例
    public Employee getEmployeeById(Integer id);
}

2.3 创建DAO的映射文件

EmployeeMapper.xml:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dao.EmployeeDao">
    <select id="getEmployeeById" resultType="com.domain.Employee">
        select * from Employee where id=#{id}
    </select>
</mapper>

2.4 编写Service层

EmployeeService接口：

package com.service;
import com.domain.Employee;
public interface EmployeeService {
    Employee getEmployeeById(Integer id);
}

EmployeeServiceImpl实现类：

public class EmployeeServiceImpl implements EmployeeService {
    static InputStream inputStream=null;
    static {
        String resource = "config.xml";
        try {
            inputStream = Resources.getResourceAsStream(resource);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
   	//1.读取全局xml配置文件，创建SqlSessionFactory对象
    private final SqlSessionFactory sqlSessionFactory=new SqlSessionFactoryBuilder().build(inputStream);
    
    @Override
    public Employee getEmployeeById(Integer id) {
    	//2.通过创建SqlSessionFactory对象获取SqlSession对象
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //3.通过SqlSession对象获取代理对象mapper，传入接口class对象,
        EmployeeDao mapper = sqlSession.getMapper(EmployeeDao.class);
        //4.通过mapper调用接口对应方法
        return  mapper.queryEmployeeById(id);
    }

2.5创建MyBatis配置文件

config.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <!--配置数据源-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!--配置映射文件-->
    <mappers>
        <mapper resource="EmployeeMapper.xml"/>
    </mappers>
</configuration>

2.6 开始测试

@Test
public void testImpl()
{
    EmployeeService employeeService=new EmployeeServiceImpl();
    Employee employeeById = employeeService.getEmployeeById(6);
    System.out.println(employeeById);
}

至此就完成了通过MyBatis访问数据库的一系列操作，在这里我们主要关注2.4与2.5中的操作，联系后面的讲解，将会深入体会到引入Spring后带来哪些便捷。另外根据上面的代码，我们将MyBatis运行时需要创建的对象抽离出一张流程图，如下

---

3.将MyBatis与Spring整合

在完成前面2.1(POJO)、2.2(DAO接口)、2.3(mapper映射文件)三个步骤的基础之上：

3.1 使用Maven导入相关依赖

<dependencies>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.6</version>
    </dependency>

    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>8.0.25</version>
    </dependency>
    
<!--直接导入spring-mvc这个包，会自动导入相关依赖的包，省下导入其他包的功夫-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>5.3.9</version>
    </dependency>
    
<!--mybatis-spring包是适配包，帮助你在Spring中使用MyBatis-->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.2</version>
    </dependency>
</dependencies>

3.2 编写Spring管理MyBatis的xml（核心）

<?xml version="1.0" encoding="UTF-8"?>
<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"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        https://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd">
    <context:annotation-config/>
    
    ！！使用Spring配置dataSource 相当于MyBatis配置文件的<environments>！！
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://localhost:3306/book"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>
    
     ！！配置SqlSessionFactoryBean 等同于SqlSessionFactory 做读取数据源以及注册mapper.xml的工作
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>引用上面的dataSource
        <property name="mapperLocations" value="classpath:EmployeeMapper.xml"/>
    </bean>
    ！！获得Mapper代理对象 等同于getMapper()
    <bean id="employeeMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
        <property name="mapperInterface" value="com.lin.mapper.EmployeeMapper" />
        <property name="sqlSessionFactory" ref="sqlSessionFactory" />
    </bean>
    ！！注册employeeServiceImpl
    <bean id="employeeServiceImpl" class="com.lin.service.EmployeeServiceImpl"/>

</beans>

3.3 重新编写Service层

package com.lin.service;
import com.lin.mapper.EmployeeMapper;
import com.lin.pojo.Employee;
import org.springframework.beans.factory.annotation.Autowired;
public class EmployeeServiceImpl implements EmployeeService {
    private EmployeeMapper employeeMapper;
    
    @Autowired //构造器注入 注入的就是id="employeeMapper"这个bean
    public EmployeeServiceImpl(EmployeeMapper employeeMapper) {
        this.employeeMapper = employeeMapper;
    }
    
    @Override
    public Employee getEmployeeById(Integer id) {
        return employeeMapper.queryEmployeeById(id);
    }
}

3.4 测试

@Test
public void testImpl()
{
	ApplicationContext context=new ClassPathXmlApplicationContext("Spring-mapper.xml");
    EmployeeService employeeServiceImpl = context.getBean("employeeServiceImpl", EmployeeService.class);
    Employee employee = employeeServiceImpl.getEmployeeById(6);
    System.out.println(employee);
}

4. 总结

其实在Spring中使用MyBatis的原理是一样的，只不过Spring将其封装了，并且以bean的方式注入，从而省去了创建对象的过程，使得代码更加整洁，更易维护。通过对比Spring-mybatis源码，可以总结出下图