MyBatis

一、MyBatis

1. MyBatis 简介

1.1 MyBatis 历史

• MyBatis 本是 Apache 的一个开源项目 iBatis，2010年这个项目由 Apache Software Foundation 迁移到了 Google Code，并且改名为 MyBatis 。代码于2013年11月迁移 Github。

• iBatis 一词来源于 “internet” 和 “abatis” 的组合，是一个基于Java的持久层框架。iBatis 提供的持久层框架包括 SQL Maps(sql 映射) 和 Data Access Objects（DAO）。

1.2 MyBatis 特性

• MyBatis 是支持定制化 SQL、存储过程以及高级映射的优秀的持久层框架
• MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集
• MyBatis可以使用简单的XML或注解用于配置和原始映射，将接口和 Java 的 POJO（Plain Old Java Objects，普通的 Java 对象）映射成数据库中的记录
• MyBatis 是一个 半自动的ORM（Object Relation Mapping 对象关系[关系型数据库]映射）框架

1.3 MyBatis 下载

• 下载地址：https://github.com/mybatis/mybatis-3

1.4 和其它的持久层技术对比

• JDBC
  • SQL 夹杂在Java代码中耦合度高，导致硬编码内伤
  • 维护不易且实际开发需求中 SQL 有变化，频繁修改的情况多见
  • 代码冗长，开发效率低
• Hibernate 和 JPA
  • 操作简便，开发效率高
  • 程序中的长难复杂 SQL 需要绕过框架
  • 内部自动生产的 SQL，不容易做特殊优化
  • 基于全映射的全自动框架，大量字段的 POJO 进行部分映射时比较困难
  • 反射操作太多，导致数据库性能下降
• MyBatis
  • 轻量级，性能出色
  • SQL 和 Java 编码分开，功能边界清晰。Java代码专注业务、SQL语句专注数据
  • 开发效率稍逊于HIbernate，但是完全能够接受

2. 搭建 MyBatis

2.1 开发环境

• IDE：idea 2020.3.2
• 构建工具：maven 3.6.1
• MySQL版本：MySQL 5.7.19
• MyBatis版本：MyBatis 3.5.10

MySQL 不同版本注意事项

1、 驱动类 driver-class-name

MySQL 5 版本使用 jdbc5 驱动，驱动类使用：com.mysql.jdbc.Driver

MySQL 8 版本使用 jdbc8 驱动，驱动类使用：com.mysql.cj.jdbc.Driver

2、连接地址 url

MySQL 5 版本的 url：

jdbc:mysql://localhost:3306/ssm

MySQL 8 版本的 url：

jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC

否则报错

2.2 创建 maven 工程

（1）empty project?然后直接新建模块(module)?

（2）打包方式 –> jar(在 pom.xml 中)

（3）导入依赖

<dependencies>
	<!-- Mybatis核心 -->
	<dependency>
		<groupId>org.mybatis</groupId>
		<artifactId>mybatis</artifactId>
		<version>3.5.7</version>
	</dependency>
	<!-- junit测试 -->
	<dependency>
		<groupId>junit</groupId>
		<artifactId>junit</artifactId>
		<version>4.12</version>
		<scope>test</scope>
	</dependency>
	<!-- MySQL驱动 -->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
		<version>5.1.47</version>
        <!--因为我的maver库李MySQL版本为5.1.3所以我的版本号为5.1.3 根据自身版本修改-->
		</dependency>
</dependencies>

（4）创建数据库和表

（5）创建对应的实体类

2.3 创建 MyBatis 的核心配置文件夹

习惯上命名为 mybatis-config.xml，这个文件名仅仅只是建议，并非强制要求。将来整合Spring之后，这个配置文件可以省略，所以操作时可以直接复制、粘贴。

核心配置文件主要用于配置连接数据库的环境以及MyBatis的全局配置信息(设置如何连接数据库，而 MyBatis 的映射文件是设置如何操作数据库)

核心配置文件存放的位置是 src/main/resources 目录下

核心配置文件的内容可以从mybatis的官方文档中的 Getting Started 获得

（1）官方文档中找配置文件里要写的内容

<?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.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC&amp;useSSL=false&amp;
                         				  useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="thr"/>
            </dataSource>
        </environment>
    </environments>

    <!-- 引入 mybatis 的映射文件(映射文件里头写的是 sql 语句) 
            通过读取核心配置文件来获取一个操作数据库的对象, 就可以直接执行 sql
            而 sql 语句在映射文件中, 所以要把映射文件配置到核心配置文件中, 
            才可以通过加载核心配置文件去找到对应映射文件中的 sql 去执行以便实现效果 
    -->
    <mappers>
        <mapper resource="mappers/UserMapper.xml"/>
    </mappers>
</configuration>

2.4 创建 mapper 接口

MyBatis 中的 mapper 接口相当于以前的dao，但是区别在于，mapper仅仅是接口，我们不需要提供实现类

package com.thr.mybatis.mapper;

/*
    创建一个 mapper 接口(不用实现类) --> mapper 接口中的一个方法对应映射文件的一个 sql 语句
    即可通过 mybatis 里头的一些功能来为它创建一个代理实现类
    当我们去调用接口里的方法时, 就可以直接对应一个 sql 语句并执行该语句

    接口的起名规则: 我们所操作的表叫 t_user, 表当前对应的实体类叫 User 类,
                    所以当前的 mapper 接口就叫 UserMapper
 */
public interface UserMapper {
    /*
        实现添加功能的方法
        返回值: 增删改的返回值是固定的, 是受影响的行数, 故返回值设为 int 型
     */
    int insertUser();
}

2.5 创建 MyBatis 的映射文件

关系梳理：

• 一张表 ——> 实体类 —-> 对应当前的mapper接口—->对应一个映射文件
• mapper接口中的方法 —> 对应映射文件中的SQL语句

相关概念：ORM（Object Relationship Mapping）对象关系映射。

• 对象：Java的实体类对象

• 关系：关系型数据库

• 映射：二者之间的对应关系

Java概念	数据库概念
类	表
属性	字段 / 列
对象	记录 / 行

1、映射文件的命名规则

表所对应的实体类的类名+Mapper.xml

例如：表 t_user，映射的实体类为 User，所对应的映射文件为 UserMapper.xml，mapper 接口就叫 UserMapper

因此一个映射文件对应一个实体类，对应一张表的操作

MyBatis 映射文件用于编写 SQL，访问以及操作表中的数据

2、MyBatis 中可以面向接口操作数据，要保证两个一致

(1) mapper 接口的全类名和映射文件的命名空间（namespace）保持一致

(2) mapper 接口中方法的方法名和映射文件中编写SQL的标签的id属性保持一致

3、映射文件的内容同样可以从官方文档的 Getting Started 中获得（第四页）

<?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">

<!-- 映射文件里头写 sql 语句 -->
<mapper namespace="com.thr.mybatis.mapper.UserMapper">
    <!--
        mapper 接口和映射文件需保证两个一致：
        1、mapper 接口的 全类名 和 映射文件 的 namespace 保持一致
        2、mapper 接口中方法的方法名和映射文件中 sql 的 id属性 保持一致
            (建议把 mapper 接口中的方法复制一份到所写的对应的 sql 语句上方)

       保证两个一致后, 当我们调用 mapper 接口中的方法时, 就会根据当前 mapper 接口的全类名来找到咱们的映射文件,
        并且根据我们当前调用的方法的方法名来找到 sql 语句, 来获取这个标签中的 sql 并执行该 sql
    -->

    <!-- int insertUser(); -->
    <insert id="insertUser">
        insert into ssm.t_user values(null, 'admin', '123456', 23, '男', '1234@qq.com')
    </insert>
</mapper>

然后修改 mybatis-config.xml 中引入映射文件的路径

<!-- 引入映射文件 -->
<mappers>
    <mapper resource="mappers/UserMapper.xml"/>
</mappers>

2.6 通过 junit 测试功能

（1）创建测试类

• 概念补充：
  • SqlSession：代表Java程序和数据库之间的会话（HttpSession是Java程序和浏览器之间的会话）
  • SqlSessionFactory：是 “生产” SqlSession的 “工厂”
  • 工厂模式：如果创建某一个对象，使用的过程基本固定，那么我们就可以把创建这个对象的相关代码封装到一个 “工厂类” 中，以后都使用这个工厂类来 “生产” 我们需要的对象
• 代码：

package com.thr.mybatis.test;

public class MyBatisTest {
    @Test
    public void testInsert() throws IOException {
        // 获取核心配置文件的输入流(读的功能), 注意此处的 Resources 是 org.apache.ibatis.io 里的
        // Resources.getResourceAsStream 用于获取当前的某一个文件(这里是核心配置文件)所对应的字节输入流
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");

        // 获取 sqlSessionFactoryBuilder 对象
        // 用于构建一个 SqlSessionFactory, 而 SqlSessionFactory 是一个工厂对象, 使用的是工厂模式, 能够为我们提供 SqlSession 对象
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();

        // 获取 SqlSessionFactory 对象(通过 build 方法, 根据核心配置文件所对应的输入流来创建所对应的对象)
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);

        // 获取 sql 的会话对象 SqlSession, 是 MyBatis 提供的操作数据库的对象
        SqlSession sqlSession = sqlSessionFactory.openSession();

   	    // 重点！(因为一个 mapper 接口不能直接创建对象, 所以通过代理模式创建当前 mapper 接口的代理实现类, 并且自动找到对应的 sql 语句去执行)
        // 获取 UserMapper 的代理实现类对象(代理模式 --> 帮助创建了 mapper 接口的代理实现类), 返回当前接口的实现类的对象
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        // 调用 mapper 接口中的方法, 实现添加用户信息的功能
        int result = mapper.insertUser();
        System.out.println("结果: " + result);

        // 手动提交事务
        sqlSession.commit();

        // 关闭会话 sqlSession
        sqlSession.close();
    }
}

• 优化(自动提交事务)

  //获取核心配置文件的输入流
  InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
  
  //获取SqlSessionFactoryBuilder对象
  SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
  
  //获取SqlSessionFactory对象
  SqlSessionFactory build = sqlSessionFactoryBuilder.build(is);
  
  //获取SQL的会话对象SqlSession()不会自动提交事务,是MyBatis提供的操作数据库的对象
  //SqlSession sqlSession = build.openSession();
  //获取SQL的会话对象SqlSession(true)会自动提交事务,是MyBatis提供的操作数据库的对象
  SqlSession sqlSession = build.openSession(true);
  
  // 重点！(因为一个 mapper 接口不能直接创建对象, 所以通过代理模式创建当前 mapper 接口的代理实现类, 并且自动找到对应的 sql 语句去执行)
  // 获取 UserMapper 的代理实现类对象(代理模式 --> 帮助创建了 mapper 接口的代理实现类), 返回当前接口的实现类的对象
  UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  
  // 调用 mapper 接口中的方法, 实现添加用户信息的功能
  int result = mapper.insertUser();
  System.out.println("结果: " + result);
  
  //        //演示不用 mapper 接口时(用的不多)
  //        // 通过 sql 语句的唯一标识找到 sql 并执行, 唯一标识是 namespace.sqlId
  //        int result1 = sqlSession.insert("com.thr.mybatis.mapper.UserMapper.insertUser");
  //        System.out.println("结果:" + result1);
  
  // 关闭会话 sqlSession
  sqlSession.close();

（2）测试

• SQLyog 中右键点击表名，在 更多表操作中选择 截断表

  截断和清空的区别：

  清空：把表中的数据删除

  截断：其底层是先将表删掉，再重新创建一个一模一样的表，故 id 会从一开始自增 (截断很危险，其不支持事务，执行了不能回滚)

  

• 执行成功

  

  

2.7 加入 log4j 日志功能

• 加入依赖，在 pom.xml 里添加配置

  <!-- log4j日志 -->
  <dependencies>
      <dependency>
          <groupId>log4j</groupId>
          <artifactId>log4j</artifactId>
          <version>1.2.17</version>
      </dependency>
  </dependencies>

• 加入 log4j(日志框架) 的配置文件

  log4j 的配置文件为 log4j.xml，存放位置是 src/main/resources 目录下

  注：报错提示 URI 未注册 可以不用管

  <?xml version="1.0" encoding="UTF-8" ?>
  <!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
  <log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
      <appender name="STDOUT" class="org.apache.log4j.ConsoleAppender">
          <param name="Encoding" value="UTF-8" />
          <layout class="org.apache.log4j.PatternLayout">
              <param name="ConversionPattern" value="%-5p %d{MM-dd HH:mm:ss,SSS} %m (%F:%L) \n" />
          </layout>
      </appender>
      <logger name="java.sql">
          <level value="debug" />
      </logger>
      <logger name="org.apache.ibatis">
          <level value="info" />
      </logger>
      <root>
          <level value="debug" />
          <appender-ref ref="STDOUT" />
      </root>
  </log4j:configuration>

  日志的级别

  FATAL(致命) > ERROR(错误) > WARN(警告) > INFO(信息) > DEBUG(调试)

  从左到右打印的内容越来越详细，故当我们选择了一个级别后，打印的是大于等于当前这个日志级别的日志信息(我们这里选的是 debug)

• 运行结果如下：

  DEBUG 12-31 00:08:52,243 ==>  Preparing: insert into ssm.t_user values(null, 'admin', '123456', 23, '男', '1234@qq.com') (BaseJdbcLogger.java:137) 
  DEBUG 12-31 00:08:52,281 ==> Parameters:  (BaseJdbcLogger.java:137) 
  DEBUG 12-31 00:08:52,293 <==    Updates: 1 (BaseJdbcLogger.java:137) 
  结果: 1

3. MyBatis 的(增)删改查

3.1 创建工具类

package com.thr.mybatis.utils;

public class SqlSessionUtil {
    // 静态方法
    public static SqlSession getSqlSession() {
        SqlSession sqlSession = null;
        try {
            // 1. 获取核心配置文件的输入流(捕获异常 ctrl + alt + t, 选择第六个 try/catch)
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");

            // 2. 获取 sqlSessionFactoryBuilder 对象
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();

            // 3. 获取 sqlSessionFactory 对象
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);

            // 4. 获取 sqlSession 对象(自动提交事务)
            sqlSession = sqlSessionFactory.openSession(true);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sqlSession;
    }
}

3.2 Update

• 在 mapper 接口中创建方法

  package com.thr.mybatis.mapper;
  
  public interface UserMapper {
      /**
       * 添加用户信息
       * 返回值: 增删改的返回值是固定的, 是受影响的行数, 故返回值设为 int 型
       */
      int insertUser();
  
      /**
       * 修改用户信息
       */
      void updateUser();
  }

• 在映射文件中写对应的 sql 语句

  <mapper namespace="com.thr.mybatis.mapper.UserMapper">
      <!-- int insertUser(); -->
      <insert id="insertUser">
          insert into ssm.t_user values(null, 'admin', '123456', 23, '男', '1234@qq.com')
      </insert>
  
      <!-- void updateUser(); -->
      <update id="updateUser">
          update ssm.t_user set username='root', password='123' where id = 3
      </update>
  </mapper>

• 测试

  @Test
  // 修改用户信息(用工具类实现)
  public void testUpdate() {
      // 1. 通过工具类先获取 sqlSession 对象
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  
      // 2. 获取 mapper 接口的代理实现类对象, 直接调用接口中的方法即可
      UserMapper mapper = sqlSession.getMapper(UserMapper.class);
      mapper.updateUser();
  
      // 3. 关闭 sqlSession
      sqlSession.close();
  }

3.3 Delete

• 在 mapper 接口中创建方法

  void deleteUser();

• 在映射文件中写对应的 sql 语句

  <!-- void deleteUser(); -->
  <delete id="deleteUser">
      delete from ssm.t_user where id = 4
  </delete>

• 测试

  @Test
  // 删除用户信息(用工具类实现)
  public void testDelete() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  
      UserMapper mapper = sqlSession.getMapper(UserMapper.class);
      mapper.deleteUser();
  
      sqlSession.close();
  }

3.4 Retrieve

（1）查询单个用户信息(根据用户 id)

• 在 mapper 接口中创建方法

  /**
   * 根据 id 查询用户信息
   * 返回一个对象(只查询一条用户信息)
   */
  User getUserById();

• 在映射文件中写对应的 sql 语句

  <!-- 由于返回值是一个对象, 所以要写 resultType/resultMap,
           因为当前的字段名和属性名完全相同, 故此处直接选 resultType 即可
             resultType: 设置结果类型, 即查询的数据要转换为的 java 类型(此处要写全类名)
             resultMap: 自定义映射, 处理多对一或一对多的映射关系
  -->
  <!-- User getUserById(); -->
  <select id="getUserById" resultType="com.thr.mybatis.pojo.User">
      select * from ssm.t_user where id = 1
  </select>

  此处若没写 resultType，测试时会报错如下：

  报错信息：A query was run and no Result Maps were found for the Mapped Statement ‘com.thr.mybatis.mapper.UserMapper.getUserById’.

  It’s likely that neither a Result Type nor a Result Map was specified.

• 测试

  @Test
  // 查询用户信息(用工具类实现)
  public void testGetUserById() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  
      UserMapper mapper = sqlSession.getMapper(UserMapper.class);
      User user = mapper.getUserById();
      System.out.println(user);
      // 结果: User{id=1, username='admin', password='123456', age=23, gender='男', email='1234@qq.com'}
  
      sqlSession.close();
  }

（2）查询所有用户信息

• 在 mapper 接口中创建方法

  /**
   * 查询所有的用户信息
   * 返回一个对象集合
   */
  List<User> getAllUser();

• 在映射文件中写对应的 sql 语句

  <!-- 先转换为实体类对象后再放到集合里头 -->
  <!-- List<User> getAllUser(); -->
  <select id="getAllUser" resultType="com.thr.mybatis.pojo.User">
      select * from ssm.t_user
  </select>

• 测试

  @Test
  // 查询所有用户信息(用工具类实现)
  public void testGetAllUser() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  
      UserMapper mapper = sqlSession.getMapper(UserMapper.class);
      List<User> list = mapper.getAllUser();
  
      // 循环输出(这写法???!)
      // System.out::println 等价于 x -> { System.out.println(x) }
      list.forEach(System.out::println);
  
      /* 结果:
              User{id=1, username='admin', password='123456', age=23, gender='男', email='1234@qq.com'}
              User{id=2, username='admin', password='123456', age=23, gender='男', email='1234@qq.com'}
              User{id=3, username='root', password='123', age=23, gender='男', email='1234@qq.com'}
       */
  
      sqlSession.close();
  }

4. MyBatis 的核心配置文件详解

4.1 environments 标签

<!--
        environments: 配置连接数据库的环境
        属性: default: 设置默认使用的环境的 id (这里是 development 开发环境)
-->
<environments default="development">
    <!--
            environment: 设置一个具体的连接数据库的环境
            属性: id: 设置环境的唯一标识(即不能重复)
            其拥有两个子标签:
                transactionManager: 事务管理器(设置数据库的管理方式)
                dataSource: 数据源
     -->

    <!-- 配置连接数据库的环境(此处是开发环境) -->
    <environment id="development">
        <!--
                 transactionManager: 设置事务管理器
                 属性: type: 设置事务管理的方式 type="JDBC/MANAGED"
                            JDBC: 表示使用 JDBC 中原生的事务管理方式
                            MANAGED: 被管理, 例如 Spring 管理事务
         -->
        <transactionManager type="JDBC"/>
        <!--
                dataSource: 设置数据源
                属性: type: 设置数据源的类型 type="POOLED/UNPOOLED/JNDI"
                            POOLED: 表示使用数据库连接池(创建完连接后交给连接池管理, 下一次创建连接时直接从连接池里获取就行)
                            UNPOOLED: 表示不使用数据库连接池(每次获取都是重新获取/重新创建连接)
                            JNDI: 表示使用上下文中的数据源
         -->
        <dataSource type="POOLED">
            <property name="driver" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC&amp;useSSL=false&amp;
                                        useUnicode=true&amp;characterEncoding=UTF-8"/>
            <property name="username" value="root"/>
            <property name="password" value="thr"/>
        </dataSource>
    </environment>

    <!-- 配置连接数据库的环境(此处是测试环境) -->
    <environment id="test">
        <transactionManager type="JDBC"/>
        <dataSource type="POOLED">
            <property name="driver" value="com.mysql.jdbc.Driver"/>
            <property name="url" value="jdbc:mysql://localhost:3306/ssm?serverTimezone=UTC&amp;useSSL=false&amp;
                                        useUnicode=true&amp;characterEncoding=UTF-8"/>
            <property name="username" value="root"/>
            <property name="password" value="thr"/>
        </dataSource>
    </environment>
</environments>

4.2 properties 标签

• 新建一个 properties 文件

  

  

• 编写配置文件

  因为xml解析转移的原因，& 都改成 &

  注意：useSSL=false 需写在最前面！！！

  jdbc.driver=com.mysql.jdbc.Driver
  jdbc.url=jdbc:mysql://localhost:3306/ssm?useSSL=false&serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8
  jdbc.username=root
  jdbc.password=thr

• 将 配置文件(jdbc.properties) 引入到核心配置文件(mybatis-config.xml)

  <!-- 引入 properties 文件, 此后就可以在当前文件中使用 ${key} 的方式访问 value -->
  <properties resource="jdbc.properties" />
  <environments default="development">
      <environment id="development">
          <transactionManager type="JDBC"/>
          <dataSource type="POOLED">
              <property name="driver" value="${jdbc.driver}"/>
              <property name="url" value="${jdbc.url}"/>
              <property name="username" value="${jdbc.username}"/>
              <property name="password" value="${jdbc.password}"/>
          </dataSource>
      </environment>
  </environments>

4.3 typeAliases 标签

• 配置文件里头进行配置

  MyBatis 核心配置文件中的标签必须按照指定的顺序配置： properties?,settings?,typeAliases?,typeHandlers?, objectFactory?,objectWrapperFactory?,reflectorFactory?,plugins?,environments?,databaseIdProvider?,mappers?

  <!--
          MyBatis 核心配置文件中的标签必须按照指定的顺序配置:
              properties?,settings?,typeAliases?,typeHandlers?,
              objectFactory?,objectWrapperFactory?,reflectorFactory?,plugins?,
              environments?,databaseIdProvider?,mappers?
  -->
  <!-- 引入 properties 文件, 此后就可以在当前文件中使用 ${key} 的方式访问 value -->
  <properties resource="jdbc.properties" />
  
  <!--
          typeAliases(这是一个复数标签): 设置类型别名
                   在 MyBatis 的范围中, 就可以使用别名表示一个具体的类型
  -->
  <typeAliases>
      <!--
             typeAlias: 为某个具体的类型设置一个别名
             属性:
                  type: 设置需要起别名的类型
                  alias: 设置某个类型的别名
          -->
      <!--<typeAlias type="com.thr.mybatis.pojo.User" alias="abc"></typeAlias>-->
      <!--若不设置 alias, 其默认别名为类名 User, 且不区分大小写 -->
      <!--<typeAlias type="com.thr.mybatis.pojo.User"></typeAlias>-->
      <!-- 通过包来设置类型别名, 指定包下所有的类型将全部拥有默认的别名, 即类名且不区分大小写 -->
      <package name="com.thr.mybatis.pojo"/>
  </typeAliases>

• 映射文件里头修改，测试结果无误

  

4.4 mappers 标签

• 在 resources 下创建多级目录(注意使用 / 分割，而不是 . 分割)

  因为 resources 下只能建目录不能建包

  

  

  

• 在核心配置文件中引入映射文件

  <mappers>
      <!--<mapper resource="mappers/UserMapper.xml"/>-->
      <!--
              以包的方式来引入映射文件, 但是必须满足两个条件:
                  1. mapper接口 和 映射文件 所在的包必须一致
                  2. mapper接口的名字 和 映射文件的名字 必须一致
        -->
      <package name="com.thr.mybatis.mapper"/>
  </mappers>

  注： 改之后报错需要重构一下！！

  (如果报错Invalid bound statement的去右边maven打开clean一下)

• 编译后可以在 target 目录下的 classes(主程序编译之后的类) 目录下看到它们实际上被加载到了同一个目录下

  

5. 配置核心配置文件和映射文件模板

5.1 配置模板

（1）核心配置文件的模板

• 在 settings 里头配置

  

• 之后右键就可以看到了

  

  

（2）映射文件的模板

• 同理

  

5.2 使用模板

（1）创建新 Module

（2）把原来的依赖和一些配置文件复制粘贴过来

（3）搭建 MyBatis 框架

• 利用前面创建的模板新建核心配置文件
• 创建 mapper 接口
• 创建 映射文件，在 namespace 里头写上接口的全类名

• 创建主体类 User (从之前那个工程里头复制过来即可)

  

• 将核心配置文件中别名和映射文件的全类名补充上

  

6. MyBatis 获取参数值的两种方式

MyBatis 获取参数值的两种方式：**${} 和 #{}**

${} 的本质就是字符串拼接，#{} 的本质就是占位符赋值(后者比较常用，因为其可以自动添加单引号，还可以避免 sql 注入)

${} 使用字符串拼接的方式拼接 sql，若为字符串类型或日期类型的字段进行赋值时，需要手动加单引号

#{} 使用占位符赋值的方式拼接 sql，此时为字符串类型或日期类型的字段进行赋值时，可以自动添加单引号

6.1 单个字面量类型的参数

若mapper接口中的方法参数为单个的字面量类型

此时可以使用 ${} 和 #{} 以任意的名称获取参数的值，注意 ${} 需要手动加单引号

• 在 mapper 接口里编写方法(根据用户名查询用户信息)

  package com.thr.mybatis.mapper;
  
  public interface UserMapper {
      /**
       * 根据用户名查询用户信息
       * @param username 单个字面量类型的参数
       * @return 返回 User 对象
       */
      User getUserByUsername(String username);
  }

• 在映射文件里写 sql 语句

  注：

  此处 #{} 的 {} 里写啥都没关系，只是最好见名知意

  而此处若用 ${} 需在外头加单引号！！

  <!-- User getUserByUsername(String username); -->
  <select id="getUserByUsername" resultType="User">
      <!-- select * from t_user where username = #{username} -->
      select * from t_user where username = '${username}'
  </select>

表名爆红的解决方案：(好像没啥用，后面又改回来了，莫名其妙就好了)

File->Settings->Languages&Frameworks->SQL Dialects->Global SQL Dialect设为None

• 编写测试类（#{} 被当作占位符来解析）

  package com.thr.mybatis.test;
  
  // 测试类
  public class ParameterTest {
      @Test
      public void testGetUserByUsername() {
          // 获取 sqlSession 对象
          SqlSession sqlSession = SqlSessionUtil.getSqlSession();
  
          // 获取 UserMapper 的代理实现类对象
          UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  
          // 调用 mapper 里头的方法
          User user = mapper.getUserByUsername("admin");
  
          System.out.println(user);
      }
  }

6.2 多个字面量类型的参数

若 mapper 接口中的方法参数为多个时，此时MyBatis会自动将这些参数放在一个 map集合 中，因此只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号

• 在 mapper 接口里编写方法

  public interface UserMapper {
      User getUserByUsername(String username);
  
      /**
       * 验证登录(多个字面量类型的参数)
       * @param username 用户名
       * @param password 密码
       * @return 返回 User 对象
       */
      User checkLogin(String username, String password);
  }

• 在映射文件里写 sql 语句

  <!-- User checkLogin(String username, String password); -->
  <select id="checkLogin" resultType="User">
      <!-- 此处可用 #{arg0} #{arg1} 或者 #{param1} #{param2} -->
      <!-- select * from t_user where username = #{arg0} and password = #{arg1} -->
      select * from t_user where username = '${param1}' and password = '${param2}'
  </select>

  若写成 #{username} 和 #{password} 则会报错！！

  报错提示：Available parameters are [arg1, arg0, param1, param2]

• 测试

  @Test
  public void testCheckLogin() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  
      User user = mapper.checkLogin("admin", "123456");
      System.out.println(user);
  }

6.3 map 集合类型的参数

若 mapper 接口中的方法需要的参数为多个时，此时可以手动创建 map 集合，将这些数据放在map中只需要通过 ${} 和 #{} 访问map集合的键就可以获取相对应的值，注意 ${} 需要手动加单引号

• 在 mapper 接口里编写方法

  public interface UserMapper {
      User getUserByUsername(String username);
      User checkLogin(String username, String password);
  
      /**
       * 验证登录(map 集合类型的参数)
       * @param map 集合里头存储用户名和密码, 用户名的键为 username, 密码的键为 password
       * @return 返回 User 对象
       */
      User checkLoginByMap(Map<String, Object> map);
  }

• 在映射文件里写 sql 语句

  <!-- User checkLoginByMap(Map<String, Object> map); -->
  <select id="checkLoginByMap" resultType="User">
      select * from t_user where username = #{username} and password = #{password}
  </select>

• 测试

  @Test
  public void testCheckLoginByMap() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  
      Map<String, Object> map = new HashMap<>();
      map.put("username", "admin");
      map.put("password", "123456");
  
      User user = mapper.checkLoginByMap(map);
      System.out.println(user);
  }

6.4 实体类类型的参数

若 mapper 接口中的方法参数为实体类对象时此时可以使用 ${} 和 #{}，通过访问实体类对象中的属性名获取属性值，注意 ${} 需要手动加单引号

• 在 mapper 接口里编写方法

  public interface UserMapper {
      User getUserByUsername(String username);
      User checkLogin(String username, String password);
      User checkLoginByMap(Map<String, Object> map);
  
      /**
       * 添加用户信息(实体类类型的参数)
       * @param user 参数是 user 对象
       */
      void insertUser(User user);
  }

• 在映射文件里写 sql 语句

  属性和成员变量？

  属性对应数据库对象的属性，成员变量是程序的变量。

  到 springboot 的时候还要写代码把属性和成员变量对应起来

  意思是：如果你的 getId 方法，return 的是你 name 的值，那我不管，我就认为你的这个 name 叫 id 属性

  不要将成员变量和方法搞混，我新建一个类，没有成员变量只有方法有没有问题？我将这个方法命名为get方法有没有问题？肯定都没问题呀

  如果是个实体类，一般都是成员变量和getset方法一一对应的，但是总会出现一些非一般的情况。老师是给大家提个醒，别到时候一脸懵逼，哈哈哈

  没有成员变量不影响你写一个getter/setter方法

  <!-- void insertUser(User user); -->
  <insert id="insertUser">
      insert into t_user values(null, #{username}, #{password}, #{age}, #{gender}, #{email})
  </insert>

• 测试

  @Test
  public void testInsertUser() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      UserMapper mapper = sqlSession.getMapper(UserMapper.class);
  
      User user = new User(null, "root", "123456", 33, "女", "123@qq.com");
      mapper.insertUser(user);
  }

6.5 使用 @Param 标识参数

该方法较为常用，可以通过 @Param 注解 标识 mapper 接口中的方法参数，此时，会将这些参数放在map集合中（以 @Param 中的值为键，参数为值 或 以param1，param2，… 为键，参数为值），只需要通过${}和#{}访问map集合的键就可以获取相对应的值，注意${}需要手动加单引号

• 在 mapper 接口里编写方法

  public interface UserMapper {
      User getUserByUsername(String username);
      User checkLogin(String username, String password);
      User checkLoginByMap(Map<String, Object> map);
      void insertUser(User user);
  
      /**
       * 验证登录(使用 @Param 标识参数), 该方法比较常用
       * @param username 用户名
       * @param password 密码
       * @return 返回 User 对象
       */
      User checkLoginByParam(@Param(value = "username") String username, @Param("password") String password);
  }

• 在映射文件里写 sql 语句

  <!-- User checkLoginByParam(@Param(value = "username") String username, @Param("password") String password); -->
  <select id="checkLoginByParam" resultType="User">
      <!-- 这里不仅可以用 @Param 的 value 属性值为键, 也可以用 param1, param2 为键(即 #{param1}) -->
      select * from t_user where username = #{username} and password = #{password}
  </select>

• 测试

  @Test
  public void testCheckLoginByParam() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      UserMapper mapper = sqlSession.getMapper(UserMapper.class);
      User user = mapper.checkLoginByParam("admin", "123456");
      System.out.println(user);
  }

6.6 总结

• 在使用过程中最好使用 实体类型的参数 和 @Param注解 来获取参数值(实际只要记住最后两种方法即可)

/**
 * MyBatis 获取参数值的两种方式: #{} 和 ${}
 *  #{} 的本质是占位符赋值, ${} 的本质是字符串拼接
 *
 * 1. 若 mapper 接口方法的参数为单个的字面量类型
 *    此时可以通过 #{} 和 ${} 以任意的内容获取参数值, 一定要注意 ${} 的单引号问题
 *
 * 2. 若 mapper 接口方法的参数为多个的字面量类型
 *    此时 MyBatis 会将参数放在 map 集合中, 以两种方式存储数据
 *    a> 以 arg0,arg1... 为键, 以参数为值
 *    b> 以 param1,param2... 为键, 以参数为值
 *    因此, 只需要通过 #{} 和 ${} 访问 map 集合的键, 就可以获取相对应的值, 一定要注意 ${} 的单引号问题
 *
 * 3. 若 mapper 接口方法的参数为 map 集合类型的参数
 *    只需要通过 #{} 和 ${} 访问 map 集合的键, 就可以获取相对应的值, 一定要注意 ${} 的单引号问题
 *
 * 4. 若 mapper 接口方法的参数为实体类类型的参数
 *    只需要通过 #{} 和 ${} 访问实体类的属性名, 就可以获取相对应的属性值, 一定要注意 ${} 的单引号问题
 *
 * 5. 可以在 mapper 接口方法的参数上设置 @Param 注解
 *    此时 MyBatis 会将这些参数放在 map 中, 以两种方式进行存储
 *    a> 以 @Param 注解的 value 属性值为键, 以参数为值
 *    b> 以 param1, param2... 为键, 以参数为值
 *    只需要通过 #{} 和 ${} 访问 map 集合的键, 就可以获取相对应的值, 一定要注意 ${} 的单引号问题
 */

7. MyBatis 的各种查询功能

7.1 查询一个实体类对象

若 sql 语句查询的结果为多条时，一定不能以实体类类型作为方法的返回值，否则会抛出异常 TooManyResultsException

若 sql 语句查询的结果为1条时，此时可以使用实体类类型或 list 集合类型作为方法的返回值

• 创建 mapper 接口、映射文件以及测试类

  

• 在 mapper 接口里编写方法

  package com.thr.mybatis.mapper;
  
  public interface SelectMapper {
      /**
       * 根据 id 查询用户信息(查询一个实体类对象)
       * @param id 用户 id
       * @return 返回一个实体类对象(此处是User 类的对象)
       */
      User getUserById(@Param("id") Integer id);
  }

• 在映射文件里写 sql 语句

  <!-- User getUserById(@Param("id") Integer id); -->
  <select id="getUserById" resultType="User">
      select * from t_user where id = #{id}
  </select>

• 测试

  @Test
  public void testGetUserById() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
      User user = mapper.getUserById(1);
      System.out.println(user);
  }

7.2 查询一个 list 集合

• 在 mapper 接口里编写方法

  public interface SelectMapper {
      User getUserById(@Param("id") Integer id);
  
      /**
       * 查询所有的用户信息
       * @return 返回一个 list 集合
       */
      List<User> getAllUser();
  }

• 在映射文件里写 sql 语句

  <!-- List<User> getAllUser(); -->
  <select id="getAllUser" resultType="User">
      select * from t_user
  </select>

• 测试

  @Test
  public void testGetAllUser() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
      List<User> list = mapper.getAllUser();
      list.forEach(System.out::println);
  }

7.3 查询单个数据

• 在 mapper 接口里编写方法

  public interface SelectMapper {
      User getUserById(@Param("id") Integer id);
      List<User> getAllUser();
  
      /**
       * 查询用户的总数量(查询单个数据)
       * @return 返回用户数量(int 类型)
       */
      Integer getCount();
  }

• 在映射文件里写 sql 语句

  <!-- Integer getCount(); -->
  <!--
          此处的 resultType 写 int/Integer 也行(不区分大小写)
          因为 MyBatis 中为 Java 中常用的类型设置了类型别名
          Integer: Integer, int
          int: _int, _integer
          String: string
          Map: map
          HashMap: hashmap   
  -->
  <select id="getCount" resultType="java.lang.Integer">
      select count(*) from t_user
  </select>

• 测试

  @Test
  public void testGetCount() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
      Integer count = mapper.getCount();
      System.out.println(count);
  }

7.4 查询一条数据为 map 集合

• 在 mapper 接口里编写方法

  public interface SelectMapper {
      User getUserById(@Param("id") Integer id);
      List<User> getAllUser();
      Integer getCount();
  
      /**
       * 通过 id 查询用户信息, 以 map 集合来获取(查询一条数据为 map 集合)
       * @return 返回一个 map 集合
       */
      Map<String, Object> getUserByIdToMap(@Param("id") Integer id);
  }

• 在映射文件里写 sql 语句

  <!-- Map<String, Object> getUserByIdToMap(@Param("id") Integer id); -->
  <select id="getUserByIdToMap" resultType="map">
      select * from t_user where id = #{id}
  </select>

• 测试

  @Test
  public void testGetUserByIdToMap() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
  
      // 输出是以 字段名为键, 以 字段的值为值的 map(若某个字段的值为 null, 则不会被放在 map 里)
      // (map 集合中的 key 是无序的不可重复的, 其排序是按照 key 所在类重写的equals()和hashcode()来进行的)
      // {password=123456, gender=男, id=1, age=23, email=12345@qq.com, username=admin}
      Map<String, Object> map = mapper.getUserByIdToMap(1);
      System.out.println(map);
  }

7.5 查询多条数据为 map 集合

若查询的数据有多条时，并且要将每条数据转换为 map 集合

此时有两种解决方案：（法一用的较多）

a> 如果不确定返回几条结果，建议将 mapper 接口方法的返回值设置为泛型是 map 的 list 集合(即 List<Map<String, Object>> getAllUserToMap();)

b> 可以将每条数据转换的 map 集合放在一个大的 map 中，但是必须要通过 @MapKey 注解将查询的某个字段的字作为大的 map 的键(json 格式？)

小技巧：

查询的结果有实体类，用实体类对象接收

查询的结果无实体类，用map集合方式接收

（1）方法一：List<Map<>>

• 在 mapper 接口里编写方法

  /**
   * 查询所有的用户信息为 map 集合(查询多条数据为 map 集合)
   * @return 返回一个存放着 每一条数据转换成的 map 集合 的 list 集合
   */
  List<Map<String, Object>> getAllUserToMap();

• 在映射文件里写 sql 语句

  注意此处的 resultType=”map” ？？

  <!-- List<Map<String, Object>> getAllUserToMap(); -->
  <select id="getAllUserToMap" resultType="map">
      select * from t_user
  </select>

• 测试

  @Test
  public void testAllUserToMap() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
  
      List<Map<String, Object>> list = mapper.getAllUserToMap();
      System.out.println(list);
      /*  运行结果:
              [{password=123456, gender=男, id=1, age=23, email=12345@qq.com, username=admin},
              {password=123456, gender=女, id=4, age=33, email=123@qq.com, username=root}]
      */
  }

（2）方法二：@MapKey

• 在 mapper 接口里编写方法

  /**
    * 采用注解方式
    * 查询所有的用户信息为 map 集合(查询多条数据为 map 集合)
    * @return 返回一个装着 map 的 map 集合
    * (这里用查询出来的 id 为外层 map 的键, 值就是当前的每一条数据所转换为的 map 集合)
    */
  @MapKey("id")
  Map<String, Object> getAllUserToMapByMapKey();

• 在映射文件里写 sql 语句

  <!-- Map<String, Object> getAllUserToMapByMapKey(); -->
  <select id="getAllUserToMapByMapKey" resultType="map">
      select * from t_user
  </select>

• 测试

  @Test
  public void testAllUserToMapByMapKey() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      SelectMapper mapper = sqlSession.getMapper(SelectMapper.class);
  
      Map<String, Object> map = mapper.getAllUserToMapByMapKey();
      System.out.println(map);
      /*  运行结果:
              {1={password=123456, gender=男, id=1, age=23, email=12345@qq.com, username=admin},
              4={password=123456, gender=女, id=4, age=33, email=123@qq.com, username=root}}
       */
  }

8. 特殊 SQL 的执行

8.1 模糊查询

直接用 #{} 会报错(因为 ? 在引号里头, 不会被当成占位符解析, 而是被当成了字符串)，因此采用如下三种方法：

a> ${} (慎用, 会有 sql 注入的风险)

b> concat 字符串拼接函数 和 #{}

c> 双引号 和 #{} (该方式比较常用)

（1）直接用 ${}

• 创建 mapper 接口和 映射文件

  

• 在 mapper 接口里编写方法

  package com.thr.mybatis.mapper;
  
  public interface SpecialSQLMapper {
      // 如果不确定查询出来的结果有几条, 建议使用 list 集合来获取(即用 list 作为返回值)
      // 因为如果用实体类对象来接收的话, 会报错(TooManyResultException)
  
      /**
       * 通过用户名模糊查询用户信息
       * @param blur 模糊查询的限定条件
       * @return 返回存放 User 对象的 list 集合
       */
      List<User> getUserByLike(@Param("blur") String blur);
  }

• 在映射文件里写 sql 语句

  <!-- List<User> getUserByLike(@Param("blur") String blur); -->
  <select id="getUserByLike" resultType="User">
      select * from t_user where username like '%${blur}%'
  </select>

• 测试

  @Test
  public void testGetUserByLike() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      SpecialSQLMapper mapper = sqlSession.getMapper(SpecialSQLMapper.class);
  
      List<User> list = mapper.getUserByLike("a");
      list.forEach(System.out::println);
      // 结果: User{id=1, username='admin', password='123456', age=23, gender='男', email='12345@qq.com'}
  }

（2）使用 mysql 中的 concat 字符串拼接函数 和 #{}

<!-- List<User> getUserByLike(@Param("blur") String blur); -->
<select id="getUserByLike" resultType="User">
    select * from t_user where username like concat('%', #{blur}, '%')
</select>

（3）使用 双引号 和 #{}

<!-- List<User> getUserByLike(@Param("blur") String blur); -->
<select id="getUserByLike" resultType="User">
    select * from t_user where username like "%"#{blur}"%"
</select>

8.2 批量删除

mysql 中写的 sql 语句：

DELETE FROM t_user WHERE id = 5 OR id = 6;
DELETE FROM t_user WHERE id IN(7,8);

由于 #{} 会在参数两边自动拼接单引号，会导致出错，但不会报错，只是更新的数据为0条，例如：如果使用#{}，则解析后的sql语句为 delete from t_user where id in (‘1,2,3’)，这样是将1,2,3看做是一个整体，只有id为 1,2,3 的数据会被删除。正确的语句应该是delete from t_user where id in (1,2,3)，或者delete from t_user where id in (‘1’,’2’,’3’) 。所以只能使用 ${}

• 在 mapper 接口里编写方法

  /**
   * 批量删除的功能
   * @param ids 用户 id
   */
  void deleteMoreUser(@Param("ids") String ids);

• 在映射文件里写 sql 语句

  <!-- void deleteMoreUser(@Param("ids") String ids);  // eg. ids: 9, 10-->
  <delete id="deleteMoreUser">
      <!-- 此处不能直接用 in(#{ids}), 因为其本质是占位符赋值,
               所以其会为我们所赋的值自动加上单引号, 解析后变成 in('9,10'), 故报错
               该处用 in() 进行批量删除时只能采用 ${} 
       -->
      delete from t_user where id in(${ids})
  </delete>

• 测试

  @Test
  public void testDeleteMoreUser() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      SpecialSQLMapper mapper = sqlSession.getMapper(SpecialSQLMapper.class);
  
      mapper.deleteMoreUser("9, 10");
  }

8.3 动态设置表名

**只能使用 ${}**，因为表名不能加单引号

• 在 mapper 接口里编写方法

  /**
   * 动态设置表名, 查询对应表当前所有用户信息
   * @param tableName 表名
   * @return 返回存放 当前表每条信息转换成的 User对象 的 list 集合
   */
  List<User> getUserList(@Param("tableName") String tableName);

• 在映射文件里写 sql 语句

  <!-- List<User> getUserList(@Param("tableName") String tableName); -->
  <select id="getUserList" resultType="User">
      <!-- 注意！表名是不能加单引号的, 所以直接用 #{} 会报错！
               所有该处动态设置表名时只能使用 ${}
       -->
      select * from ${tableName}
  </select>

• 测试

  @Test
  public void testGetUserList() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      SpecialSQLMapper mapper = sqlSession.getMapper(SpecialSQLMapper.class);
  
      List<User> list = mapper.getUserList("t_user");
      list.forEach(System.out::println);
  }

8.4 添加功能获取自增的主键(常用！难理解)

也就是说，这个insertUser方法的目的是为了实现添加一个数据，并且获取他的自增列然后把jdbc自增列的值赋给我们实体类对应的属性

注意看，最后的user不是查出来的，是传进数据库操作的对象，user的id值在进行xml操作时，被赋了值

其实就一个功能 你没设置前在控制台看不到 id 多少 但是数据库已经自动设置好了，设置后能在控制台看到

实际上就是添加了一个数据并在 id 上回显添加成功的这次 id

场景模拟：假设现在有两张表：

t_clazz(clazz_id,clazz_name) 学生表

t_student(student_id,student_name,clazz_id) 班级表

需求：在添加班级信息的同时为班级分配学生(需要在多的一方设置主键，即在学生里面设置班级的 id)

1、添加班级信息

2、获取新添加的班级的 id

3、为班级分配学生，即将某学生的班级 id 修改为新添加的班级的 id

• 在 mapper 接口里编写方法

  /**
   * 添加用户信息并获取自增的主键
   * @param user User 对象
   * useGeneratedKeys: 设置使用自增的主键
   * keyProperty: 因为增删改有统一的返回值(是受影响的行数),
   *             因此只能将获取的自增的主键放在传输的参数 user 对象的某个属性中
   */
  void insertUser(User user);

• 在映射文件里写 sql 语句

  <!-- void insertUser(User user); -->
  <insert id="insertUser" useGeneratedKeys="true" keyProperty="id">
      <!--
              useGeneratedKeys: 表示当前的添加功能使用了自增的主键
              keyProperty: 将添加的数据的自增主键为实体类类型的参数的属性赋值
       -->
      insert into t_user values(null, #{username}, #{password}, #{age}, #{gender}, #{email})
  </insert>

• 测试

  @Test
  public void testInsertUser() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      SpecialSQLMapper mapper = sqlSession.getMapper(SpecialSQLMapper.class);
  
      User user = new User(null, "xiaoming", "123456", 23, "男", "123@qq.com");
      mapper.insertUser(user);
      System.out.println(user);
  }

9. 自定义映射 resultMap

9.0 准备工作

• 创建一个新模块

  

• 将原先的 jdbc 配置文件、log4j 文件和 util 类复制过来，再创建包、核心配置文件等(搭建 MyBatis 框架)

  

• 创建员工表和部门表

  员工 和 部门 是 多对一 的关系

  在多的一方，即员工表中添上部门的 id 这一字段

  

  

• 添加一些测试数据

  

  

• 创建 主体类(包含有参无参构造、getter和setter、toString方法) 和 mapper 接口

  此处的 Emp 中 缺少 dept_id 字段对应的属性

  并且注意此处 Emp 类中与 emp_id 和 emp_name 字段名对应的属性名是 empId 和 empName（一个是下划线，一个是驼峰式命名，导致字段和属性名不一致）

  

9.1 resultMap 处理字段和属性的映射关系(字段和属性名不一致)

 若字段名和属性名不一致，则查询的结果中，属性名和字段名不一致的属性值为 null

（1）解决方法一：在 SQL 语句中起别名

• 在 mapper 接口里编写方法

  package com.thr.mybatis.mapper;
  
  public interface EmpMapper {
      /**
       * 根据 id 查询员工信息
       * @param empId 员工 id
       * @return 返回一个 Emp 对象
       */
      Emp getEmpByEmpId(@Param("empId") Integer empId);
  }

• 在映射文件里写 sql 语句

  <!-- Emp getEmpByEmpId(@Param("empId") Integer empId); -->
      <select id="getEmpByEmpId" resultType="Emp">
          <!-- 1. 在 SQL 语句中起别名(不用 select * , 而是用 select 具体的字段) -->
          select emp_id empId, emp_name empName, age, gender from t_emp where emp_id = #{empId}
  </select>

• 测试

  @Test
  public void testGetEmpByEmpId() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
  
      Emp emp = mapper.getEmpByEmpId(1);
      System.out.println(emp);
  }

（2）解决方法二：在核心配置文件的 settings 标签设置全局配置

• 在 官方文档里头找到并复制到核心配置文件中

  注意核心配置文件里的标签顺序：properties?,settings?,typeAliases?….

  可以把这块代码直接放在 模板文件 里头

  

  <settings>
      <!-- 自动将下划线映射为驼峰 -->
      <setting name="mapUnderscoreToCamelCase" value="true"/>
  </settings>

• 在映射文件里写 sql 语句

  <!-- Emp getEmpByEmpId(@Param("empId") Integer empId); -->
      <select id="getEmpByEmpId" resultType="Emp">
          <!-- 2. 在核心配置文件的 settings 标签设置全局配置 -->
          select * from t_emp where emp_id = #{empId}
      </select>

（3）解决方法三：使用 resultMap 自定义映射处理

• 在映射文件里写 sql 语句

  <!-- 3. 使用 resultMap 自定义映射处理(编写自定义映射)
              id: 唯一标识
              type: 处理映射关系的实体类类型
              常用的标签:
                  id: 处理主键和实体类中属性的映射关系
                  result: 处理普通字段和实体类中属性的映射
              标签里头的属性:
                  column: 设置映射关系中的字段名, 必须是 sql 查询出的某个字段
                  property: 设置映射关系中的属性的属性名, 必须是实体类类型中的属性名
  -->
  <resultMap id="empResultMap" type="Emp">
      <id column="emp_id" property="empId"></id>
      <result column="emp_name" property="empName"></result>
      <result column="age" property="age"></result>
      <result column="gender" property="gender"></result>
  </resultMap>
  
  <!-- Emp getEmpByEmpId(@Param("empId") Integer empId); -->
  <select id="getEmpByEmpId" resultMap="empResultMap">
      select * from t_emp where emp_id = #{empId}
  </select>

9.2 多对一映射处理

场景模拟：查询员工信息以及员工所对应的部门信息

首先在 Emp 类添加 private Dept dept; 属性

在 员工Emp类 中设置 部门Dept类型 的属性，表示当前所对应的员工的部门(一是对象，多是集合，多对一则在”多“的类中创建”一“的类型的属性)，同时添加 getter and setter 并重写 toString 方法

就是通过一个sql查询emp，要把里面的dept属性赋值的问题

2. 处理多对一的映射关系(就是通过一个sql查询emp，要把里面的dept属性赋值的问题)
   下面的方法都用的是 resultMap !!
   2.1 级联方式处理
   2.2 association 标签(javaType: 设置要处理的属性的类型)
   处理多对一(或一对一)的映射关系(实际是处理实体类类型的属性)
   2.3 分步查询(先查员工, 查完员工后知道员工所对应的部门 id,
   再把部门 id 作为条件去部门表里查部门信息, 查询的结果再赋值给 emp类 里头的 dept对象)
   (相当于用第一步结果中的 dept_id 这个结果作为第二部查询的条件)

（1）级联方式处理映射关系

• 在 mapper 接口里编写方法

  /**
   * 获取员工以及所对应的部门信息
   * @param empId 员工 id
   * @return 返回一个 Emp 对象
   */
  Emp getEmpAndDeptByEmpId(@Param("empId") Integer empId);

• 在映射文件里写 sql 语句

  <!-- 2.1 级联(将 emp类 中的属性(对象类型的属性)的属性映射到字段)-->
  <resultMap id="empAndDeptResultMapOne" type="Emp">
      <id column="emp_id" property="empId"></id>
      <result column="emp_name" property="empName"></result>
      <result column="age" property="age"></result>
      <result column="gender" property="gender"></result>
      <result column="dept_id" property="dept.deptId"></result>
      <result column="dept_name" property="dept.deptName"></result>
  </resultMap>
  
  <!-- Emp getEmpAndDeptByEmpId(@Param("empId") Integer empId); -->
  <select id="getEmpAndDeptByEmpId" resultMap="empAndDeptResultMapOne">
      <!-- 多表查询(该处采用左外连接, 查询所有员工及其部门, 如部门为空, 显示 null) -->
      select t_emp.*, t_dept.*
      from t_emp left join t_dept
      on t_emp.dept_id = t_dept.dept_id
      where t_emp.emp_id = #{empId}
  </select>

• 测试

  @Test
  public void testGetEmpAndDeptByEmpId() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
  
      Emp emp = mapper.getEmpAndDeptByEmpId(1);
      System.out.println(emp);
  }

（2）使用 association 处理映射关系

• 在映射文件里写 sql 语句

  <!-- 2.2 association 标签 -->
  <resultMap id="empAndDeptResultMap" type="Emp">
      <id column="emp_id" property="empId"></id>
      <result column="emp_name" property="empName"></result>
      <result column="age" property="age"></result>
      <result column="gender" property="gender"></result>
      <!--
              association 标签: 处理多对一(或一对一)的映射关系(实际是处理实体类类型的属性)
              该标签里头的属性:
                  property: 设置需要处理映射关系的属性的属性名
                  javaType: 设置要处理的属性的类型
       -->
      <association property="dept" javaType="Dept">
          <id column="dept_id" property="deptId"></id>
          <result column="dept_name" property="deptName"></result>
      </association>
  </resultMap>

（3）分步查询

•  在 EmpMapper 接口添加分步查询的第一步

  /**
   * 通过分步查询获取员工以及所对应的部门信息的第一步
   * 分步查询第一步：查询员工信息
   * @param empId 员工 id
   * @return 返回一个 Emp 对象
   */
  Emp getEmpAndDeptByStepOne(@Param("empId") Integer empId);

• 再创建一个 DeptMapper 接口添加分步查询的第二步

  package com.thr.mybatis.mapper;
  
  // 查哪张表就写在其对应的接口中
  public interface DeptMapper {
      /**
       * 通过分步查询获取员工以及所对应的部门信息的第二步
       * @param deptId 在第一步查询到的员工信息里的部门 id
       * @return 返回一个 部门Dept类 对象
       */
      Dept getEmpAndDeptByStepTwo(@Param("deptId") Integer deptId);
  }

• 在 映射文件中添加 SQL 语句及 resultMap

  获取方法的唯一标识：

  

  <!-- 2.3 分步查询 -->
  <resultMap id="empAndDeptByStepResultMap" type="Emp">
      <id column="emp_id" property="empId"></id>
      <result column="emp_name" property="empName"></result>
      <result column="age" property="age"></result>
      <result column="gender" property="gender"></result>
      <!--
              property: 设置需要处理映射关系的属性的属性名
              select: 设置分步查询的 sql 的唯一标识(mapper 接口的全类名 + 查询语句的 id)
              column: 将查询出的某个字段作为分步查询的 sql 的条件
      -->
      <association property="dept"
                   select="com.thr.mybatis.mapper.DeptMapper.getEmpAndDeptByStepTwo"
                   column="dept_id"></association>
  </resultMap>
  
  <!-- Emp getEmpAndDeptByStepOne(@Param("empId") Integer empId); -->
  <select id="getEmpAndDeptByStepOne" resultMap="empAndDeptByStepResultMap">
      select * from t_emp where emp_id = #{empId}
  </select>

  <mapper namespace="com.thr.mybatis.mapper.DeptMapper">
      <!-- Dept getEmpAndDeptByStepTwo(@Param("deptId") Integer deptId); -->
      <select id="getEmpAndDeptByStepTwo" resultType="Dept">
          select * from t_dept where dept_id = #{deptId}
      </select>
  </mapper>

• 测试

  @Test
  public void testGetEmpAndDeptByStep() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
  
      Emp emp = mapper.getEmpAndDeptByStepOne(2);
      System.out.println(emp);
  }

（4）分步查询的优点：延迟加载(懒加载)

分步查询的优点：可以实现延迟加载

但是必须在核心配置文件中设置全局配置信息(在 settings 标签中进行设置)：

lazyLoadingEnabled：延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。这里需要设置为 true

aggressiveLazyLoading：当开启时，任何方法的调用都会加载该对象的所有属性。 否则，每个属性会按需加载。这里需要设置为 false(mybatis 版本小于等于3.4.1时，默认为 true，其他版本默认为 false，所以高版本可以不用设置)

此时就可以实现按需加载，获取的数据是什么，就只会执行相应的sql。此时可通过 association 和 collection 中的fetchType 属性设置当前的分步查询是否使用延迟加载，fetchType=”lazy(延迟加载)|eager(立即加载)”

延迟加载就是我需要分步加载中的哪一步就只执行哪一步

<settings>
    <!-- 自动将下划线映射为驼峰 -->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
    <!-- 开启延迟加载 -->
    <setting name="lazyLoadingEnabled" value="true"/>
    <!-- 按需加载 -->
    <setting name="aggressiveLazyLoading" value="false"/>
</settings>

9.3 一对多映射处理

一个部门里有多个员工（对多对应集合）

需求：查询部门信息并把当前部门中的所有员工也查出来

在 Dept 类中添加属性 private List<Emp> emps;

3. 处理一对多的映射关系
	3.1 collection -> 处理一对多或者多对多的映射关系(处理集合类型的属性)
		ofType: 设置当前集合中的属性
	3.2 分步查询

（1）collection

• 在 DeptMapper 接口中添加方法

  /**
   * 查询部门以及部门中的员工信息
   * @param deptId 部门 id
   * @return 返回一个部门对象
   */
  Dept getDeptAndEmpByDeptId(@Param("deptId") Integer deptId);

• 在 DeptMapper 映射文件中写 sql 语句

  <!-- 3.1 collection 标签(处理一对多或者多对多的映射关系(处理集合类型的属性)) -->
  <resultMap id="DeptAndEmpResultMap" type="Dept">
      <id column="dept_id" property="deptId"></id>
      <result column="dept_name" property="deptName"></result>
      <!--
              ofType: 设置集合类型的属性中存储的数据的类型
      -->
      <collection property="emps" ofType="Emp">
          <id column="emp_id" property="empId"></id>
          <result column="emp_name" property="empName"></result>
          <result column="age" property="age"></result>
          <result column="gender" property="gender"></result>
      </collection>
  </resultMap>
  
  <!-- Dept getDeptAndEmpByDeptId(@Param("deptId") Integer deptId); -->
  <select id="getDeptAndEmpByDeptId" resultMap="DeptAndEmpResultMap">
      select *
      from t_dept left join t_emp
      on t_dept.dept_id = t_emp.dept_id
      where t_dept.dept_id = #{deptId}
  </select>

• 测试

  @Test
  public void testGetDeptAndAEmpByDeptId() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);
  
      Dept dept = mapper.getDeptAndEmpByDeptId(1);
      System.out.println(dept);
      /* 运行结果
          Dept{deptId=1, deptName='A', emps=[
                  Emp{empId=1, empName='张三', age=20, gender='男', dept=null},
                  Emp{empId=4, empName='赵六', age=24, gender='男', dept=null}
                  ]
              }
       */
  }

（2）分步查询

• 在 DeptMapper 接口中添加方法

  /**
   * 通过分步查询查询部门以及部门中的员工信息第一步(一对多)
   * @param deptId 部门 id
   * @return 返回一个部门对象
   */
  Dept getDeptAndEmpByStepOne(@Param("deptId") Integer deptId);

• 在 EmpMapper 接口中添加方法

  /**
   * 通过分步查询查询部门以及部门中的员工信息第二步(一对多)
   * @param deptId 部门 id
   * @return 返回一个包含 Emp 对象的 List 集合
   */
  List<Emp> getDeptAndEmpByStepTwo(@Param("deptId") Integer deptId);

• 在 映射文件中添加 SQL 语句及 resultMap

  <!-- 3.2 分步查询第一步 -->
  <resultMap id="deptAndEmpResultMapByStep" type="Dept">
      <id column="dept_id" property="deptId"></id>
      <result column="dept_name" property="deptName"></result>
      <collection property="emps"
                  select="com.thr.mybatis.mapper.EmpMapper.getDeptAndEmpByStepTwo"
                  column="dept_id">
      </collection>
  </resultMap>
  
  <!-- Dept getDeptAndEmpByStepOne(@Param("deptId") Integer deptId); -->
  <select id="getDeptAndEmpByStepOne" resultMap="deptAndEmpResultMapByStep">
      select * from t_dept where dept_id = #{deptId}
  </select>

  <!-- 3.2 分步查询第二步 -->
  <!-- List<Emp> getDeptAndEmpByStepTwo(@Param("deptId") Integer deptId); -->
  <select id="getDeptAndEmpByStepTwo" resultType="Emp">
      select * from t_emp where dept_id = #{deptId}
  </select>

• 测试

  @Test
  public void testGetDeptAndAEmpByStep() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);
  
      Dept dept = mapper.getDeptAndEmpByStepOne(1);
      System.out.println(dept);
      System.out.println(dept.getDeptName());
  }

10. 动态 SQL

MyBatis 框架的 动态SQL 技术是一种根据特定条件动态拼装SQL语句的功能，它存在的意义是为了解决拼接SQL语句字符串时的痛点问题

比如说根据图书编号，图书名，作者查询，只填一个，或者两个，或者三个，如果填了就添加在 sql 语句中，没填就不用(动态 sql)

不是 null 或者 空字符串 就进行拼接，是 null 或者 空字符串 就不拼接

若都是空，需求一般就是要打印所有记录信息的

• 创建新的工程，设置好配置文件啥的

  

10.1 if

if标签可通过 test 属性（即传递过来的数据）的表达式进行判断，若表达式的结果为true，则标签中的内容会执行；反之标签中的内容不会执行

if: 通过 test 属性中的表达式判断标签中的内容是否有效(是否会拼接到 sql 中)

• 在 mapper 接口中添加方法

  /**
   * 根据条件查询员工信息(多条件查询)
   * @param emp 一个员工对象
   * @return 返回 list 集合(因为不确定有几条返回值)
   */
  List<Emp> getEmpByCondition(Emp emp);

• 在 映射文件中添加 SQL 语句

  <!-- List<Emp> getEmpByCondition(Emp emp); -->
  <!-- 1. if 标签 -->
  <select id="getEmpByCondition" resultType="Emp">
      select * from t_emp where
      <if test="empName != null and empName != ''">
          emp_name = #{empName}
      </if>
      <if test="age != null and age != ''">
          and age = #{age}
      </if>
      <if test="gender != null and gender != ''">
          and gender = #{gender}
      </if>
  </select>

• 测试

  @Test
  public void testGetEmpByCondition() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
  
      Emp emp = new Emp(null, "张三", 20, "男");
      List<Emp> list = mapper.getEmpByCondition(emp);
      list.forEach(System.out::println);
  }

10.2 where

为了解决后面条件不成立导致 sql 语句多出来的 where 的问题，一种方法是在 where 后头加上 ”1=1“ 的恒成立条件，再将后头判断语句的前面都加上 ”and“ 即可，另一种方法是使用 where 标签

where 和 if一般结合使用：

• 若 where 标签中的 if 条件都不满足，则where标签没有任何功能，即不会添加where关键字
• 若 where 标签中的 if 条件满足，则where标签会自动添加 where 关键字，并将条件最前方多余的 and 和 or 去掉

注意：where标签不能去掉条件最后多余的and

• 映射文件里的 sql 语句

  <!-- List<Emp> getEmpByCondition(Emp emp); -->
  <!-- 2. where 标签 -->
  <select id="getEmpByCondition" resultType="Emp">
      select * from t_emp
      <where>
          <if test="empName != null and empName != ''">
              emp_name = #{empName}
          </if>
          <if test="age != null and age != ''">
              and age = #{age}
          </if>
          <if test="gender != null and gender != ''">
              and gender = #{gender}
          </if>
      </where>
  </select>

10.3 trim

trim 用于去掉或添加标签中的内容

常用属性:

prefix：在trim标签中的内容的前面添加某些内容

suffix：在trim标签中的内容的后面添加某些内容

prefixOverrides：在trim标签中的内容的前面去掉某些内容

suffixOverrides：在trim标签中的内容的后面去掉某些内容

• 映射文件里的 sql 语句

  <!-- List<Emp> getEmpByCondition(Emp emp); -->
  <!-- 3. trim 标签 -->
  <select id="getEmpByCondition" resultType="Emp">
      select * from t_emp
      <trim prefix="where" suffixOverrides="and">
          <if test="empName != null and empName != ''">
              emp_name = #{empName} and
          </if>
          <if test="age != null and age != ''">
              age = #{age} and
          </if>
          <if test="gender != null and gender != ''">
              gender = #{gender}
          </if>
      </trim>
  </select>

10.4 choose、when、otherwise

choose、when、otherwise 相当于 if …… else if …… else …… 一个成立后面便不再执行, 所以也不用加 and

因此 where 后头最多只能加一个条件, 不能多条件查询了

when(表示 if..elif) 至少设置一个, otherwise(表示 else) 最多设置一个

• 在 mapper 接口中添加方法

  /**
   * 使用 choose 查询员工信息
   * @param emp 一个员工对象
   * @return 返回 list 集合(因为不确定有几条返回值)
   */
  List<Emp> getEmpByChoose(Emp emp);

• 在 映射文件中添加 SQL 语句

  <!-- List<Emp> getEmpByChoose(Emp emp); -->
  <!-- 4. choose, when, otherwise 标签 -->
  <select id="getEmpByChoose" resultType="Emp">
      select * from t_emp
      <where>
          <choose>
              <when test="empName != null and empName != ''">
                  emp_name = #{empName}
              </when>
              <when test="age != null and age != ''">
                  age = #{age}
              </when>
              <when test="gender != null and gender != ''">
                  gender = #{gender}
              </when>
          </choose>
      </where>
  </select>

10.5 foreach(重要)

foreach: 循环执行该标签里头的内容, 其具体属性有:
collection: 设置要循环的数组或集合
item: 用一个字符串来表示数组或集合中的每一个数据
separator: 设置每次循环的数据之间的分隔符
open: 循环的所有内容以什么开始
close: 循环的所有内容以什么结束

（1）批量添加

• 在 mapper 接口中添加方法

  /**
    * 批量添加员工信息
    * @param emps 存放 Emp对象的集合
    */
  void insertMoreEmp(@Param("emps") List<Emp> emps);

• 在 映射文件中添加 SQL 语句

  <!-- void insertMoreEmp(@Param("emps") List<Emp> emps); -->
  <!-- 5.1 foreach 批量添加 -->
  <select id="insertMoreEmp">
      insert into t_emp values
      <foreach collection="emps" item="emp" separator=",">
          (null, #{emp.empName}, #{emp.age}, #{emp.gender}, null)
      </foreach>
  </select>

• 测试

  @Test
  public void testInsertMoreEmp() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
  
      Emp emp1 = new Emp(null, "小明1", 20, "男");
      Emp emp2 = new Emp(null, "小明2", 20, "男");
      Emp emp3 = new Emp(null, "小明3", 20, "男");
      List<Emp> list = Arrays.asList(emp1, emp2, emp3);
      mapper.insertMoreEmp(list);
  }

（2）批量删除

• 在 mapper 接口中添加方法

  /**
   * 批量删除用户信息
   * @param empIds 存放 用户id 的数组
   */
  void deleteMoreEmp(@Param("empIds") Integer[] empIds);

• 在 映射文件中添加 SQL 语句

  此处删除可用两种方法

  • where id in(???)
  • where or…or…

  <!-- void deleteMoreEmp(@Param("empIds") Integer[] empIds); -->
  <!-- 5.2 foreach 批量删除 -->
  <select id="deleteMoreEmp">
      <!-- 5.2.1 用 where..in(?,?,?) -->
      <!--delete from t_emp where emp_id in
          <foreach collection="empIds" item="empId" separator="," open="(" close=")">
               #{empId}
          </foreach>-->
  
      <!-- 5.2.1 用 where...or... -->
      delete from t_emp where
      <foreach collection="empIds" item="empId" separator="or">
          emp_id = #{empId}
      </foreach>
  </select>

• 测试

  @Test
  public void testDeleteMoreEmp() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      DynamicSQLMapper mapper = sqlSession.getMapper(DynamicSQLMapper.class);
  
      Integer[] empIds = new Integer[]{6, 7};
      mapper.deleteMoreEmp(empIds);
  }

10.6 SQL 片段

select * 少用，数据多了的话查询效率特低，因为查询的时候会先把查询成所有字段，所以建议写全，写全以后又很麻烦，*直接用sql标签，然后引用，减少代码冗余

sql片段，可以记录一段公共sql片段，在使用的地方通过 include 标签进行引入

• 声明 sql 片段

  <sql id="empColumns">
      emp_id, emp_name, age, gender, dept_id
  </sql>

• 引用 sql 片段

  select <include refid="empColumns"></include> from t_emp

11. MyBatis 的缓存

• 创建新的工程

  

11.1 MyBatis 的一级缓存

一级缓存是默认开启的，且是 SqlSession 级别的，也就是通过同一个 SqlSession 查询的数据会被缓存，下次查询相同的数据，就会从缓存中直接获取，不会从数据库重新访问

使一级缓存失效的四种情况：

1）不同的 SqlSession 对应不同的一级缓存

2）同一个 SqlSession 但是查询条件不同

3）同一个 SqlSession 两次查询期间执行了任何一次增删改操作(因为任意一次增删改执行完后会自动清空缓存)

4）同一个 SqlSession 两次查询期间手动清空了缓存（清空缓存可以使用）

• 在 mapper 接口中添加方法

  /**
   * 根据员工 id 查询员工信息
   * @param empId 员工 id
   * @return 返回一个 Emp 对象
   */
  Emp getEmpById(@Param("empId") Integer empId);

• 在 映射文件中添加 SQL 语句

  <!-- Emp getEmpById(@Param("empId") Integer empId); -->
  <select id="getEmpById" resultType="Emp">
      select * from t_emp where emp_id = #{empId}
  </select>

• 测试

  @Test
  public void testGetEmpById() {
      /*
              MyBatis的一级缓存: (默认开启)
              sqlSession 级别的, 即通过同一个 sqlSession 查询出来的数据会被缓存
              再次使用同一个 sqlSession 查询同一条数据, 会从缓存中获取
       */
      // 第一个 sqlSession
      SqlSession sqlSession1 = SqlSessionUtil.getSqlSession();
      CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
  
      Emp emp1 = mapper1.getEmpById(1);
      System.out.println(emp1);
      
      // 手动清空一级缓存, 会使一级缓存失效
      // sqlSession1.clearCache();
  
      // 查询相同的数据, 从运行结果可以看出只执行了一次 sql, 返回了两条数据
      // 故 emp1 是从数据库里头查的, emp2 是从缓存里查的
      Emp emp2 = mapper1.getEmpById(1);
      System.out.println(emp2);
  
      // 第二个 sqlSession
      SqlSession sqlSession2 = SqlSessionUtil.getSqlSession();
      CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
  
      // emp3 会再次从数据库里头查, 因为与上头那个不是同一个 sqlSession
      Emp emp3 = mapper2.getEmpById(1);
      System.out.println(emp3);
  }

11.2 MyBatis 的二级缓存

二级缓存是 SqlSessionFactory 级别，通过同一个SqlSessionFactory 创建的 SqlSession 查询的结果会被缓存；此后若再次执行相同的查询语句，结果就会从缓存中获取

二级缓存开启的条件：

• 在核心配置文件中，设置全局配置属性cacheEnabled=”true”，默认为true，不需要设置
• 在映射文件中设置标签 <cache />
• 二级缓存必须在SqlSession关闭或提交之后有效
• 查询的数据所转换的实体类类型必须实现序列化 Serializable 的接口

使二级缓存失效的情况：两次查询之间执行了任意的增删改，会使一级和二级缓存同时失效

• 查询的数据所转换的实体类类型实现序列化接口

  public class Emp implements Serializable {...}

• 测试

  @Test
  public void testCache() throws IOException {
      // 测试二级缓存, 故不能直接用工具类, 需要重新获取一个 SqlSessionFactory
      InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
      SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(is);
  
      // 由同一个 sqlSessionFactory 得到的 sqlSession1 和 sqlSession2
      SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
      CacheMapper mapper1 = sqlSession1.getMapper(CacheMapper.class);
      Emp emp1 = mapper1.getEmpById(1);
      System.out.println(emp1);
  
      // 二级缓存必须在 SqlSession 关闭或提交之后有效(关闭后, 保存在一级缓存中的数据才会被保存到二级缓存中)
      sqlSession1.close();
  
      SqlSession sqlSession2 = sqlSessionFactory.openSession(true);
      CacheMapper mapper2 = sqlSession2.getMapper(CacheMapper.class);
      Emp emp2 = mapper2.getEmpById(1);
      System.out.println(emp2);
  
      sqlSession2.close();
  }

11.3 二级缓存的相关配置

cache 标签的相关属性：

• eviction属性：缓存回收策略

LRU（Least Recently Used） – 最近最少使用的：移除最长时间不被使用的对象。

FIFO（First in First out） – 先进先出：按对象进入缓存的顺序来移除它们。

SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。

WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象。

默认的是 LRU

• flushInterval属性：刷新间隔，单位毫秒

默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句（增删改）时刷新

• size属性：引用数目，正整数

代表缓存最多可以存储多少个对象，太大容易导致内存溢出

• readOnly属性：只读，true/false

true：只读缓存；会给所有调用者返回缓存对象的相同实例(将缓存的数据直接返回给调用者)。因此这些对象不能被修改。这提供了很重要的性能优势。

false：读写缓存；会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是false

11.4 MyBatis 缓存查询的顺序

从大范围查到小范围，二级缓存是SqlSessionFactory 范围更大些

若一级缓存和二级缓存都开启，则先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用

如果二级缓存没有命中，再查询一级缓存(因为可能没关闭，所以一级里头可能有二级没有的)

二级缓存是要session提交后的数据，而一级缓存里面的数据不一定提交了

如果一级缓存也没有命中，则查询数据库

SqlSession关闭之前，数据默认保存在一级缓存之中，但SqlSession关闭之后，一级缓存中的数据会写入二级缓存

11.5 整合第三方缓存 EHCache(了解即可)

（1）添加依赖

<!-- Mybatis EHCache整合包 -->
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.2.1</version>
</dependency>

<!-- slf4j日志门面的一个具体实现 -->
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>

（2）各 jar 包功能

jar 包名称	作用
mybatis-ehcache	Mybatis和EHCache的整合包
ehcache	EHCache核心包
slf4j-api	SLF4J日志门面包
logback-classic	支持SLF4J门面接口的一个具体实现

（3）创建 EHCache 的配置文件 ehcache.xml (名字必须为 ehcache.xml)

爆红不用管，能实现功能就行

<?xml version="1.0" encoding="utf-8" ?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
    <!-- 磁盘保存路径 -->
    <diskStore path="D:\ehcache"/>
 
    <!-- 设置缓存的信息 -->
    <defaultCache
            maxElementsInMemory="1000"
            maxElementsOnDisk="10000000"
            eternal="false"
            overflowToDisk="true"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            diskExpiryThreadIntervalSeconds="120"
            memoryStoreEvictionPolicy="LRU">
    </defaultCache>
</ehcache>

（4）设置二级缓存的类型

在xxxMapper.xml文件中设置二级缓存类型

例如，在 CacheMapper.xml 中设置

<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

（5）加入 logback 日志

存在SLF4J时，作为简易日志的log4j将失效，此时我们需要借助SLF4J的具体实现logback来打印日志。

创建logback的配置文件 logback.xml，名字固定，不可改变

<?xml version="1.0" encoding="UTF-8"?>
<configuration debug="true">
    <!-- 指定日志输出的位置 -->
    <appender name="STDOUT"
              class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <!-- 日志输出的格式 -->
            <!-- 按照顺序分别是：时间、日志级别、线程名称、打印日志的类、日志主体内容、换行 -->
            <pattern>[%d{HH:mm:ss.SSS}] [%-5level] [%thread] [%logger] [%msg]%n</pattern>
        </encoder>
    </appender>

    <!-- 设置全局日志级别。日志级别按顺序分别是：DEBUG、INFO、WARN、ERROR -->
    <!-- 指定任何一个日志级别都只打印当前级别和后面级别的日志。 -->
    <root level="DEBUG">
        <!-- 指定打印日志的appender，这里通过“STDOUT”引用了前面配置的appender -->
        <appender-ref ref="STDOUT" />
    </root>
    <!-- 根据特殊需求指定局部日志级别 -->
    <logger name="com.thr.mybatis.mapper" level="DEBUG"/>
</configuration>

12. MyBatis 的逆向工程

正向工程：先创建Java实体类，由框架负责根据实体类生成数据库表。Hibernate是支持正向工程的

逆向工程(本质是代码生成器)：先创建数据库表，由框架负责根据数据库表，反向生成如下资源：

• Java实体类
• Mapper接口
• Mapper映射文件

逆向工程时，如果出现生成的实体类总是错误，属性命名没有根据命名规则来，甚至出现了在表中没有的属性：

可以尝试在数据库连接的 URL 后面加上  nullCatalogMeansCurrent=true

12.1 创建逆向工程的步骤(简洁版)

（1）设置打包方式为jar，添加依赖和插件

<packaging>jar</packaging>

<dependencies>
    <!-- MyBatis核心依赖包 -->
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.7</version>
    </dependency>
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
    <!-- MySQL驱动 -->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
    <!-- log4j日志 -->
    <dependency>
        <groupId>log4j</groupId>
        <artifactId>log4j</artifactId>
        <version>1.2.17</version>
    </dependency>
</dependencies>

<!-- 控制Maven在构建过程中相关配置 -->
<build>
    <!-- 构建过程中用到的插件 -->
    <plugins>
        <!-- 具体插件，逆向工程的操作是以构建过程中插件形式出现的 -->
        <plugin>
            <groupId>org.mybatis.generator</groupId>
            <artifactId>mybatis-generator-maven-plugin</artifactId>
            <version>1.3.0</version>
            <!-- 插件的依赖 -->
            <dependencies>
                <!-- 逆向工程的核心依赖 -->
                <dependency>
                    <groupId>org.mybatis.generator</groupId>
                    <artifactId>mybatis-generator-core</artifactId>
                    <version>1.3.2</version>
                </dependency>
                <!-- MySQL驱动 -->
                <dependency>
                    <groupId>mysql</groupId>
                    <artifactId>mysql-connector-java</artifactId>
                    <version>5.1.47</version>
                </dependency>
            </dependencies>
        </plugin>
    </plugins>
</build>

（2）创建 MyBatis 的核心配置文件、逆向工程的配置文件

这里 MyBatis 的核心配置文件 可以先不用填写 typeAliase 和 mappers 的包名，可以等到逆向后再填写

逆向工程的配置文件名字必须是 generatorConfig.xml，上面的 URI 爆红不用管

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE generatorConfiguration
        PUBLIC "-//mybatis.org//DTD MyBatis Generator Configuration 1.0//EN"
        "http://mybatis.org/dtd/mybatis-generator-config_1_0.dtd">
<generatorConfiguration>
    <!--
        targetRuntime: 执行生成的逆向工程的版本
            MyBatis3Simple: 生成基本的CRUD（清新简洁版）
            MyBatis3: 生成带条件的CRUD（奢华尊享版）
    -->
    <context id="DB2Tables" targetRuntime="MyBatis3Simple">
        <!-- 数据库的连接信息 -->
        <jdbcConnection driverClass="com.mysql.jdbc.Driver"
                        connectionURL="jdbc:mysql://localhost:3306/ssm?useSSL=false&amp;
                                       serverTimezone=UTC&amp;useUnicode=true&amp;characterEncoding=UTF-8"
                        userId="root"
                        password="thr">
        </jdbcConnection>

        <!-- javaBean的生成策略-->
        <javaModelGenerator targetPackage="com.thr.mybatis.pojo" targetProject=".\src\main\java">
            <!--
                enableSubPackages：设置是否能用子包
                    true：targetPackage属性中每一个点对应一层包(目录)
                    false：targetPackage中的名字只作为一层包(目录)
            -->
            <property name="enableSubPackages" value="true" />
            <!-- trimStrings：去掉字符串前后的空格 -->
            <property name="trimStrings" value="true" />
        </javaModelGenerator>

        <!-- SQL映射文件的生成策略 -->
        <sqlMapGenerator targetPackage="com.thr.mybatis.mapper"
                         targetProject=".\src\main\resources">
            <property name="enableSubPackages" value="true" />
        </sqlMapGenerator>

        <!-- Mapper接口的生成策略 -->
        <javaClientGenerator type="XMLMAPPER" targetPackage="com.thr.mybatis.mapper" targetProject=".\src\main\java">
            <property name="enableSubPackages" value="true" />
        </javaClientGenerator>

        <!-- 逆向分析的表 -->
        <!-- tableName：设置表名，若设置为*号，可以对应所有表，此时不写domainObjectName -->
        <!-- domainObjectName：设置生成出来的实体类的类名 -->
        <table tableName="t_emp" domainObjectName="Emp"/>
        <table tableName="t_dept" domainObjectName="Dept"/>
    </context>
</generatorConfiguration>

（3）执行 MBG 插件的 generate 目标(双击即可)

执行后，就会在对应位置生成实体类和 xml 文件

之后注意完善核心配置文件 mybatis-config.xml

将 typeAliases 和 mappers 标签对应的包名填上

12.2 逆向工程 MyBatis3 生成的方法说明(奢华版)

1、只要方法中有 Example，那就是根据条件来查询，例如 countByExample 根据条件查询记录数，deleteByExample 根据条件删除

2、普通插入 int insert(Emp record) 和 选择性插入 int insertSelective(Emp record) 的区别：若传入的方法参数的实体类的某个属性含有 null 值，普通插入会将 null 作为该值赋给对应字段，而选择性插入只会为属性值不是 null 的字段赋值，不会为属性是 null 的字段赋值。当然，由于默认值为 null，所以效果并不明显

3、普通修改和选择性修改的区别：若传入的方法参数的实体类的某个属性含有 null 值，普通修改会将对应字段赋值为 null，而选择性修改只会修改属性不是 null 的对应的字段

• 先将前面自动生成目录等的删除掉，然后在 generatorConfig.xml 文件中将执行生成的逆向工程的版本改成 MyBatis3，再次找到插件双击即可

  <!--
          targetRuntime: 执行生成的逆向工程的版本
              MyBatis3Simple: 生成基本的CRUD（清新简洁版）
              MyBatis3: 生成带条件的CRUD（奢华尊享版）
  -->
  <context id="DB2Tables" targetRuntime="MyBatis3">

  

  效果如下：

  自动生成的Emp类和Dept类是没有 toString 方法和无参有参构造的！建议自己加上去

  

• 测试

  对于单表而言很好用，多表查询还是乖乖的自己写 sql 语句

  @Test
  public void testMBG() {
      SqlSession sqlSession = SqlSessionUtil.getSqlSession();
      EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);
  
      // 1. 根据主键 id 查用户信息
      /*Emp emp = mapper.selectByPrimaryKey(1);
          System.out.println(emp);*/
  
      // 2. 查所有用户信息(放个 null 进去即可)
      /*List<Emp> list = mapper.selectByExample(null);
          list.forEach(System.out::println);*/
  
      // 3. 根据条件查询数据(Query By Criteria: QBC 查询)
      /*EmpExample example = new EmpExample();
          example.createCriteria().andEmpNameEqualTo("张三").andAgeGreaterThanOrEqualTo(20);  // 创建条件对象
          example.or().andGenderEqualTo("男"); // 上一句会和这一句以 or 连接
          List<Emp> list = mapper.selectByExample(example);
          list.forEach(System.out::println);*/
  
      Emp emp = new Emp(1, "小黑", null, "女");
      // 4. 测试普通修改功能(即使给的要修改的属性为 null, 也会把 null 赋值给原来的数据)
      // mapper.updateByPrimaryKey(emp);
  
      // 5. 测试选择性修改功能(如果给的要修改的属性为 null, 其不会更改原来的数据)
      mapper.updateByPrimaryKeySelective(emp);
  }

13. 分页插件

sql 语句实现分页查询：limit index,pageSize

pageSize：每页显示的条数(已知)

pageNum：当前页的页码(已知)

index：当前页的起始索引

由公式：index = (pageNum - 1) * pageSize

eg. 每页 4 条，当前是第 3 页 —> 则 index = 4 * (3 - 1) = 8 —> 此时的 sql 语句：limit 8,4

count：当前的总记录数

totalPage：总页数

totalPage = count / pageSize;
if (count % pageSize != 0) {
    totalPage += 1；
}

13.1 分页插件的使用步骤

（1）添加依赖

<!-- https://mvnrepository.com/artifact/com.github.pagehelper/pagehelper -->
<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper</artifactId>
	<version>5.2.0</version>
</dependency>

（2）配置分页插件

在 MyBatis 的核心配置文件（mybatis-config.xml）中配置插件，注意位置在 typeAliases 和 environments 标签之间

<plugins>
	<!--配置分页插件-->
	<plugin interceptor="com.github.pagehelper.PageInterceptor"></plugin>
</plugins>

（3）测试分页功能

@Test
// 在查询功能里头实现分页
public void testPage() {
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);

    // 在查询功能之前开启分页功能(此处表示查询第一页, 每页展示 4 条数据)
    PageHelper.startPage(1,4);

    // 查询所有数据
    List<Emp> list = mapper.selectByExample(null);
    list.forEach(System.out::println);
}

13.2 分页插件的使用(获取分页相关数据)

（1）通过查询之前 PageHelper.startPage(int pageNum, int pageSize) 获取对应对象并输出

@Test
// 获取分页相关数据(直接通过 page 对象输出)
public void testGetPageData() {
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);

    // 在查询功能之前开启分页功能(此处表示查询第一页, 每页展示 4 条数据)
    Page<Object> page = PageHelper.startPage(1, 4);

    // 查询所有数据
    List<Emp> list = mapper.selectByExample(null);
    list.forEach(System.out::println);
    System.out.println(page);

    /* page 的输出为:
            Page{count=true, pageNum=1, pageSize=4, startRow=0, endRow=4, 
                total=30, pages=8, reasonable=false, pageSizeZero=false}
                [Emp{empId=1, empName='aaa', age=null, gender='null', deptId=null}, 
                 Emp{empId=2, empName='aa', age=null, gender='null', deptId=null}, 
                 Emp{empId=3, empName='a', age=null, gender='null', deptId=null}, 
                 Emp{empId=4, empName='a', age=null, gender='null', deptId=null}]
    */
}

（2）通过获取 PageInfo 对象 获取数据

在查询获取list集合之后，使用PageInfo<T> pageInfo = new PageInfo<>(List<T> list, intnavigatePages) 获取分页相关所有数据，PageInfo 比 Page 获取的数据多些

• list：分页之后的数据
• navigatePages：导航分页的页码数

@Test
// 获取分页相关数据
public void testGetPageInfo() {
    SqlSession sqlSession = SqlSessionUtil.getSqlSession();
    EmpMapper mapper = sqlSession.getMapper(EmpMapper.class);

    // 在查询功能之前开启分页功能(此处表示查询第一页, 每页展示 4 条数据)
    Page<Object> page = PageHelper.startPage(1, 4);

    // 查询所有数据
    List<Emp> list = mapper.selectByExample(null);

    // 查询功能之后可以通过 PageInfo 获取分页相关的所有数据
    PageInfo<Emp> pageInfo = new PageInfo<>(list, 5);
    list.forEach(System.out::println);
    System.out.println(pageInfo);

    /* pageInfo 的输出为: (其中 list 就是上面 page 的内容)
            PageInfo{pageNum=1, pageSize=4, size=4, startRow=1, endRow=4, total=30, pages=8, 
                    list=Page{count=true, pageNum=1, pageSize=4, startRow=0, endRow=4, total=30, 
                        pages=8, reasonable=false, pageSizeZero=false}
                    [Emp{empId=1, empName='aaa', age=null, gender='null', deptId=null}, 
                    Emp{empId=2, empName='aa', age=null, gender='null', deptId=null}, 
                    Emp{empId=3, empName='a', age=null, gender='null', deptId=null}, 
                    Emp{empId=4, empName='a', age=null, gender='null', deptId=null}], 
                    prePage=0, nextPage=2, isFirstPage=true, isLastPage=false, hasPreviousPage=false, 
                    hasNextPage=true, navigatePages=5, navigateFirstPage=1, navigateLastPage=5, 
                    navigatepageNums=[1, 2, 3, 4, 5]}
   */
}

常用数据：

pageNum：当前页的页码

pageSize：每页显示的条数

size：当前页显示的真实条数

total：总记录数

pages：总页数

prePage：上一页的页码

nextPage：下一页的页码

isFirstPage/isLastPage：是否为第一页/最后一页

hasPreviousPage/hasNextPage：是否存在上一页/下一页

navigatePages：导航分页的页码数

navigatepageNums：导航分页的页码，[1,2,3,4,5]