Mybatis课堂笔记

Mybatis-9.28

环境：

• JDK1.8
• Mysql 5.7
• maven 3.6.1
• IDEA

回顾：

• JDBC
• Mysql
• Java基础
• Maven
• Junit

SSM框架：配置文件的。 最好的方式：看官网文档；

1. 简介

1.1 什么是Mybatis

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-a4YFvjJm-1602519093863)(Mybatis课堂笔记.assets/1569633932712.png)]

• MyBatis 是一款优秀的持久层框架
• 它支持定制化 SQL、存储过程以及高级映射。
• MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。
• MyBatis 可以使用简单的 XML 或注解来配置和映射原生类型、接口和 Java 的 POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
• MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了google code，并且改名为MyBatis 。
• 2013年11月迁移到Github。

1.2 如何获得Mybatis？

• maven仓库：

  <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
  <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.2</version>
  </dependency>
  

• 如果要下载到本地仓库的话：

  Github ： https://github.com/mybatis/mybatis-3/releases

• 中文文档：https://mybatis.org/mybatis-3/zh/index.html

1.3 持久化

数据持久化

• 持久化就是将程序的数据在持久状态和瞬时状态转化的过程。
  • 数据库(Jdbc)，io文件持久化。
  • 生活中的持久化：冷藏. 罐头。

• 内存：断电即失

为什么需要需要持久化？

• 有一些对象，不能让他丢掉。

• 内存太贵了

1.4 持久层

Dao层，Service层，Controller层….

• 完成持久化工作的代码块
• 层界限十分明显。

1.5 为什么需要Mybatis？

• 帮助程序员将数据存入到数据库中。
• 方便
• 传统的JDBC代码太复杂了。简化。框架。自动化。
• 不用Mybatis也可以。但学习后更容易上手。 技术没有高低之分
• 优点：
  • 简单易学
  • 灵活：sql写在xml文件中，便于统一管理和优化。
  • sql和代码的分离，提高了可维护性。
  • 提供映射标签，支持对象与数据库的orm字段关系映射
  • 提供对象关系映射标签，支持对象关系组建维护
  • 提供xml标签，支持编写动态sql。

最重要的一点：使用的人多！

Spring SpringMVC SpringBoot

2. 第一个Mybatis程序

思路：搭建环境–>导入Mybatis–>编写代码–>测试！

2.1 搭建环境

1. 搭建数据库

CREATE DATABASE `mybatis`;

USE `mybatis`;

CREATE TABLE `user`(
  `id` INT(20) NOT NULL PRIMARY KEY,
  `name` VARCHAR(30) DEFAULT NULL,
  `pwd` VARCHAR(30) DEFAULT NULL
)ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT INTO `user`(`id`,`name`,`pwd`) VALUES 
(1,'狂神','123456'),
(2,'张三','123456'),
(3,'李四','123890')

2. 新建项目

   1. 新建一个普通的maven项目

   2. 删除src目录

   3. 在pom.xml文件中导入maven依赖

   4. 点击窗口右侧Maven刷新，会自动导入jar包

      如何查看是否成功导入jar包？

      [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-F2r6jyxA-1602519093868)(G:\学习笔记\Mybatis\Mybatis课堂笔记.assets\1.PNG)]

   
       <!--导入依赖-->
       <dependencies>
           <!--mysql驱动-->
           <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
               <version>5.1.6</version>
           </dependency>
           <!--mybatis-->
           <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
           <dependency>
               <groupId>org.mybatis</groupId>
               <artifactId>mybatis</artifactId>
               <version>3.5.2</version>
           </dependency>
           <!--junit-->
           <dependency>
               <groupId>junit</groupId>
               <artifactId>junit</artifactId>
               <version>4.12</version>
           </dependency>
       </dependencies>
   

2.2 编写核心配置文件

• 右键项目 —> New Module —> 不使用骨架创建

  创建后，不需要重复父工程的导入依赖的步骤，就已经依赖那些jar包了

• 编写mybatis的核心配置文件 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核心配置文件 -->
  <configuration>
      <environments default="development">
          <environment id="development">
              <!-- 配置事务管理方式：JDBC/MANAGED
  									JDBC：将事务交给JDBC管理（推荐）
  									MANAGED：自己管理事务
  			  		-->
              <transactionManager type="JDBC"/>
              <!-- 配置数据源，即连接池 JNDI/POOLED/UNPOOLED
  									JNDI：已过时
  									POOLED：使用连接池（推荐）
  									UNPOOLED：不使用连接池
  			 			-->
              <dataSource type="POOLED">
                  <property name="driver" value="com.mysql.jdbc.Driver"/>
                  <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useUnicode=true&amp;characterEncoding=UTF-8"/>
                  <property name="username" value="root"/>
                  <property name="password" value="chenjian123"/>
              </dataSource>
          </environment>
      </environments>
      
  <!-- 每一个Mapper.xml都需要在mybatis核心配置文件中注册！-->
  	<mappers>
      	<mapper resource="Mapper.xml的路径"/>
      </mappers>
  </configuration>
  

• 编写mybatis工具类

  //sqlSessionFactory --> sqlSession
  public class MybatisUtils {
  
      private static SqlSessionFactory sqlSessionFactory;
  
      static{
          try {
              // 读取核心配置文件，其中使用了类加载器
              String resource = "mybatis-config.xml";
              InputStream inputStream = Resources.getResourceAsStream(resource);
              //使用Mybatis第一步：获取sqlSessionFactory对象
              sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
          } catch (IOException e) {
              e.printStackTrace();
          }
  
      }
  
      //既然有了 SqlSessionFactory，顾名思义，我们就可以从中获得 SqlSession 的实例了。
      // SqlSession 完全包含了面向数据库执行 SQL 命令所需的所有方法。
      public static SqlSession  getSqlSession(){
        	// 给与参数true，设置为自动提交事务
          return sqlSessionFactory.openSession(true);
      }
  }
  
  

  读取配置文件的步骤，既没有使用绝对路径，也没有使用相对路径！

  • 绝对路径：d:/xxx/xxx.xml
  • 相对路径：src/java/main/xxx.xml

  以后在项目开发的Java代码关于路径就使用两种方式：

  1. 使用类加载器，它只能读取类路径的配置文件
  2. 使用ServletContext对象的getRealPath()方法

mybatis中的设计模式：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-57rYkiCp-1602519093870)(G:\学习笔记\Mybatis\Mybatis课堂笔记.assets\3.PNG)]

2.3 编写代码

• 实体类

  package com.anuo.pojo;
  
  //实体类
  public class User {
      private int id;
      private String name;
      private String pwd;
  
      public User() {
      }
  
      public User(int id, String name, String pwd) {
          this.id = id;
          this.name = name;
          this.pwd = pwd;
      }
  
      public int getId() {
          return id;
      }
  
      public void setId(int id) {
          this.id = id;
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public String getPwd() {
          return pwd;
      }
  
      public void setPwd(String pwd) {
          this.pwd = pwd;
      }
  
      @Override
      public String toString() {
          return "User{" +
                  "id=" + id +
                  ", name='" + name + '\'' +
                  ", pwd='" + pwd + '\'' +
                  '}';
      }
  }
  
  

• Dao接口

  public interface UserDao {
      List<User> getUserList();
  }
  

• 接口实现类由原来的UserDaoImpl转变为一个 Mapper配置文件.

  可以将这个配置文件看做UserDao接口的实体类

  <?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">
  <!-- 
  	namespace一般指定为当前文件的[所在包路径+文件名（接口名）]
  	在程序中通过[ namespace + id ]定位到执行哪一条SQL语句
   -->
  <mapper namespace="com.anuo.dao.UserDao">
  	<!--select查询语句-->
      <!-- id：UserDao接口中对应查询的方法名 -->
     <select id="getUserList" resultType="com.anuo.pojo.User">
         select * from user;
     </select>
      <!-- 
  		resultType：返回值类型，简单类型（例如：Integer，String，User等）
  								如果返回集合(List<User>)，只需配置集合中的元素类型即可！
  		resultMap：复杂对象结构（例如多表关联查询等），后面用到再讲解
  		parameterType：参数类型，这里如果是集合(List<User>)，也要写集合的类型，例如list
  	 	-->
  </mapper>
  

2.4 测试

2.4.1 junit测试

public class UserDaoTest {
@Test
public void getUserList() {
    // 第一步：获取SqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    // 第二步：执行sql
    // 方式一 getMapper
    // 创建Dao接口的代理对象
    UserDao userDao = sqlSession.getMapper(UserDao.class);
    List<User> userList = userDao.getUserList();
    for (User user : userList) {
        System.out.println(user);
    }
    // 第三步：关闭SqlSession
    sqlSession.close();
}
}

2.4.2 可能会遇到的问题

1. 配置文件没有注册

   • 抛出的异常：org.apache.ibatis.binding.BindingException: Type interface com.anuo.dao.UserDao is not known to the MapperRegistry.

   • MapperRegistry是什么？

     核心配置文件中注册 mappers

   • 解决方案：在mybatis的核心配置文件中注册对应的mappers

   <!-- 每一个Mapper.xml都需要在mybatis核心配置文件中注册！ -->
   <mappers>
       <mapper resource="com/anuo/dao/UserMapper.xml" />
   </mappers>
   

2. 绑定接口不匹配错误；方法名不对；返回类型不对。

   • 这是在接口对应的Mapper配置文件中会产生的错误。

     [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gz9dpBmR-1602519093874)(G:\学习笔记\Mybatis\Mybatis课堂笔记.assets\2.PNG)]

3. 项目运行时，Maven导出资源问题：

   在src/main/java下的配置文件（.xml）无法导出到target的classes目录下。

   • 解决方案：在项目的pom.xml文件中加入以下代码

   <!--在build中配置resources，来防止我们资源导出失败的问题-->
   <build>
     <resources>
       <resource>
         <directory>src/main/resources</directory>
         <includes>
           <include>**/*.properties</include>
           <include>**/*.xml</include>
         </includes>
         <filtering>true</filtering>
       </resource>
       <resource>
         <directory>src/main/java</directory>
         <includes>
           <include>**/*.properties</include>
           <include>**/*.xml</include>
         </includes>
         <filtering>true</filtering>
       </resource>
     </resources>
   </build>
   

   可能会出现导出的xml文件的中文乱码问题：

   解决方案：参考 3. CRUD → 6. 分析错误

3. CRUD

1. namespace

namespace（命名空间）中的包名要和接口的包名一致！

<!-- namespace=绑定一个对应的Dao/Mapper接口 -->
<mapper namespace="com.anuo.dao.UserDao">
   <!-- select查询语句  -->
   <select id="getUserList" resultType="com.anuo.pojo.User">
        select * from mybatis.user
   </select>
</mapper>

2. select

查询语句：

• id : 就是对应的namespace中接口的方法名！
• resultType：Sql语句执行后的返回值！
• parameterType ： 接口中方法的参数类型！

1. 编写接口

   //根据ID查询用户
   User getUserById(int id);
   

2. 编写对应的mapper中的sql语句

   <!-- 当传入的参数是基本类型的时候，就不需要指定parameterType，直接传入参数即可 -->
   <select id="getUserById" resultType="com.kuang.pojo.User">
           select * from user where id = #{id};
   </select>
   
   

3. 测试

   @Test
   public void getUserById() {
     // 1. 获取sqlSession对象
     SqlSession sqlSession = MybatisUtils.getSqlSession();
     // 2. 获取UserDao接口的代理对象
     UserDao mapper = sqlSession.getMapper(UserDao.class);
     // 3. 执行接口中的方法
     User user = mapper.getUserById(3);
     // 4. 打印
     System.out.println(user);
     // 5. 释放资源
     sqlSession.close();
   }
   

3. Insert

<!-- 对象中的属性，可以直接取出来-->
<insert id="addUser" parameterType="com.kuang.pojo.User">
   insert into user(id,name,pwd) values(#{id},#{name},#{pwd});
</insert>

• mybatis的两种传值方式

  1. ${} 文本替换，未经任何处理对SQL文本替换

  2. #{} 预编译传值，使用预编译传值可以预防SQL注入

     #{} 相当于之前的？占位符，sql语句传值都用#{}

{}中就是实体类的属性名或者map集合的键，又或者单个参数等等

// 增删改需要提交事务
@Test
public void addUser() {
    // 1. 获取sqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    // 2. 获取UserDao接口的代理对象
    UserDao mapper = sqlSession.getMapper(UserDao.class);
    // 3. 执行接口中的方法
    int count = mapper.addUser(new User(4, "陈健", "518711"));
    // 4. 提交事务
    sqlSession.commit();
    // 5. 释放资源
    sqlSession.close();
}

4. update

<update id="updateUser" parameterType="com.kuang.pojo.User">
   update user set name=#{name},pwd=#{pwd} where id=#{id};
</update>

@Test
public void updateUser() {
    // 1. 获取sqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    // 2. 获取UserDao接口的代理对象
    UserDao mapper = sqlSession.getMapper(UserDao.class);
    // 3. 执行接口中的方法
    int count = mapper.updateUser(new User(4, "康婧", "518711"));
    // 4. 提交事务
    sqlSession.commit();
    // 5. 释放资源
    sqlSession.close();
}

5. Delete

<delete id="deleteUser" parameterType="int">
    delete from mybatis.user where id = #{id};
</delete>

@Test
public void deleteUser() {
    // 1. 获取sqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    // 2. 获取UserDao接口的代理对象
    UserDao mapper = sqlSession.getMapper(UserDao.class);
    // 3. 执行接口中的方法
    int count = mapper.deleteUser(3);
    // 4. 提交事务
    sqlSession.commit();
    // 5. 释放资源
    sqlSession.close();
}

注意点：

• 增删改需要提交事务！

• 提交事务的方法：sqlSession.commit();

6. 分析错误

• 标签不要匹配错，例如：查询就要对应select标签

• resource 绑定mapper，需要使用路径！，不是com.anuo.dao

  <!-- 每一个Mapper.xml都需要在mybatis核心配置文件中注册！ -->
  <mappers>
      <mapper resource="com/anuo/dao/UserMapper.xml" />
  </mappers>
  

• 输出的xml文件中存在中文乱码问题！

  解决方案：在pom.xml文件中加入以下代码，设置项目编码

  <!-- 设置项目编码，解决导出的xml文件的中文乱码问题 -->
  <properties>
      <project.build.sourceEncoding>
        UTF-8
    	</project.build.sourceEncoding>
  </properties>
  

7. 万能Map

假设，我们的实体类，或者数据库中的表，字段或者参数过多，我们应当考虑使用Map！

实际上Map集合多用于原本方法需要传入多个参数的时候！

// 万能的map
int addUserByMap(Map<String, Object> map);

<!-- 万能的map 只需要传递map集合的键 -->
<insert id="addUser" parameterType="map">
    insert into mybatis.user (id, pwd) values (#{userId},#{passWord});
</insert>

@Test
public void addUserByMap() {
    // 1. 获取sqlSession对象
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    // 2. 获取UserDao接口的代理对象
    UserDao mapper = sqlSession.getMapper(UserDao.class);
    // 3. 执行接口中的方法
    Map<String, Object> map = new HashMap<>();
    map.put("userId", 5);
    map.put("password", "123455");
    int count = mapper.addUserByMap(map);
    // 4. 提交事务
    sqlSession.commit();
    // 5. 释放资源
    sqlSession.close();
}

• 总结

1. Map传递参数，直接在sql中取出key即可！

   【parameterType=“map”】

2. 对象传递参数，直接在sql中取对象的属性即可！【parameterType=“Object”】

3. 只有一个基本类型参数的情况下，可以直接在sql中取到！

   不需要写【parameterType=“int”】

4. 多个参数用Map，或者@Param注解！

8. 模糊查询

模糊查询怎么写？

1. Java代码执行方法的时候，参数中传递通配符 % %

   List<User> userList = mapper.getUserLike("%李%");
   

2. 在sql拼接中使用通配符！

   select * from mybatis.user where name like concat("%", #{value}, "%")
   

4. 核心配置解析

1. 核心配置文件

• mybatis-config.xml 【官方建议取这个名字】

• MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息。

  <!-- mybatis核心配置文件中的标签 -->
  1. configuration（配置）
    2. properties（属性） *
    2. settings（设置） 
    2. typeAliases（类型别名）*
    2. typeHandlers（类型处理器）
    2. objectFactory（对象工厂）
    2. plugins（插件）
    2. environments（环境配置）*
    	3. environment（环境变量）*
    		4. transactionManager（事务管理器）*
    		4. dataSource（数据源）*
    2. databaseIdProvider（数据库厂商标识）
    2. mappers（映射器）*
  

2. 环境配置(environments)

1. MyBatis 可以配置成适应多种环境

   不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。

2. 学会使用配置多套运行环境：指定default属性为要使用环境的id值

3. Mybatis默认的事务管理器就是 JDBC ， 默认数据源就是POOLED（使用连接池）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-TZC5sQxt-1602519093876)(G:\学习笔记\Mybatis\Mybatis课堂笔记.assets\4.PNG)]

3. 属性(properties)

我们可以通过properties属性来实现引用配置文件

这些属性都是可外部配置且可动态替换的，既可以在典型的 Java 属性文件中配置，亦可通过 properties 元素的子元素来传递。【db.properties】

• 在核心配置文件中的标签顺序是固定的，不能换位置

  所以在configuration标签下，第一个写的就是properties标签

• 使用步骤

1. 编写一个配置文件

   db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useUnicode=true&characterEncoding=UTF-8
username=root
password=chenjian123

2. 在核心配置文件中映入

<!--引入外部配置文件-->
<properties resource="db.properties">
   <!-- 增加一些属性配置，如果与引入的配置文件中属性冲突，则引入的配置文件优先级更高 -->
    <property name="username" value="root"/>
    <property name="pwd" value="chenjian123"/>
</properties>

3. 在核心配置文件中使用：用${}符号

   <environment id="development">
       <!-- 事务管理 -->
       <transactionManager type="JDBC"/>
       <!-- 连接数据库参数 -->
       <dataSource type="POOLED">
           <property name="driver" value="${driver}"/>
           <property name="url" value="${url}"/>
           <property name="username" value="${username}"/>
           <property name="password" value="${password}"/>
       </dataSource>
   </environment>
   

• 总结：

  1. 可以直接引入外部文件

  2. 可以在其中增加一些属性配置

  3. 如果两个文件有同一个属性，优先使用外部配置文件的！

如果同一个属性在不止一个地方进行了配置，那么，MyBatis 将按照下面的顺序来加载：

• 首先读取在 properties 元素体内指定的属性。
• 然后根据 properties 元素中的 resource 属性读取类路径下属性文件，或根据 url 属性指定的路径读取属性文件，并覆盖之前读取过的同名属性。
• 最后读取作为方法参数传递的属性，并覆盖之前读取过的同名属性。

因此，通过方法参数传递的属性具有最高优先级，resource/url 属性中指定的配置文件次之，最低优先级的则是 properties 元素中指定的属性。

4. 类型别名(typeAliases)

• 类型别名是为 Java 类型设置一个短的名字。‘
• 存在的意义仅在于用来减少类完全限定名的冗余。

1. 方式一：标签，给单独的类起别名。

<!--给单独的实体类起别名-->
<typeAliases>
    <typeAlias type="com.kuang.pojo.User" alias="User"/>
</typeAliases>

​ 起别名后，在mapper.xml文件中简化了类名的指定：

<!-- 起别名前  -->
<select id="getUserList" resultType="com.anuo.pojo.User">
    select * from mybatis.user;
</select>
----------------------------------
<!-- 起别名后  -->
<select id="getUserList" resultType="User">
    select * from mybatis.user;
</select>

2. 方式二：标签，扫描指定的包。

   指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，比如：

   扫描实体类的包，它的默认别名就为包中类的类名，建议首字母小写！

<!-- 扫描指定的包 -->
<typeAliases>
    <package name="com.kuang.pojo"/>
</typeAliases>

<!-- 扫描包后，默认别名就是实体类的类名首字母小写  -->
<select id="getUserList" resultType="user">
    select * from mybatis.user;
</select>

• 两种方式的使用建议：

  1. 在实体类比较少的时候，使用第一种方式。

  2. 如果实体类十分多，建议使用第二种。

• 两种方式的区别：

  第一种可以DIY别名，第二种则不行（默认类名首字母小写）。

  如果第二种方式非要自定义别名，则需要在对应实体类上方增加注解

@Alias("user")
public class User {}

• JDK中常见的内置类，mybatis已经进行别名。

  一般别名是类名的小写，为了区分基本类型和其包装类的命名重复，

  基本类型采取了特殊的命名风格：开头加上下划线_

  [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PD6QjAp5-1602519093879)(G:\学习笔记\Mybatis\Mybatis课堂笔记.assets\5.PNG)]

5. 设置(settings)

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。

设置项较多，可以在mybatis官方文档中查看。

• 其中主要记住四个设置项，如图所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vZKDv49P-1602519093880)(Mybatis课堂笔记.assets/1569657659080.png)]

设置名	描述	有效值
mapUnderscoreToCamelCase	是否允许实体类属性名为对应数据表字段名的驼峰形式	true|false
cacheEnabled	全局性地开启或关闭所有映射器配置文件中已配置的任何缓存	true|false
lazyLoadingEnabled	延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。	true|false
logImpl	指定 MyBatis 所用日志的具体实现，未指定时将自动查找	LOG4J|LOG4J2等

• 在mybatis-config.xml中，通过setting标签设置即可

  例如：

  <settings>
    <setting name="cacheEnabled" value="true"/>
    <setting name="lazyLoadingEnabled" value="true"/>
    <!-- 标准的日志工厂的实现 -->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
    <!-- 允许实体类属性名为对应数据表字段名的驼峰形式 -->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
  </settings>
  

6. 其他配置(了解)

• typeHandlers（类型处理器）
• objectFactory（对象工厂）
• plugins插件
  • mybatis-generator-core
  • mybatis-plus
  • 通用mapper

7. 映射器（mappers）

MapperRegistry：注册绑定我们的Mapper文件；

1. 方式一： 【推荐使用】

<!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册！-->
<mappers>
    <mapper resource="com/anuo/dao/UserMapper.xml"/>
</mappers>

2. 方式二：使用class文件绑定注册

<!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册！-->
<mappers>
    <mapper class="com.anuo.dao.UserMapper"/>
</mappers>

使用方式二的注意点：

• 接口和他的Mapper配置文件必须同名！

• 接口和他的Mapper配置文件必须在同一个包下！

3. 方式三：使用扫描包进行注入绑定

<!--每一个Mapper.XML都需要在Mybatis核心配置文件中注册！-->
<mappers>
    <package name="com.kuang.dao"/>
</mappers>

注意点与方式二相同：

• 接口和他的Mapper配置文件必须同名！
• 接口和他的Mapper配置文件必须在同一个包下！

• 思考题：

  使用方式二或方式三，如何实现接口和他的Mapper配置文件分离，

  也就是接口的Mapper.xml文件放置在src.main.resources文件夹下？

  • 解决方案：

    了解本质：要放在同一个包下的原因为接口编译生成的class文件会和

    ​ xml文件在同一个目录下。

    ​ 所以只要保证编译生成的class文件和xml文件在同个目录。

    做法：在src.main.resources下建立与接口所在包相同的文件夹，

    ​ 例如接口在com.anuo.dao包下，resources文件夹下也建立

    ​ com.anuo.dao，然后在里面放接口对应的Mapper.xml即可

    注意：在src.main.resources下建立的文件夹一定是要能够展开的多级文件夹，之前我将该文件夹命名为com.anuo.dao，但并不是多级文件夹，导致报错。

    • 如何验证是不是多级文件夹？

      点击左侧工程目录右上角的小齿轮，将Compact Middle Packages不要勾选！

8. 生命周期和作用域

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ajgOdSfL-1602519093882)(Mybatis课堂笔记.assets/1569660357745.png)]

生命周期和作用域，是至关重要的，因为错误的使用会导致非常严重的并发问题。

SqlSessionFactoryBuilder：

• 一旦创建了 SqlSessionFactory，就不再需要它了
• 所以一般当做：局部变量

SqlSessionFactory：

• 说白了就是可以想象为 ：数据库连接池
• SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。
• 因此 SqlSessionFactory 的最佳作用域是应用作用域。
• 最简单的就是使用单例模式或者静态单例模式。

SqlSession

• 连接到连接池的一个请求！
• SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
• 用完之后需要赶紧关闭，否则资源被占用！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iOH43Krs-1602519093883)(Mybatis课堂笔记.assets/1569660737088.png)]

这里面的每一个Mapper，就代表一个具体的业务！

5. 解决属性名和字段名不一致的问题

1. 问题测试

1. 数据库中的字段

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FA7ZmRiD-1602519093885)(Mybatis课堂笔记.assets/1569660831076.png)]

2. 新建一个项目，测试实体类属性名与数据库字段名不一致的情况

public class User {
    
    private int id;
    private String name;
    private String password; // 数据库中为pwd字段
}

3. 测试结果：password为null值

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RMkWORYa-1602519093886)(Mybatis课堂笔记.assets/1569661145806.png)]

• 原因：

-- 类型处理器无法对pwd和password进行匹配
select * from user where id = #{id};
								|等同于|
select id,name,pwd from user where id = #{id};

2. 解决方法

1. 方式一：在sql语句中起别名：

<select id="getUserById" resultType="com.anuo.pojo.User">
    select id,name,pwd as password from user where id = #{id}
</select>

​ 2、方式二：resultMap：结果集映射

id   name   pwd
id   name   password

<!--结果集映射-->
<resultMap id="UserMap" type="User">
    <!--column：数据库中的字段，property：实体类中的属性-->
    <result column="id" property="id"/>
    <result column="name" property="name"/>
    <result column="pwd" property="password"/>
</resultMap>

<select id="getUserById" resultMap="UserMap">
    select * from mybatis.user where id = #{id}
</select>

• resultMap 元素是 MyBatis 中最重要最强大的元素
• ResultMap 的设计思想是，对于简单的语句根本不需要配置显式的结果映射，而对于复杂一点的语句只需要描述它们的关系就行了。
• ResultMap 最优秀的地方在于，虽然你已经对它相当了解了，但是根本就不需要显式地用到他们。
• 如果世界总是这么简单就好了。

6. 日志

6.1 日志工厂

如果一个数据库操作，出现了异常，我们需要排错。日志就是最好的助手！

曾经：sout 、debug

现在：日志工厂！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-T4FGnNnr-1602519093888)(Mybatis课堂笔记.assets/1569892155104.png)]

• mybatis中有哪些日志实现？
  • SLF4J
  • LOG4J 【掌握】
  • LOG4J2
  • JDK_LOGGING
  • COMMONS_LOGGING
  • STDOUT_LOGGING 【掌握】
  • NO_LOGGING

• 在Mybatis中具体使用哪个日志实现，在核心配置文件的设置中设定！

6.2 STDOUT_LOGGING

STDOUT_LOGGING为标准日志输出

在mybatis核心配置文件中，配置我们的日志！

<settings>
  	<!-- 标准的日志工厂的实现 -->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-mi5IfOn7-1602519093889)(Mybatis课堂笔记.assets/1569892595060.png)]

6.2 Log4j

什么是Log4j？

• Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
• 我们也可以控制每一条日志的输出格式
• 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。
• 通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。

1. 先导入log4j的包

   <!-- https://mvnrepository.com/artifact/log4j/log4j -->
   <dependency>
       <groupId>log4j</groupId>
       <artifactId>log4j</artifactId>
       <version>1.2.17</version>
   </dependency>
   

2. log4j.properties

   #将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码
   log4j.rootLogger=DEBUG,console,file
   
   #控制台输出的相关设置
   log4j.appender.console = org.apache.log4j.ConsoleAppender
   log4j.appender.console.Target = System.out
   log4j.appender.console.Threshold=DEBUG
   log4j.appender.console.layout = org.apache.log4j.PatternLayout
   log4j.appender.console.layout.ConversionPattern=[%c]-%m%n
   
   #文件输出的相关设置
   log4j.appender.file = org.apache.log4j.RollingFileAppender
   log4j.appender.file.File=./log/kuang.log
   log4j.appender.file.MaxFileSize=10mb
   log4j.appender.file.Threshold=DEBUG
   log4j.appender.file.layout=org.apache.log4j.PatternLayout
   log4j.appender.file.layout.ConversionPattern=[%p][%d{yy-MM-dd}][%c]%m%n
   
   #日志输出级别
   log4j.logger.org.mybatis=DEBUG
   log4j.logger.java.sql=DEBUG
   log4j.logger.java.sql.Statement=DEBUG
   log4j.logger.java.sql.ResultSet=DEBUG
   log4j.logger.java.sql.PreparedStatement=DEBUG
   

3. 配置log4j为日志的实现

   <settings>
       <setting name="logImpl" value="LOG4J"/>
   </settings>
   

4. Log4j的使用！，直接测试运行刚才的查询

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-QLOBUqNR-1602519093890)(Mybatis课堂笔记.assets/1569893505842.png)]

需要自定义日志输出内容时，简单使用：

1. 在要使用Log4j 的类中，导入包 import org.apache.log4j.Logger;

2. 创建日志对象作为成员变量，参数为当前类的class

   static Logger logger = Logger.getLogger(UserDaoTest.class);
   

3. 调用方法，自定义输出内容

   logger.info("info:进入了testLog4j");
   logger.debug("debug:进入了testLog4j");
   logger.error("error:进入了testLog4j");
   

   方法名对应了日志的输出级别：（从高到低）

   error：错误 - 系统的故障日志

   warn：警告 - 存在风险或使用不当的日志

   info：一般性消息

   debug：程序内部用于调试信息

   trace：程序运行的跟踪信息

7. 分页

思考：为什么要分页？

• 减少数据的处理量

7.1 使用Limit分页

语法：SELECT * from user limit startIndex,pageSize;
SELECT * from user limit 0, 4;  -- 0索引开始取4条数据
SELECT * from user limit 3;  -- 单个参数，默认从0索引开始取3条数据

使用Mybatis实现分页，核心SQL

1. 接口

   //分页 
   List<User> getUserByLimit(Map<String,Integer> map);
   

2. Mapper.xml

   <!-- 分页 -->
   <select id="getUserByLimit" parameterType="map" resultMap="UserMap">
       select * from user limit #{startIndex}, #{pageSize}
   </select>
   

3. 测试

   @Test
   public void getUserByLimit() {
       // 1.获取SqlSession对象
       SqlSession sqlSession = MybatisUtils.getSqlSession();
       // 2.获取UserMapper接口的代理对象
       UserMapper mapper = sqlSession.getMapper(UserMapper.class);
       // 3.创建map集合
       Map<String, Integer> map = new HashMap<>();
       map.put("startIndex", 0);
       map.put("pageSize", 5);
       // 4.代理对象执行接口方法getUserByLimit
       List<User> userList = mapper.getUserByLimit(map);
       // 5.遍历打印
       userList.forEach(System.out::println);
       // 6. 关闭SqlSession,释放资源
       sqlSession.close();
   }
   

7.2 RowBounds分页

不再使用SQL实现分页，基于RowBounds对象分页【了解即可】

1. 接口

   //分页2
   List<User> getUserByRowBounds();
   

2. mapper.xml

   <!--分页2-->
   <select id="getUserByRowBounds" resultMap="UserMap">
       select * from user;
   </select>
   

3. 测试

   @Test
   public void getUserByRowBounds() {
       // 1.获取SqlSession对象
       SqlSession sqlSession = MybatisUtils.getSqlSession();
       // 2.RowBounds对象实现分页
       RowBounds rowBounds = new RowBounds(1, 2);
       // 3.RowBounds只能用selectList方式执行接口方法
       List<Object> userList = sqlSession.selectList("com.anuo.dao.UserMapper.getUserByRowBounds", null, rowBounds);
       // 4.遍历打印
       userList.forEach(System.out::println);
       // 5. 关闭SqlSession,释放资源
       sqlSession.close();
   }
   

7.3 分页插件

• 网址：https://pagehelper.github.io/
• 了解即可，万一 以后公司的架构师，说要使用，你需要知道它是什么东西！
• 使用时，可以查看该网站的文档即可

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Il6Hbg25-1602519093891)(Mybatis课堂笔记.assets/1569896603103.png)]

8. 使用注解开发

8.1 面向接口编程

- 大家之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程
- 根本原因 : 解耦 , 可拓展 , 提高复用 , 分层开发中 , 上层不用管具体的实现 , 大家都遵守共同的标准 , 使得开发变得容易 , 规范性更好
- 在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了；
- 而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程。

关于接口的理解

- 接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。
- 接口的本身反映了系统设计人员对系统的抽象理解。
- 接口应有两类：
- 第一类是对一个个体的抽象，它可对应为一个抽象体(abstract class)；
- 第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）；
- 一个体有可能有多个抽象面。抽象体与抽象面是有区别的。

三个面向区别

- 面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法 .
- 面向过程是指，我们考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现 .
- 接口设计与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题.更多的体现就是对系统整体的架构

8.2 使用注解开发

1. 注解在接口上实现

   @Select("select * from user")
   List<User> getUserList();
   

2. 需要再核心配置文件中绑定接口！或者在接口上使用@Mapper

   <!-- 利用注解开发，就没有mapper.xml文件了，直接绑定接口即可 -->
   <mappers>
       <mapper class="com.anuo.dao.UserMapper"/>
   </mappers>
   

3. 测试

   @Test
   public void getUserList() {
       // 1. 获取SqlSession对象
       SqlSession sqlSession = MybatisUtils.getSqlSession();
       // 2. 获得UserMapper接口的代理对象
       UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
       List<User> userList = userMapper.getUserList();
       // 3. 遍历打印
       userList.forEach(System.out::println);
       // 4. 关闭SqlSession,释放资源
       sqlSession.close();
   }
   

本质：反射机制实现

底层：动态代理！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AdwN5TOb-1602519093893)(Mybatis课堂笔记.assets/1569898830704.png)]

Mybatis详细的执行流程！

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-ahuAKbC2-1602519093894)(Mybatis课堂笔记.assets/Temp.png)]

8.3 利用注解实现CRUD

• 注解开发适合用于简单的sql语句

• 备注：我们可以在MybatisUtils工具类创建的时候实现自动提交事务！

public static SqlSession  getSqlSession(){
    return sqlSessionFactory.openSession(true);
}

• 使用步骤

1. 将接口注册绑定到我们的核心配置文件中

<!-- 利用注解开发，就没有mapper.xml文件了，直接绑定接口即可 -->
<mappers>
     <mapper class="com.anuo.dao.UserMapper" />
</mappers>

2. 编写接口，增加注解

@Mapper
public interface UserMapper {

    @Select("select * from user")
    List<User> getUsers();

    // 方法存在多个参数，所有的参数前面必须加上 @Param注解，#{id}就是根据@Param("id")找到的
    @Select("select * from user where id = #{id}")
    User getUserByID(@Param("id") int id);


    @Insert("insert into user(id,name,pwd) values (#{id},#{name},#{password})")
    int addUser(User user);

    
    @Update("update user set name=#{name},pwd=#{password} where id = #{id}")
    int updateUser(User user);

    
    @Delete("delete from user where id = #{uid}")
    int deleteUser(@Param("uid") int id);
}

3. 测试类

public class UserMapperTest {
    @Test
    public void getUserList() {
        // 1. 获取SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        // 2. 获得UserMapper接口的代理对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = userMapper.getUserList();
        // 3. 遍历打印
        userList.forEach(System.out::println);
        // 4. 关闭SqlSession,释放资源
        sqlSession.close();
    }

    @Test
    public void getUserById() {
        // 1. 获取SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        // 2. 获得UserMapper接口的代理对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        User user = userMapper.getUserById(2);
        // 3. 打印
        System.out.println(user);
        // 4. 关闭SqlSession,释放资源
        sqlSession.close();
    }

    @Test
    public void addUser() {
        // 1. 获取SqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        // 2. 获得UserMapper接口的代理对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        // 3. 创建User对象
        User user = new User(8, "帅帅健", "13241312");
        // 4. 接口的代理对象执行添加用户的方法
        int result = userMapper.addUser(user);
        // 5. 创建Utils工具类的时候已经设置自动提交事务
        // 6. 关闭SqlSession,释放资源
        sqlSession.close();
    }

    @Test
    public void updateUser() {
        // 1.获取sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        // 2.获取接口的代理对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        // 3.执行更新用户的方法
        userMapper.updateUser(new User(8, "小帅健", "1234567"));
        // 5.创建Utils工具类的时候已经设置自动提交事务
        // 6.关闭sqlSession，释放资源
        sqlSession.close();
    }

    @Test
    public void deleteUser() {
        // 1.获取sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        // 2.获取接口的代理对象
        UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
        // 3.执行更新用户的方法
        userMapper.deleteUser(8);
        // 5.创建Utils工具类的时候已经设置自动提交事务
        // 6.关闭sqlSession，释放资源
        sqlSession.close();
    }
}

关于@Param() 注解

• 基本类型的参数或者String类型，需要加上
• 引用类型不需要加，除非动态sql的条件中使用到该引用类型！
• 如果只有一个基本类型的话，可以忽略，但是建议大家都加上！
• 我们在SQL中引用的就是我们这里的 @Param() 中设定的属性名！

9. Lombok

• Lombok是一款非常实用Java工具，可用来帮助开发人员消除Java的冗长代码，尤其是对于简单的Java对象（POJO）。它通过注释实现这一目的。

• 使用步骤：

  1. 在IDEA中安装Lombok插件！

  2. 在项目中导入lombok的jar包

     <dependency>
         <groupId>org.projectlombok</groupId>
         <artifactId>lombok</artifactId>
         <version>1.18.10</version>
     </dependency>
     

  3. 在实体类上加注解即可！

     @Data  // 自动生成：getter、setter、toString、hashCode，equals
     @AllArgsConstructor // 自动生成：全参构造
     @NoArgsConstructor // 自动生成：无参构造
     public class User {
         private int id;
         private String name;
         private String password;
     }
     

• 可供添加的注解【了解即可】

@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data
@Builder
@SuperBuilder
@Singular
@Delegate
@Value
@Accessors
@Wither
@With
@SneakyThrows
@val
@var

• 常用的注解：

@Data：// getter、setter、toString、hashCode，equals 方法
@AllArgsConstructor // 全参构造
@NoArgsConstructor // 无参构造
@EqualsAndHashCode // equals 和 hashCode 方法
@ToString // toString方法
@Getter // getter方法
@Setter // setter方法

10. 多对一处理

多对一：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-byNKGBKX-1602519093896)(Mybatis课堂笔记.assets/1569909163944.png)]

• 多个学生，对应一个老师
• 对于学生这边而言， 关联 , 多个学生，关联一个老师 【多对一】
• 对于老师而言， 集合 ， 一个老师，有很多学生 【一对多】

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6uTuw0vA-1602519093897)(Mybatis课堂笔记.assets/1569909422471.png)]

老师学生案例的SQL：

CREATE TABLE `teacher` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师'); 

CREATE TABLE `student` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  `tid` INT(10) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `fktid` (`tid`),
  CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;


INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '小明', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '小红', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '小张', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '小李', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', '小王', '1');

环境搭建

1. 导入lombok

2. 新建实体类 Teacher，Student

   // Teacher实体类
   @Data
   public class Teacher {
       private int id;
       private String name;
   }
   

   // Student实体类
   @Data
   public class Student {
       private int id;
       private String name;
       // 学生需要关联一个老师
       private Teacher teacher;
   }
   

3. 建立Mapper接口

   public interface StudentMapper {
       // 查询所有的学生信息，以及对应的老师的信息！  
       List<Student> getStudent();
       List<Student> getStudent2();
   }
   

   public interface TeacherMapper {
       Teacher getTeacher(@Param("id") int id);
   }
   

4. 建立Mapper.XML文件，两种处理方式见下面分析

5. 在核心配置文件中绑定注册我们的Mapper接口或者文件！【方式很多，随心选】

   <mappers>
       <package name="com.anuo.dao" />
   </mappers>
   

6. 测试查询是否能够成功！

   public class MyTest {
       @Test
       public void getStudent() {
           // 1.获取sqlSession对象
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           // 2.获取TeacherMapper接口的代理对象
           StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
           // 3.执行接口的getTeacher方法
           List<Student> students = mapper.getStudent();
           // 4.打印
           students.forEach(System.out::println);
           // 5.关闭资源
           sqlSession.close();
       }
   
       @Test
       public void getStudent2() {
           // 1.获取sqlSession对象
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           // 2.获取TeacherMapper接口的代理对象
           StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
           // 3.执行接口的getTeacher方法
           List<Student> students = mapper.getStudent2();
           // 4.打印
           students.forEach(System.out::println);
           // 5.关闭资源
           sqlSession.close();
       }
   }
   

按照查询映射处理

<!--
    思路:
        1. 查询所有的学生信息
        2. 根据查询出来的学生的tid，寻找对应的老师！  子查询
-->

<select id="getStudent" resultMap="StudentTeacher">
    select * from student
</select>

<resultMap id="StudentTeacher" type="Student">
    <id property="id" column="id"/>
    <result property="name" column="name"/>
    <!--
			复杂的属性，我们需要单独处理 
			对象使用标签： association ，其中因为是对象，需要以javaType属性指定对象类型；select属性指定嵌套的查询
			集合使用标签： collection 
		-->
  	<!-- 子查询的映射：column="tid"是将tid字段作为参数传递给子查询getTeacher的#{id} -->
    <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
</resultMap>

<select id="getTeacher" resultType="Teacher">
    select * from teacher where id = #{id}
</select>

按照结果映射处理

<!--按照结果嵌套处理-->
<select id="getStudent2" resultMap="StudentTeacher2">
    select s.id sid,s.name sname,t.name tname
    from student s,teacher t
    where s.tid = t.id;
</select>

<resultMap id="StudentTeacher2" type="Student">
    <id property="id" column="sid"/>
    <result property="name" column="sname"/>
    <association property="teacher" javaType="Teacher">
      	<!-- 看看上面sql的结果字段中，需要哪些整合成Teacher对象 -->
        <result property="name" column="tname"/>
    </association>
</resultMap>

11. 一对多处理

比如：一个老师拥有多个学生！

对于老师而言，就是一对多的关系!

环境搭建

1. 导入lombok

2. 新建实体类 Teacher，Student

   // Student实体类
   @Data
   public class Student {
       private int id;
       private String name;
       private int tid;
   }
   

   // Teacher实体类
   @Data
   public class Teacher {
       private int id;
       private String name;
       //一个老师拥有多个学生
       private List<Student> students;
   }
   

3. 建立Mapper接口

   public interface TeacherMapper {
       
       // 获取指定老师下的所有学生及老师的信息
       Teacher getTeacher(@Param("id") int id);
   
       Teacher getTeacher2(@Param("id") int id);
   }
   

   public interface StudentMapper {
       List<Student> getStudentByTid(@Param("tid") int tid);
   }
   

4. 建立Mapper.XML文件，两种处理方式见下面分析

5. 在核心配置文件中绑定注册我们的Mapper接口或者文件！【方式很多，随心选】

   <mappers>
       <package name="com.anuo.dao" />
   </mappers>
   

6. 测试查询是否能够成功！

   public class MyTest {
       @Test
       public void getTeacher() {
           // 1.获取sqlSession对象
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           // 2.获取TeacherMapper接口的代理对象
           TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
           // 3.执行方法
           Teacher teacher = mapper.getTeacher(1);
           // 4.打印
           System.out.println(teacher);
           // 5.关闭资源
           sqlSession.close();
       }
   
       @Test
       public void getTeacher2() {
           // 1.获取sqlSession对象
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           // 2.获取TeacherMapper接口的代理对象
           TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
           // 3.执行方法
           Teacher teacher = mapper.getTeacher2(1);
           // 4.打印
           System.out.println(teacher);
           // 5.关闭资源
           sqlSession.close();
       }
   }
   

按照结果映射处理

<!--按结果映射处理-->
<select id="getTeacher" resultMap="TeacherStudent">
  	select t.id tid, t.name tname, s.id sid, s.name sname
  	from teacher t, student s
 		where t.id = s.tid and t.id = #{id}
</select>

<resultMap id="TeacherStudent" type="Teacher">
  	<id property="id" column="tid"/>
  	<result property="name" column="tname"/>
  	<!--
      复杂的属性，我们需要单独处理
      对象使用标签： association ，其中因为是对象，需要以javaType属性指定对象类型；select属性指定嵌套的查询
      集合使用标签： collection ，其中用ofType属性指定集合泛型的类型
  	-->
  	<collection property="students" ofType="Student">
   	  <!-- 看看上述sql的结果，有哪些字段用于包装成Student对象 -->
    	<id property="id" column="sid"/>
    	<result property="name" column="sname"/>
    	<result property="tid" column="tid"/>
  	</collection>
</resultMap>

按照查询映射处理

<select id="getTeacher2" resultMap="TeacherStudent2">
  	select * from teacher where id = #{id};
</select>

<resultMap id="TeacherStudent2" type="Teacher">
  	<id property="id" column="id"/>
  	<result property="name" column="name"/>
  	<!--
      复杂的属性，我们需要单独处理
      对象使用标签： association ，其中因为是对象，需要以javaType属性指定对象类型；select属性指定嵌套的查询
      集合使用标签： collection ，其中用ofType属性指定集合泛型的类型
  	-->
  	<!-- 子查询的映射：column="id"是将tid字段作为参数传递给子查询getStudentByTid的#{tid} -->
  	<collection property="students" ofType="Student" column="id" select="getStudentByTid"/>
</resultMap>

<select id="getStudentByTid" resultType="Student">
  	select * from student where tid = #{tid};
</select>

小结

1. 关联 - association 【多对一】

2. 集合 - collection 【一对多】

3. javaType & ofType

   1. JavaType 用来指定实体类中属性的类型
   2. ofType 用来指定映射到List或者集合中的 pojo类型，泛型中的约束类型！

4. 按照查询映射处理：适合于要封装的对象类型的属性在数据库中的字段多的时候。

   按照结果映射处理：适合于要封装的对象类型的属性在数据库中的字段少的时候。

5. 设计数据库表的时候，有关联的表之间的字段名尽可能的不要重名。

   这样可以让我们在服务器端写多表查询的sql的时候，不用对多表间重名的字段名进行取别名，如果出现重名，是必需要取别名进行区分的。

注意点：

• 保证SQL的可读性，尽量保证通俗易懂
• 注意一对多和多对一中，属性名和字段的问题！
• 如果问题不好排查错误，可以使用日志 ， 建议使用 Log4j

慢SQL 1s 1000s

面试高频

• Mysql引擎
• InnoDB底层原理
• 索引
• 索引优化！

12. 动态 SQL

什么是动态SQL：动态SQL就是指根据不同的条件生成不同的SQL语句

传统的JDBC若是要完成动态SQL，需要涉及到字符串的拼接，十分麻烦！

利用Mybatis的动态 SQL 这一特性可以彻底摆脱这种痛苦。

动态 SQL 元素和 JSTL 或基于类似 XML 的文本处理器相似。
在 MyBatis 之前的版本中，有很多元素需要花时间了解。
MyBatis 3 大大精简了元素种类，现在只需学习原来一半的元素便可。
MyBatis 采用功能强大的基于 OGNL 的表达式来淘汰其它大部分元素。

主要学习的元素：
if
choose (when, otherwise)
trim (where, set)
foreach

12.1 搭建环境

1. 创建表的sql语句

CREATE TABLE `blog` (
  `id` varchar(50) NOT NULL COMMENT '博客id',
  `title` varchar(100) NOT NULL COMMENT '博客标题',
  `author` varchar(30) NOT NULL COMMENT '博客作者',
  `create_time` datetime NOT NULL COMMENT '创建时间',
  `views` int(30) NOT NULL COMMENT '浏览量'
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

2. 创建一个基础工程

   1. 导包

   2. 编写配置文件

   3. 编写实体类

   @Data
   public class Blog {
       private String id;
       private String title;
       private String author;
       private Date createTime; // 注意这里导入的包是java.util.Date
       private int views;
   }
   

   注意：

   数据库表字段的datetime类型，对应在Java实体类中是java.util包下的Date类型，不是java.sql包下的！！！！

   4. 编写实体类对应Mapper接口 和 Mapper.XML文件

12.2 IF

• IF 标签给sql语句提供了多条件可选的查找功能。
• 以下语句，如果给了title或author字段的参数，那么就将对应的条件加上进行查询，就算两个都没有给，因为1=1条件的恒成立，也会将所有表记录查询出来。
• 当然，这种WHERE 1=1写法是不规范的，只是为了暂时解决AND关键字和WHERE关键字不能直接拼接的问题，之后的WHERE关键字会用where标签代替。

<select id="queryBlogIF" parameterType="map" resultType="blog">
    select * from blog where 1=1
    <if test="title != null">
        and title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
</select>

12.3 choose（when, otherwise)

• 有时候，我们只是想从多个条件中选择一个使用。针对这种情况，MyBatis 提供了 choose 标签，它有点像 Java 中的 switch 语句。

• choose标签多用于优先条件查询，即让多条件有一个优先级，只能执行一个。

• 以下语句，从上到下存在优先级高低的问题，例如：只要title不为空，就只执行title = #{title}这一个条件。这里使用了where标签

<select id="queryBlogChoose" parameterType="map" resultType="blog">
  select * from blog
  <where>
    <choose>
      <when test="title != null">
        title = #{title}
      </when>
      <when test="author != null">
        author = #{author}
      </when>
      <otherwise>
        views = #{views}
      </otherwise>
    </choose>
  </where>
</select>

12.4 trim，where ，set

• 不使用where与set标签代替WHERE与SET关键字会出现什么情况？

  <!-- 当title为空时而author有值时，会出现where和and直接拼接的情况，将报错！ -->
  <select id="queryBlogIF" parameterType="map" resultType="blog">
      select * from blog where
      <if test="title != null">
          title = #{title}
      </if>
      <if test="author != null">
          and author = #{author}
      </if>
  </select>
  

  <!-- 同理当title有值而author为空时，在拼接时set语句结尾多了一个逗号-->
  <update id="updateBlog" parameterType="map">
      update blog set
      <if test="title != null">
        title = #{title},
      </if>
      <if test="author != null">
        author = #{author}
      </if>
      where id = #{id}
  </update>
  

• 使用where与set元素代替WHERE与SET关键字可以避免这种情况！

  • where 元素会在有至少一个条件存在时才插入 “WHERE” 子句，当没有条件时不插入"WHERE"子句。而且，若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除。

    select * from mybatis.blog
    <where>
        <if test="title != null">
            title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </where>
    

  • set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号

    <update id="updateBlog" parameterType="map">
        update mybatis.blog
        <set>
            <if test="title != null">
                title = #{title},
            </if>
            <if test="author != null">
                author = #{author}
            </if>
        </set>
        where id = #{id}
    </update>
    

• trim元素可以用来定制类似于where和set标签的功能

  1. trim元素的属性主要有：

     prefix：自定义前缀值

     prefixOverrides：覆盖会导致出错的前缀值

     suffix：自定义后缀值

     suffixOverrides：覆盖会导致出错的后缀值

  2. 和 where元素等价的自定义 trim元素为：

     <!-- 前缀值为WHERE，覆盖前缀值AND |OR （注意空格是必要的） -->
     <trim prefix="WHERE" prefixOverrides="AND |OR ">
       ...
     </trim>
     

  3. 和 set元素等价的自定义 trim元素为：

     <!-- 前缀值为SET，覆盖后缀值逗号 -->
     <trim prefix="SET" suffixOverrides=",">
       ...
     </trim>
     

12.5 SQL片段

• 有的时候，我们可能会将一些功能的部分抽取出来，方便复用！

1. 使用SQL标签抽取公共的部分

   <sql id="if-title-author">
       <if test="title != null">
           title = #{title}
       </if>
       <if test="author != null">
           and author = #{author}
       </if>
   </sql>
   

2. 在需要使用的地方使用Include标签引用即可

   <select id="queryBlogIF" parameterType="map" resultType="blog">
       select * from mybatis.blog
       <where>
           <include refid="if-title-author"></include>
       </where>
   </select>
   

注意事项：

• 最好基于单表来定义SQL片段！
• 不要存在where标签

12.7 Foreach

• Foreach标签能够去遍历集合（List、Set、Map）或者数组

• 我觉得Foreach标签用于条件过多的时候，以及in语句类型的条件很合适

• 以下是官方文档使用Foreach标签的示例：

  1. collection：有四种值 list | set | array | map集合的键。

     为什么是map集合的键？

     ​ 经过测试，当方法的参数传入map集合时，并不能直接遍历该map集合，它只能作为集合或数组的载体，也就是说要使用到map集合的遍历，可以创建一个大map集合，里面再放入一个小map集合，大map集合作为参数传入方法，指定collection属性为大map集合的键，来遍历键对应的值，也就是小map集合。

     ​ 当然，这也体现了万能的map集合，因为可以在map集合中放入多个集合后当做方法参数传入，想遍历哪个集合，指定键即可。

  2. item ： 表示在迭代过程中每一个元素的别名，对于map集合为键值对中的值。

  3. index ：表示在迭代过程中每次迭代到的位置（索引），对于map集合为键值对中的键。

  4. open ：前缀

  5. close ：后缀

  6. separator ：分隔符，表示迭代时每个元素之间以什么分隔

  <select id="selectPostIn" resultType="domain.blog.Post">
    SELECT *
    FROM POST P
    WHERE ID in
    <foreach item="item" index="index" collection="list"
        open="(" separator="," close=")">
          #{item}
    </foreach>
  </select>
  

• Foreach标签用于in条件语句时：

  1. BlogMapper.java

     // 查询第1-2-3号记录的博客
     List<Blog> queryBlogForeach(List list);
     

  2. BlogMapper.xml

     <!-- 对应的sql：select * from blog where id in (?,?,?...) -->
     <select id="queryBlogForeach" parameterType="list" resultType="blog">
         select * from blog where id in
         <foreach collection="list" item="id" open="(" separator="," close=")">
             #{id}
         </foreach>
     </select>
     

  3. 测试类

     @Test
     public void queryBlogForeach() {
         // 1.获取sqlSession对象
         SqlSession sqlSession = MybatisUtils.getSqlSession();
         // 2.获取接口代理对象
         BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
         // 3.创建list集合
         List<String> lists = new ArrayList<>();
         lists.add("1");
         lists.add("2");
         lists.add("3");
         // 4.执行方法
         List<Blog> blogs = mapper.queryBlogForeach(lists);
         // 5.遍历打印
         blogs.forEach(System.out::println);
         // 6.关闭资源
         sqlSession.close();
     }
     ==============================================
     执行结果：
     Blog(id=1, title=Mybatis, author=狂神说, createTime=Tue Jun 02 21:02:16 CST 2020, views=9999)
     Blog(id=2, title=Java, author=狂神说, createTime=Tue Jun 02 21:02:16 CST 2020, views=1000)
     Blog(id=3, title=Spring, author=狂神说, createTime=Tue Jun 02 21:02:16 CST 2020, views=9999)
     

• Foreach标签用于多条件语句时：【自创的】

  1. BlogMapper.java

     // 查询id = "1" 或 title = "Java" 或 author = "帅贱贱说"
     List<Blog> queryBlogForeach3(Map map);
     

  2. BlogMapper.xml

     <!-- 
     	1.参数传递一个万能的map集合，这个map集合中还放着一个map集合，对应的键为map1
     	2.遍历map1集合，map1集合的key我们使用${}占位，因为它不需要预编译，应该直接拼接。
     	3.对应的sql：select * from blog where 1=1 and (key1 = ?,key2 = ?,....)
     	4.嵌套了一个if判定，当map1集合的存在值为null时，该键值对不参与此次语句拼接。
     -->
     <select id="queryBlogForeach3" parameterType="map" resultType="blog">
         select * from blog
         <where>
             <foreach collection="map1" item="val" index="key" open="(" separator="or" close=")">
                 <if test="val != null">
                     ${key} = #{val}
                 </if>
             </foreach>
         </where>
     </select>
     

  3. 测试类

     @Test
     public void queryBlogForeach3() {
         // 1.获取sqlSession对象
         SqlSession sqlSession = MybatisUtils.getSqlSession();
         // 2.获取接口代理对象
         BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);
         // 3.创建两个map集合
         Map maps = new HashMap();
         Map map1 = new HashMap();
         map1.put("id", "1");
         map1.put("title", "Java");
         map1.put("author", "帅贱贱说");
         maps.put("map1", map1);
         // 4.执行方法
         List<Blog> blogs = mapper.queryBlogForeach3(maps);
         // 5.遍历打印
         blogs.forEach(System.out::println);
         // 6.关闭资源
         sqlSession.close();
     }
     =============================================
     执行结果：
     Blog(id=1, title=Mybatis, author=狂神说, createTime=Tue Jun 02 21:02:16 CST 2020, views=9999)
     Blog(id=2, title=Java, author=狂神说, createTime=Tue Jun 02 21:02:16 CST 2020, views=1000)
     Blog(id=4, title=Cloud, author=帅贱贱说, createTime=Tue Jun 02 21:02:16 CST 2020, views=9999)
     

12.8 小结

1. 动态SQL就是指根据不同的条件生成不同的SQL语句

2. 所谓的动态SQL，本质还是SQL语句 ， 只是我们可以在SQL层面，去执行一个逻辑代码。

3. 动态SQL就是在拼接SQL语句，我们只要保证SQL的正确性，按照SQL的格式，去排列组合就可以了

4. 建议：

   先在Mysql中写出完整的SQL,再对应的去修改成为我们的动态SQL实现通用即可！

13、缓存 （了解）

13.1、简介

查询  ：  连接数据库 ，耗资源！
	一次查询的结果，给他暂存在一个可以直接取到的地方！--> 内存 ： 缓存
	
我们再次查询相同数据的时候，直接走缓存，就不用走数据库了

1. 什么是缓存 [ Cache ]？

   • 存在内存中的临时数据。
   • 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。

2. 为什么使用缓存？

   • 减少和数据库的交互次数，减少系统开销，提高系统效率。

3. 什么样的数据能使用缓存？

   • 经常查询并且不经常改变的数据。【可以使用缓存】

4. 什么样的数据不能使用缓存？

   • 不经常查询或者经常改变的数据。【不使用缓存】

13.2、Mybatis缓存

• MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
• MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存

  • 默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存，意思是在同一次SqlSession创建到关闭之间相同的查询结果放入缓存）

  • 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。

  • 为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

13.3、一级缓存

• 一级缓存也叫本地缓存： SqlSession
  • 与数据库同一次会话期间查询到的数据会放在本地缓存中。
  • 以后如果需要获取相同的数据，直接从缓存中拿，没必须再去查询数据库；

• 测试一级缓存步骤：

1. 开启日志！
2. 测试在一个Sesion中查询两次相同记录
3. 查看日志输出

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-fe04E72V-1602519093900)(Mybatis课堂笔记.assets/1569983650437.png)]

• 缓存失效的情况：

1. 查询不同的东西

2. 增删改操作，可能会改变原来的数据，所以必定会刷新缓存！

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6R9bQt3W-1602519093901)(Mybatis课堂笔记.assets/1569983952321.png)]

3. 查询不同的Mapper.xml

4. 手动清理缓存！

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GVwdSp9S-1602519093902)(Mybatis课堂笔记.assets/1569984008824.png)]

• 小结：一级缓存默认是开启的，只在一次SqlSession中有效，也就是拿到连接到关闭连接这个区间段！

  一级缓存就是一个Map。

13.4、二级缓存

• 二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存
• 基于namespace级别的缓存，一个名称空间，对应一个二级缓存；
• 工作机制
  • 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中；
  • 如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中；
  • 新的会话查询信息，就可以从二级缓存中获取内容；
  • 不同的mapper查出的数据会放在自己对应的缓存（map）中；

步骤：

1. 开启全局缓存

   <!--显示的开启全局缓存-->
   <setting name="cacheEnabled" value="true"/>
   

2. 在要使用二级缓存的Mapper中开启

   <!--在当前Mapper.xml中使用二级缓存-->
   <cache/>
   

   也可以自定义参数

   <!--
   	1.eviction：清除策略
   		* LRU – 最近最少使用：移除最长时间不被使用的对象。
   		* FIFO – 先进先出：按对象进入缓存的顺序来移除它们。
   		* SOFT – 软引用：基于垃圾回收器状态和软引用规则移除对象。
   		* WEAK – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。
   	2.flushInterval：刷新间隔，单位ms，正整数
   	3.size：引用数目，正整数
   	4.readOnly：只读属性，可以被设置为 true 或 false
   -->
   <cache  eviction="FIFO"
          flushInterval="60000"
          size="512"
          readOnly="true"/>
   

3. 测试

   1. 出现问题：

      当我们在<cache>标签中不设置只读属性readOnly为true时，测试时报错。

      Caused by: java.io.NotSerializableException: com.kuang.pojo.User
      

   2. 问题原因：没有进行实体类的序列化

   3. 解决方案：让实体类序列化

      @Data
      @AllArgsConstructor
      @NoArgsConstructor
      // 序列化实体类
      public class User implements Serializable {
          private int id;
          private String name;
          private String pwd;
      }
      

小结：

• 只要开启了二级缓存，在同一个Mapper下就有效
• 所有的数据都会先放在一级缓存中；
• 只有当会话提交或者关闭的时候，才会提交到二级缓冲中！

13.5、缓存原理

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-frKNQkx6-1602519093903)(Mybatis课堂笔记.assets/1569985541106.png)]

• 读取缓存的顺序
  1. 先看二级缓存中有没有
  2. 再看一级缓存中有没有
  3. 都没有就在数据库中查找

13.6、自定义缓存-ehcache

Ehcache是一种广泛使用的开源Java分布式缓存。主要面向通用缓存

要在程序中使用ehcache，先要导包！

<!-- https://mvnrepository.com/artifact/org.mybatis.caches/mybatis-ehcache -->
<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-ehcache</artifactId>
    <version>1.1.0</version>
</dependency>

在mapper中指定使用我们的ehcache缓存实现！

<!--在当前Mapper.xml中使用二级缓存-->
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!--
       diskStore：为缓存路径，ehcache分为内存和磁盘两级，此属性定义磁盘的缓存位置。参数解释如下：
       user.home – 用户主目录
       user.dir  – 用户当前工作目录
       java.io.tmpdir – 默认临时文件路径
     -->
    <diskStore path="./tmpdir/Tmp_EhCache"/>
    
    <defaultCache
            eternal="false"
            maxElementsInMemory="10000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="259200"
            memoryStoreEvictionPolicy="LRU"/>
 
    <cache
            name="cloud_user"
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="1800"
            memoryStoreEvictionPolicy="LRU"/>
    <!--
       defaultCache：默认缓存策略，当ehcache找不到定义的缓存时，则使用这个缓存策略。只能定义一个。
     -->
    <!--
      name:缓存名称。
      maxElementsInMemory:缓存最大数目
      maxElementsOnDisk：硬盘最大缓存个数。
      eternal:对象是否永久有效，一但设置了，timeout将不起作用。
      overflowToDisk:是否保存到磁盘，当系统当机时
      timeToIdleSeconds:设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
      timeToLiveSeconds:设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
      diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
      diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
      diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
      memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
      clearOnFlush：内存数量最大时是否清除。
      memoryStoreEvictionPolicy:可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
      FIFO，first in first out，这个是大家最熟的，先进先出。
      LFU， Less Frequently Used，就是上面例子中使用的策略，直白一点就是讲一直以来最少被使用的。如上面所讲，缓存的元素有一个hit属性，hit值最小的将会被清出缓存。
      LRU，Least Recently Used，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
   -->

</ehcache>

Redis数据库来做缓存！ K-V

练习：29道练习题实战！

upId>
mybatis-ehcache
1.1.0

在mapper中指定使用我们的ehcache缓存实现！

```xml
<!--在当前Mapper.xml中使用二级缓存-->
<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>

ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    <!--
       diskStore：为缓存路径，ehcache分为内存和磁盘两级，此属性定义磁盘的缓存位置。参数解释如下：
       user.home – 用户主目录
       user.dir  – 用户当前工作目录
       java.io.tmpdir – 默认临时文件路径
     -->
    <diskStore path="./tmpdir/Tmp_EhCache"/>
    
    <defaultCache
            eternal="false"
            maxElementsInMemory="10000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="259200"
            memoryStoreEvictionPolicy="LRU"/>
 
    <cache
            name="cloud_user"
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="1800"
            memoryStoreEvictionPolicy="LRU"/>
    <!--
       defaultCache：默认缓存策略，当ehcache找不到定义的缓存时，则使用这个缓存策略。只能定义一个。
     -->
    <!--
      name:缓存名称。
      maxElementsInMemory:缓存最大数目
      maxElementsOnDisk：硬盘最大缓存个数。
      eternal:对象是否永久有效，一但设置了，timeout将不起作用。
      overflowToDisk:是否保存到磁盘，当系统当机时
      timeToIdleSeconds:设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
      timeToLiveSeconds:设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
      diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
      diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
      diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
      memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
      clearOnFlush：内存数量最大时是否清除。
      memoryStoreEvictionPolicy:可选策略有：LRU（最近最少使用，默认策略）、FIFO（先进先出）、LFU（最少访问次数）。
      FIFO，first in first out，这个是大家最熟的，先进先出。
      LFU， Less Frequently Used，就是上面例子中使用的策略，直白一点就是讲一直以来最少被使用的。如上面所讲，缓存的元素有一个hit属性，hit值最小的将会被清出缓存。
      LRU，Least Recently Used，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
   -->

</ehcache>

Redis数据库来做缓存！ K-V

练习：29道练习题实战！