Spring Boot系列MyBatis配置详解

PS:你的状态取决于你的心态,要想不再焦虑,先把生活节奏规律起来。

前面几篇文章尝试了接口开发、Thymeleaf 模板、常用语法、模板布局、项目国际化、JDBC 等,阅读本文之前可以阅读前面几篇文章:

  • 开发一个接口
  • Thymeleaf模板入门
  • Thymeleaf常用语法
  • Thymeleaf模板布局
  • 项目国际化
  • JDBC操作数据库

MyBatis 是一款优秀的持久层框架,MyBatis 使用 XML 或者注解来进行配置和映射,可以方便的将 POJO 映射成数据库中的记录。

  1. MyBatis工作流程
  2. 依赖及配置
  3. @Mapper和@MapperScan
  4. 实体类
  5. Mapper配置文件
  6. Mapper接口
  7. Mapper映射文件
  8. collection标签的使用
  9. 多数据源配置
  10. 测试结果
  11. MyBatis使用注解配置

MyBatis工作流程

MyBatis 工作流程如下图所示:

Spring Boot系列MyBatis配置详解_第1张图片

  1. 读取 mybatis-config.xml 配置文件;
  2. 加载 Mapper 映射文件或对应注解内容,里面定义了相应的 SQL 语句;
  3. 根据配置信息创建会话工厂 SqlSessionFactory
  4. 根据会话工厂创建 SqlSession,里面包含了执行 SQL 需要的所有方法;
  5. 创建 Executor 执行器,用来执行 SQL 语句,在创建会话工厂 SqlSessionFactory 的时候就会创建一个 Executor,其默认执行器类型是 ExecutorType.SIMPLE
  6. MappedStatement 对象,该对象是 Executor 执行器方法中的参数,主要是对 Mapper XML 文件中映射信息的封装;
  7. 输入参数映射;
  8. 输出参数映射。

依赖及配置

创建 Spring Boot 项目,在其 build.gradle 文件中添加 MyBatis 和 MySQL 驱动的依赖如下:

dependencies {
    // ...
    // myBaits
    // http://mybatis.org/spring-boot-starter/mybatis-spring-boot-autoconfigure/index.html
    implementation 'org.mybatis.spring.boot:mybatis-spring-boot-starter:2.1.1'
    // mysql驱动
    runtime("mysql:mysql-connector-java")
    // ...
}

然后在项目的 application.properties 文件中配置数据库连接参数以及 MyBatis 相关配置,如下:

# 数据库用户名
spring.datasource.username=root
# 数据库密码
spring.datasource.password=admin
# JDBC Driver
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
# JDBC URL
spring.datasource.url=jdbc:mysql://localhost:3306/db_student?serverTimezone=Asia/Shanghai
#spring.datasource.url=jdbc:mysql://localhost:3306/db_student?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8&useSSL=true

# 是否执行MyBatis xml配置文件的状态检查, 只是检查状态,默认false
mybatis.check-config-location=true
# mybatis-config.xml文件的位置
mybatis.config-location=classpath:mybatis/mybatis-config.xml
# Mapper对应的xml路径
mybatis.mapper-locations=classpath:mybatis/mapper/*.xml
# 设置别名的路径,可避免写全限定类名
mybatis.type-aliases-package=com.manu.mybatisxml.model

MyBatis 主要配置的是配置文件 mybatis-config.xml 的路径、Mapper 对应的 XML 文件的路径。

@Mapper和@MapperScan

@Mapper 注解用来标记 Mapper 接口,其被标注的接口都会生成对应的动态代理类,如果有多个 Mapper 接口,则都需要用 @Mapper 注解来标注,使用方式如下:

@Mapper
public interface ClassMapper{
    ///
}

@MapperScan 在项目的入口类上进行标注,可以配置要扫描的接口所在的一个或多个包,也可以使用通配符 * 来进行配置,使用方式如下:

@SpringBootApplication
// 扫描指定包中的接口
@MapperScan("com.manu.mybatisxml.mapper")
// @MapperScan("com.manu.mybatisxml.*.mapper")
// @MapperScan({"pack1","pack2"})
public class SpringBootMybatisXmlApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringBootMybatisXmlApplication.class, args);
    }
}

实体类

案例是班级和学生的关系,也就是一对多的关系,定义班级类 Class 如下:

/**
 * 班级类
 */
public class Class {
    private String classId;
    private String name;
    private List<Student> students;
    public Class() {
    }
    public Class(String classId, String name) {
        this.classId = classId;
        this.name = name;
    }
    // ...
    // setter、getter、toString
}

定义学生类 Student 类如下:

/**
 * 学生类
 */
public class Student {
    private String classId;
    private String sno;
    private String name;
    private String grade;
    public Student() {
    }
    public Student(String classId, String sno, String name, String grade) {
        this.classId = classId;
        this.sno = sno;
        this.name = name;
        this.grade = grade;
    }
    // ...
    // setter、getter、toString
}

MyBatis配置文件

MyBatis 的配置文件是 mybatis-config.xml 文件,当在 Spring Boot 中使用 MyBatis 时,该配置文件中的大多数配置都可以在 application.properties 文件中配置,所以在 Spring Boot 项目中可以借助该配置文件简化全限定类名,如下:


<configuration>
    <typeAliases>
        
        <typeAlias alias="Integer" type="java.lang.Integer" />
        <typeAlias alias="Long" type="java.lang.Long" />
        <typeAlias alias="HashMap" type="java.util.HashMap" />
        <typeAlias alias="LinkedHashMap" type="java.util.LinkedHashMap" />
        <typeAlias alias="ArrayList" type="java.util.ArrayList" />
        <typeAlias alias="LinkedList" type="java.util.LinkedList" />
        <typeAlias alias="Student" type="com.manu.mybatisxml.model.Student" />
        <typeAlias alias="Class" type="com.manu.mybatisxml.model.Class" />
    typeAliases>
configuration>

Mapper接口

Mapper 接口中中方法名对应 Mapper 映射文件中对应的 SQL 语句对应的方法,且方法名必须与对应的 SQL 语句中的 id 属性子相同,ClassMapper 如下:

/**
 * ClassMapper.xml对应的Mapper接口
 */
public interface ClassMapper {
    /**
     * 插入一条数据
     * @param student student
     */
    void insertStudent(Student student);
    void insertClass(Class course);
    /**
     * 根据sno删除一条记录
     * @param sno sno
     */
    void deleteStudent(String sno);
    /**
     * 更新数据
     * @param student student
     */
    void updateStudent(Student student);
    /**
     * 更具名称查询数据
     * @param name name
     * @return
     */
    Student findStudentByName(String name);
    /**
     * 查询全部数据
     * @return
     */
    List<Student> findAllStudent();
    /**
     * 集合数据查询
     * @param name name
     * @return
     */
    Class findClassStudents(String name);
    /**
     * 集合数据嵌套查询
     * @param classId classId
     * @return
     */
    Class findClassStudents1(String classId);
}

Mapper映射文件

Mapper 映射文件以 XML 为基础,使用与 SQL 语句对应的 SQL 标签来灵活的构建 SQL 语句,一些标签及其属性都是见名知意,常用标签如下:

  • mapper :配置 Mapper 映射文件对应的 Mapper 接口类;
  • resultMap:查询语句结果集;
  • result:用于定义 resultMap 标签中的字段;
  • id:用于定义 resultMap 标签中的主键字段;
  • collection:集合数据,如 List 这种数据;
  • sql:定义 SQL 语句块供其他 SQL 语句使用;
  • insert:插入语句;
  • delete:删除语句;
  • update:更新语句;
  • select:查询语句。

常用属性可查看如下案例中的相关注释,上述 Mapper 接口类 ClassMapper 对应的 Mapper 映射文件如下:


<mapper namespace="com.manu.mybatisxml.mapper.ClassMapper">
    
    
    
    <resultMap id="StudentResultMap" type="com.manu.mybatisxml.model.Student">
        
        
        
        <id column="classId" property="classId" jdbcType="VARCHAR" />
        
        <result column="userName" property="name" jdbcType="VARCHAR" />
        <result column="sno" property="sno" jdbcType="VARCHAR" />
        <result column="grade" property="grade" jdbcType="VARCHAR" />
    resultMap>

    
    <resultMap id="ClassWithCollectionResultMap" type="com.manu.mybatisxml.model.Class">
        <id column="classId" property="classId" jdbcType="VARCHAR" />
        <result column="name" property="name" jdbcType="VARCHAR" />
        
        <collection property="students" ofType="Student">
            <id column="sno" property="sno" jdbcType="VARCHAR" />
            <result column="userName" property="name" jdbcType="VARCHAR" />
            <result column="classId" property="classId" jdbcType="VARCHAR" />
            <result column="grade" property="grade" jdbcType="VARCHAR" />
        collection>
    resultMap>

    
    <resultMap id="ClassWithCollectionResultMap1" type="com.manu.mybatisxml.model.Class">
        <id column="classId" property="classId" jdbcType="VARCHAR" />
        <result column="name" property="name" jdbcType="VARCHAR" />
        
        
        <collection column="{classId = classId}" property="students" ofType="Student"
            select="getStudent" />
    resultMap>

    <select id="getStudent" parameterType="String" resultMap="StudentResultMap">
        SELECT *
        FROM mybatis_student
        WHERE classId = #{classId}
    select>

    
    <sql id="BaseStudentColumn">
        sno,userName,classId,grade
    sql>

    
    
    <insert id="insertClass" parameterType="Class">
        INSERT INTO mybatis_class(classId, name)
        VALUES (#{classId}, #{name})
    insert>
    <insert id="insertStudent" parameterType="Student">
        INSERT INTO mybatis_student(classId, userName, sno, grade)
        VALUES (#{classId}, #{name}, #{sno}, #{grade})
    insert>

    
    <delete id="deleteStudent" parameterType="String">
        DELETE
        FROM mybatis_student
        WHERE sno = #{sno}
    delete>

    
    <update id="updateStudent" parameterType="Student">
        UPDATE mybatis_student
        SET userName = #{name},
            classId  = #{classId},
            grade    = #{grade},
            sno      = #{sno}
        WHERE sno = #{sno}
    update>

    
    <select id="findClassStudents" parameterType="String" resultMap="ClassWithCollectionResultMap">
        SELECT mybatis_class.classId,
               mybatis_class.name,
               mybatis_student.sno,
               mybatis_student.userName,
               mybatis_student.grade
        FROM mybatis_student,
             mybatis_class
        WHERE mybatis_class.classId = mybatis_student.classId
          and mybatis_class.name = #{name}
    select>

    
    <select id="findClassStudents1" parameterType="String"
        resultMap="ClassWithCollectionResultMap1">
        SELECT mybatis_class.classId,
               mybatis_class.name,
               mybatis_student.sno,
               mybatis_student.userName,
               mybatis_student.grade
        FROM mybatis_student,
             mybatis_class
        WHERE mybatis_class.classId = mybatis_student.classId
          and mybatis_class.classId = #{classId}
    select>

    
    <select id="findStudentByName" resultMap="StudentResultMap" parameterType="String">
        SELECT *
        FROM mybatis_student
        WHERE userName = #{name}
    select>

    
    <select id="findAllStudent" resultMap="StudentResultMap">
        SELECT
        <include refid="BaseStudentColumn" />
        FROM mybatis_student
    select>
mapper>

collection标签的使用

上文介绍了Mapper 文件中中的一些常用标签,其他标签的使用没什么可单独说的,这里单独说明一下 标签的使用,该标签主要用来标识结果集,如班级类 Class 中的学生集合 List,通过该标签就可以查询到指定班级的学生集合,第一种方式:


<resultMap id="ClassWithCollectionResultMap" type="Class">
    <id column="classId" property="classId" jdbcType="VARCHAR" />
    <result column="name" property="name" jdbcType="VARCHAR" />
    
    <collection property="students" ofType="Student">
        <id column="sno" property="sno" jdbcType="VARCHAR" />
        <result column="userName" property="name" jdbcType="VARCHAR" />
        <result column="classId" property="classId" jdbcType="VARCHAR" />
        <result column="grade" property="grade" jdbcType="VARCHAR" />
    collection>
resultMap>

对应的查询 SQL 映射如下:


<select id="findClassStudents" parameterType="String" resultMap="ClassWithCollectionResultMap">
    SELECT mybatis_class.classId,
           mybatis_class.name,
           mybatis_student.sno,
           mybatis_student.userName,
           mybatis_student.grade
    FROM mybatis_student,
         mybatis_class
    WHERE mybatis_class.classId = mybatis_student.classId
      and mybatis_class.name = #{name}
select>

第二种方式如下:


<resultMap id="ClassWithCollectionResultMap1" type="com.manu.mybatisxml.model.Class">
    <id column="classId" property="classId" jdbcType="VARCHAR" />
    <result column="name" property="name" jdbcType="VARCHAR" />
    
    
    <collection column="{classId = classId}" property="students" ofType="Student"
        select="getStudent" />
resultMap>

<select id="getStudent" parameterType="String" resultMap="StudentResultMap">
    SELECT *
    FROM mybatis_student
    WHERE classId = #{classId}
select>

对应的查询 SQL 映射如下:


<select id="findClassStudents1" parameterType="String"
    resultMap="ClassWithCollectionResultMap1">
    SELECT mybatis_class.classId,
           mybatis_class.name,
           mybatis_student.sno,
           mybatis_student.userName,
           mybatis_student.grade
    FROM mybatis_student,
         mybatis_class
    WHERE mybatis_class.classId = mybatis_student.classId
      and mybatis_class.classId = #{classId}
select>

通过在 Mapper 接口中定义的 findClassStudents 即可查询到 Student 的对应集合。

多数据源配置

分别创建多数据源配置文件,生成多个不同的数据源以及不同的 SqlSessionFactory 等,主要数据源配置如下:

/**
 * @Primary表示主数据源
 * basePackages:指定扫描的Mapper接口
 * sqlSessionTemplateRef:指定在Mapper路径下指定的SqlSessionTemplate
 */
@Configuration
@MapperScan(basePackages = "com.manu.multimybatisxml.mapper.primary",
        sqlSessionTemplateRef = "primarySqlSessionTemplate")
public class PrimaryDataSourceConfig {

    @Primary
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource.primary")
    public DataSource primaryDataSource() {
        return DataSourceBuilder.create().build();
    }

    @Primary
    @Bean
    public SqlSessionFactory primarySqlSessionFactory(@Qualifier("primaryDataSource") DataSource dataSource) throws Exception {
        SqlSessionFactoryBean sessionFactoryBean = new SqlSessionFactoryBean();
        sessionFactoryBean.setDataSource(dataSource);
        sessionFactoryBean.setMapperLocations(
                new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/primary/*.xml"));
        return sessionFactoryBean.getObject();
    }

    @Primary
    @Bean
    public DataSourceTransactionManager primaryDataSourceTransactionManager(@Qualifier("primaryDataSource") DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }

    @Primary
    @Bean
    public SqlSessionTemplate primarySqlSessionTemplate(@Qualifier("primarySqlSessionFactory") SqlSessionFactory sqlSessionFactory) {
        return new SqlSessionTemplate(sqlSessionFactory);
    }
}

第二个数据源的配置同上,只是不在标注 @Primary,修改第二个数据源的名称以及对应的 Mapper 映射文件等,这里不再赘述。

然后按照上述配置中指定的前缀,在 application.properties 文件中配置多数据库连接如下:

# dataSourceOne
spring.datasource.primary.username=root
spring.datasource.primary.password=admin
spring.datasource.primary.driver-class-name=com.mysql.cj.jdbc.Driver
#spring.datasource.jdbc-url 多数据源中用来重写自定义连接池
spring.datasource.primary.jdbc-url=jdbc:mysql://localhost:3306/data_source_one?serverTimezone=Asia/Shanghai

# dataSourceTwo
spring.datasource.secondary.username=root
spring.datasource.secondary.password=admin
spring.datasource.secondary.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.secondary.jdbc-url=jdbc:mysql://localhost:3306/data_source_two?serverTimezone=Asia/Shanghai

# 是否执行MyBatis xml配置文件的状态检查, 只是检查状态,默认false
mybatis.check-config-location=true
# mybatis-config.xml文件的位置
mybatis.config-location=classpath:mybatis/mybatis-config.xml
# 设置别名的路径,可避免写全限定类名
mybatis.type-aliases-package=com.manu.multimybatisxml.model

具体内容可回复关键字【Spring Boot】获取源码链接。

测试结果

案例仅仅是为了说明使用方式,读者无需关心其合理性,编写测试类如下:

/**
 * MyBatisTest
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class MyBatisTest {
    @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
    @Autowired
    private ClassMapper mClassMapper;

    @Test
    public void insert() {
        Class class1 = new Class("class1", "一班");
        Class class2 = new Class("class2", "二班");
        mClassMapper.insertClass(class1);
        mClassMapper.insertClass(class2);

        List<Student> students = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            Student student;
            if (i % 2 == 0) {
                student = new Student("class1", "sno" + i, "Student"+i, "A");
            } else {
                student = new Student("class2", "sno" + i, "Student"+i, "B");
            }
            mClassMapper.insertStudent(student);
        }
    }

    @Test
    public void deleteStudentBySno() {
        mClassMapper.deleteStudent("sno0");
    }

    @Test
    public void updateStudent() {
        Student student = new Student("class1","sno1","student1","C");
        mClassMapper.updateStudent(student);
    }

    @Test
    public void findStudentByName() {
        Student student = mClassMapper.findStudentByName("student5");
        System.out.println(student);
    }

    @Test
    public void findAllStudent() {
        List<Student> students = mClassMapper.findAllStudent();
        for (Student student : students) {
            System.out.println(student.toString());
        }
    }

    @Test
    public void findClassStudents(){
        Class clazz = mClassMapper.findClassStudents("一班");
        System.out.println("classId:"+clazz.getClassId()+",name:"+clazz.getName());

        List<Student> students = clazz.getStudents();
        for (Student student : students) {
            System.out.println(student.toString());
        }
    }

    @Test
    public void findClassStudents1(){
        Class clazz = mClassMapper.findClassStudents1("class1");
        System.out.println("classId:"+clazz.getClassId()+",name:"+clazz.getName());

        List<Student> students = clazz.getStudents();
        for (Student student : students) {
            System.out.println(student.toString());
        }
    }
}

这里以 findClassStudents 方法为例查看执行结果如下:

classId:class1,name:一班
Student{classId='class1', sno='sno1', name='student1', grade='C'}
Student{classId='class1', sno='sno2', name='Student2', grade='A'}
Student{classId='class1', sno='sno4', name='Student4', grade='A'}
Student{classId='class1', sno='sno6', name='Student6', grade='A'}
Student{classId='class1', sno='sno8', name='Student8', grade='A'}

注解配置

MyBatis 除了使用 XML 进行配置外还可以通过注解进行配置,如下:

@Mapper
public interface StudentMapper {
    /**
     * 注解中的SQL语句中会自动获取对象student的相关属性
     */
    @Insert("INSERT INTO mybatis_student(userName,sno,grade) VALUES(#{name},#{sno},#{grade})")
    void insert(Student student);

    /**
     * StudentFactory中会自动获取对象student的相关属性在SQL语句中
     * StudentFactory中insert2方法通过#{属性名}的方式获取变量值
     */
    @InsertProvider(type = StudentFactory.class, method = "insert1")
    void insert1(Student student);

    /**
     * 直接传递参数
     * StudentFactory中insert2方法通过#{变量名}的方式获取变量值
     * 此外也可以通过StringBuffer拼接SQL,如在insert2方法中拼接SQL字符串返回
     */
    @InsertProvider(type = StudentFactory.class, method = "insert2")
    void insert2(String sno, String name, String grade);
}

实现上述方法即可,如下:

public class StudentFactory {
    public String insert1(Student student) {
        String sql = new SQL() {{
            INSERT_INTO("mybatis_student");
            VALUES("sno", "#{sno}");
            VALUES("userName", "#{name}");
            VALUES("grade", "#{grade}");
        }}.toString();
        System.out.println("SQL:" + sql);
        return sql;
    }

    public String insert2(String sno,String name,String grade) {
        String sql = new SQL() {{
            INSERT_INTO("mybatis_student");
            VALUES("sno", "#{sno}");
            VALUES("userName", "#{name}");
            VALUES("grade", "#{grade}");
        }}.toString();
        System.out.println("SQL:" + sql);
        return sql;
    }
}

最后,进行测试,如下:

@RunWith(SpringRunner.class)
@SpringBootTest
public class MyBatisAnnotationTests {

    @SuppressWarnings("SpringJavaInjectionPointsAutowiringInspection")
    @Autowired
    StudentMapper mStudentMapper;

    @Test
    public void insert() {
        Student student = new Student("sno0", "jzman0", "A");
        mStudentMapper.insert(student);
    }

    @Test
    public void insert1() {
        Student student = new Student("sno1", "jzman1", "A");
        mStudentMapper.insert1(student);
    }

    @Test
    public void insert2() {
        Student student = new Student("sno2", "jzman2", "A");
        mStudentMapper.insert2(student.getSno(), student.getName(), student.getGrade());
    }
}

MyBatis 使用注解方式代码更少,但是在 SQL 的灵活性性上还是有一定的局限性,这里没实践不做过多阐述可以在公众号后台回复【躬行之】回复关键字【Spring Boot】获取对应案例源码链接。

Spring Boot系列MyBatis配置详解_第2张图片

你可能感兴趣的:(Spring,Boot系列,spring,boot,mybatis,mysql,sql,Mapper)