基于狂神说Mybatis笔记总结

Mybatis-9.28

环境：

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

1、简介

1.1、什么是Mybatis

• 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。

如何获得Mybatis？

• maven仓库
• Mybatis官方文档 : http://www.mybatis.org/mybatis-3/zh/index.html
• GitHub : https://github.com/mybatis/mybatis-3

1.2、持久化

数据持久化

• 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
• 内存：断电即失
• 数据库(jdbc),io文件持久化
• 生活：冷藏、罐头

为什么需要持久化？

• 有一些对象，不能让他丢掉
• 内存太贵了

1.3、持久层

Dao层、Service层、Controller层…

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

1.4、为什么需要Mybatis层

• 帮助程序员将数据存入到数据库中
• 方便
• 传统的JDBC代码太复杂的
• 不用Mybatis也可以，更容易上手，技术没有高低之分

• MyBatis的优点
• • 简单易学：本身就很小且简单。没有任何第三方依赖，最简单安装只要两个jar文件+配置几个sql映射文件就可以了，易于学习，易于使用，通过文档和源代码，可以比较完全的掌握它的设计思路和实现。
  • 灵活：mybatis不会对应用程序或者数据库的现有设计强加任何影响。sql写在xml里，便于统一管理和优化。通过sql语句可以满足操作数据库的所有需求。
  • 解除sql与程序代码的耦合：通过提供DAO层，将业务逻辑和数据访问逻辑分离，使系统的设计更清晰，更易维护，更易单元测试。sql和代码的分离，提高了可维护性。
  • 提供xml标签，支持编写动态sql。
  • …
• 最重要的一点，使用的人多！公司需要！

2、第一个Mybatis程序

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

2.1、搭建环境

• 搭建数据库

CREATE TABLE `user` (
  `id` int NOT NULL AUTO_INCREMENT,
  `name` varchar(30) DEFAULT NULL,
  `pwd` varchar(30) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;
INSERT INTO `mybatis`.`user`(`id`, `name`, `pwd`) VALUES (1, '狂神', '123456');
INSERT INTO `mybatis`.`user`(`id`, `name`, `pwd`) VALUES (2, '张三', '123456');
INSERT INTO `mybatis`.`user`(`id`, `name`, `pwd`) VALUES (3, '李四', '123456');

新建项目

1. 新建一个maven项目
2. 删除src目录
3. 导入maven依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.hui</groupId>
    <artifactId>Myabtis-Study</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>mybatis-01</module>
    </modules>
    <!--父工程-->
    <dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
        </dependency>
    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
                <filtering>false</filtering>
            </resource>

            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>
</project>

2.2、创建一个模板

• 编写mybatis的核心配置文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF8&amp;serverTimeZone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/hui/dao/UserMapper.xml"/>
    </mappers>
</configuration>

• 编写mybatis的工具类

package com.hui.utils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;

    static{
        String resource="mybatis-config.xml";
        InputStream inputStream = null;
        try {
            //获取sqlsessionfactory对象
            inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
    //既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例。
    //SqlSession 提供了在数据库执行 SQL 命令所需的所有方法。你可以通过 SqlSession 实例来直接执行已映射的 SQL 语句。

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

}

2.3、编写代码

• 实体类

package com.hui.pojo;

public class User {
    private int id;
    private String name;
    private String 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;
    }

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

• Dao接口

package com.hui.pojo;

public class User {
    private int id;
    private String name;
    private String 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;
    }

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
}

• 接口实现类由原来的USerDaoImpl转换成一个Mapper.xml的配置文件

<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.hui.dao.UserMapper">
   <select id="getUserList" resultType="com.hui.pojo.User">
       select * from mybatis.user;
   </select>
    <select id="getUserById" parameterType="int" resultType="com.hui.pojo.User">
       select * from mybatis.user where id=#{id}
    </select>
    <insert id="addUser" parameterType="com.hui.pojo.User">
        insert into mybatis.user(id,name,pwd) values(#{id},#{name},#{pwd});
    </insert>
    <update id="updateUser" parameterType="com.hui.pojo.User">
        update mybatis.user set name=#{name},pwd=#{pwd} where id=#{id};
    </update>
    <delete id="deleteUser" parameterType="int">
        delete from mybatis.user where id=#{id};
    </delete>
</mapper>

2.4、测试类

• junit测试

package com.hui.dao;

import com.hui.pojo.User;
import com.hui.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserMapperTest {

    @Test
    public void getUserById(){
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        User user=mapper.getUserById(1);
        System.out.println(user);
        sqlSession.close();
    }
    @Test
    public void addUser(){
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        int res = mapper.addUser(new User(4, "haha", "123333"));
        if(res>0){
            System.out.print("插入成功");
        }
        //提交事务
        sqlSession.commit();
        sqlSession.close();

    }
    @Test
    public void updateUser(){
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        int res = mapper.updateUser(new User(4, "hehe", "123333"));
        if(res>0){
            System.out.print("更新成功");
        }
        //提交事务
        sqlSession.commit();
        sqlSession.close();

    }
    @Test
    public void deleteUser(){
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        int res = mapper.deleteUser(4);
        if(res>0){
            System.out.print("删除成功");
        }
        //提交事务
        sqlSession.commit();
        sqlSession.close();

    }
}

2.5、可能会出现的问题

• 配置文件没有注册

  //mybatis-config.xml
  <mappers>
          <mapper resource="com/hui/dao/UserMapper.xml"/>
   </mappers>
  

• 绑定接口错误

​

• 方法名不对

• 返回类型不对

• Maven导出资源问题

   //pom.xml   
     <build>
          <resources>
              <resource>
                  <directory>src/main/java</directory>
                  <includes>
                      <include>**/*.xml</include>
                      <include>**/*.properties</include>
                  </includes>
                  <filtering>false</filtering>
              </resource>
  
              <resource>
                  <directory>src/main/resources</directory>
                  <includes>
                      <include>**/*.xml</include>
                      <include>**/*.properties</include>
                  </includes>
                  <filtering>false</filtering>
              </resource>
          </resources>
      </build>
  

3、CRUD

3.1、namespace

namespace中的包名要和Dao/mapper保持一致

3.2、select

选择，查询语句：

• id:就是对应的namespace中的方法名
• resultType：SQL语句的返回值
• parameterType：参数类型

UserMapper:

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

UserMapper.xml:

<select id="getUserById" parameterType="int" resultType="com.hui.pojo.User">
       select * from mybatis.user where id=#{id}

Test:

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

3.3、insert

  //插入一个用户
    int addUser(User user);

 <insert id="addUser" parameterType="com.hui.pojo.User">
        insert into mybatis.user(id,name,pwd) values(#{id},#{name},#{pwd});
    </insert>

  @Test
    public void addUser(){
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        int res = mapper.addUser(new User(4, "haha", "123333"));
        if(res>0){
            System.out.print("插入成功");
        }
        //提交事务
        sqlSession.commit();
        sqlSession.close();

    }

3.4、update

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

3.5、delete

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

注意点：增删改需要提交事务

3.6、万能Map

​ 假设，我们的实体类、或者书库剧中的表、字段或者参数过多，我们应当考虑使用map。

 int addUser2(Map<String,Object> map);

 <insert id="addUser2" parameterType="map">
        insert into mybatis.user(id,name,pwd) values(#{userid},#{username},#{userpwd});
    </insert>

 @Test
    public void addUser2(){
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper mapper=sqlSession.getMapper(UserMapper.class);
        HashMap<String, Object> map= new HashMap<String, Object>();
        map.put("userid",5);
        map.put("username","hello");
        map.put("userpwd","2223");
        int res = mapper.addUser2(map);
        if(res>0){
            System.out.print("插入成功");
        }
        //提交事务
        sqlSession.commit();
        sqlSession.close();

    }

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

对象传递参数，直接在SQL中取对象的属性即可！

只有一个参数的情况下，可以直接在SQL取出即可！

多个参数用map或注解！

3.7、思考题

• 模糊查询

1. Java代码执行的时候，传递通配符%%

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

2. 在SQL拼接中使用通配符

select * from mybatis.user where name like "%"#{value}"%"

4、配置解析

4.1、核心配置文件

• mybatis-config.xml
• MyBatis的配置文件包含了会深深影响MyBatis行为的设置和属性信息

    configuration（配置）
    properties（属性）
    settings（设置）
    typeAliases（类型别名）
    typeHandlers（类型处理器）
    objectFactory（对象工厂）
    plugins（插件）
    environments（环境配置）
    environment（环境变量）
    transactionManager（事务管理器）
    dataSource（数据源）
    databaseIdProvider（数据库厂商标识）
    mappers（映射器）

4.2、环境配置（environments）

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

学会使用配置多套运行环境

Mybatis默认的事务管理器就是JDBC，连接池：

4.3、 properties（属性）

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

• 

• 这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。【db.properties】

• 编写一个配置文件

  driver="com.mysql.cj.jdbc.Driver"
  url="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF8&serverTimeZone=UTC"
  username="root"
  password="root"
  

  • 在核心配置文件中引入

    <properties resource="org/mybatis/example/config.properties">
      <property name="username" value="dev_user"/>
      <property name="password" value="F2Fa3!33TYyg"/>
    </properties>
    

• 可以直接引入外部文件

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

• 如果两个文件有同一个字段，优先使用外部配置文件的

4.4、typeAliases（类型别名）

类型别名可为 Java 类型设置一个缩写名字。 它仅用于 XML 配置，意在降低冗余的全限定类名书写。

	<typeAliases>
        <typeAlias type="com.hui.pojo.User" alias="User"></typeAlias>
 	</typeAliases>

也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean。

每一个在包 domain.blog 中的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名。

    <typeAliases>
        <package name="com.hui.pojo"/>
    </typeAliases>

在实体类比较少的时候建议使用第一种，否则第二种

注意：第一种可以DIY,第二种则不行，如果非要改，需要在实体类上加上注释

//注解
@Alias("author")
public class Author {
    ...
}

4.5、 settings（设置）

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

4.6、其他配置

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

4.7、映射器

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

方式一：[推荐使用]

<mappers>
       <mapper resource="com/hui/dao/UserMapper.xml"/>
</mappers>

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

<mappers>  
        <mapper class="com.hui.dao.UserMapper"/>
</mappers>

注意点：

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

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

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

注意点：

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

4.8、生命周期和作用域

• 理解我们目前已经讨论过的不同作用域和生命周期类是至关重要的，因为错误的使用会导致非常严重的并发问题。

• 我们可以先画一个流程图，分析一下Mybatis的执行过程！

SqlSessionFactoryBuilder:

• 一旦创建了SqlSessionFactory，就不再需要他了
• 局部变量

SqlSessionFactory：

• 说白了就是想象为：数据库连接池
• SqlSessionFactory 一旦被创建就应该在应用的运行期间一直存在，没有任何理由丢弃它或重新创建另一个实例。 使用 SqlSessionFactory 的最佳实践是在应用运行期间不要重复创建多次，多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。因此 SqlSessionFactory 的最佳作用域是应用作用域。 有很多方法可以做到，最简单的就是使用单例模式或者静态单例模式。

SqlSession：

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

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

5.1、问题

数据库中的字段：

• 解决方法

  1. 起别名

     select id,name,pwd as password from user;

  2. resultMap

   <resultMap id="UserMap" type="User">
          <!--column字段》 映射》 propery实体类的属性-->
          <result column="id" property="id"></result>
          <result column="name" property="name"></result>
          <result column="pwd" property="password"></result>
  </resultMap>
  

5.2、ResultMap（结果集映射）

• ResultMap元素是Mybatis中最重要最强大的元素
• ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
• 如果这个世界总是这么简单就好了。

6、日志

6.1、日志工厂

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

曾经：sout、debug

现在：日志工厂

在mybatis中具体使用哪个日志实现，在设置（settings）中设定！

STDOUT_LOGGING 标准日志输出

• 在mybatis核心文件中配置日志

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

6.2、Log4j

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

1. 先导入Log4j的包

<dependency>
   <groupId>log4j</groupId>
   <artifactId>log4j</artifactId>
   <version>1.2.17</version>
</dependency>

2. 配置文件编写

#将等级为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/hui.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>
        <!--log4j-->
        <setting name="logImpl" value="LOG4J"/>
  </settings>

4. Log4j的使用！

简单使用

1. 在要使用Log4j的类中，导入包 import org.apache.log4j.Logger;
2. 日志对象，参数为当前类的class

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

3. 日志级别

  @Test
    public void testlog4j(){
        logger.info("info:进入了testLog4j");
        logger.debug("debug:进入了testLog4j");
        logger.debug("error:进入了testLog4j");
    }

7、分页

思考：为什么需要分页？

• 在学习mybatis等持久层框架的时候，会经常对数据进行增删改查操作，使用最多的是对数据库进行查询操作，如果查询大量数据的时候，我们往往使用分页进行查询，也就是每次处理小部分数据，这样对数据库压力就在可控范围内。

7.1、使用Limit实现分页

#语法
SELECT * FROM table LIMIT stratIndex，pageSize

SELECT * FROM table LIMIT 5,10; // 检索记录行 6-15  

#为了检索从某一个偏移量到记录集的结束所有的记录行，可以指定第二个参数为 -1：   
SELECT * FROM table LIMIT 95,-1; // 检索记录行 96-last.  

#如果只给定一个参数，它表示返回最大的记录行数目：   
SELECT * FROM table LIMIT 5; //检索前 5 个记录行  

#换句话说，LIMIT n 等价于 LIMIT 0,n。 

使用Mybatis实现分页，核心SQL

1. 接口

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

2. Mapper.xml

   <resultMap id="UserMap" type="User">
           <!--column字段》 映射》 propery实体类的属性-->
           <result column="id" property="id"></result>
           <result column="name" property="name"></result>
           <result column="pwd" property="pwd"></result>
       </resultMap>
       <select id="getUserByLimit" parameterType="map" resultMap="UserMap">
           select * from mybatis.user limit #{startIndex},#{pageSize}
       </select>
   

3. 测试

@Test
public void getUserByLimit(){
    SqlSession sqlSession =MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    HashMap<String, Integer> map = new HashMap<String, Integer>();
    map.put("startIndex",1);
    map.put("pageSize",2);

    List<User> userList = mapper.getUserByLimit(map);
    for (User user:userList) {
        System.out.println(user);
    }
    sqlSession.close();
}

7.2、RowBounds分页

我们除了使用Limit在SQL层面实现分页，也可以使用RowBounds在Java代码层面实现分页，当然此种方式作为了解即可。我们来看下如何实现的！

步骤：

1、mapper接口

//选择全部用户RowBounds实现分页
List<User> getUserByRowBounds();
12

2、mapper文件

<select id="getUserByRowBounds" resultType="user">
select * from user
</select>
123

3、测试类

在这里，我们需要使用RowBounds类

@Test
public void testUserByRowBounds() {
   SqlSession session = MybatisUtils.getSession();

   int currentPage = 2;  //第几页
   int pageSize = 2;  //每页显示几个
   RowBounds rowBounds = new RowBounds((currentPage-1)*pageSize,pageSize);

   //通过session.**方法进行传递rowBounds，[此种方式现在已经不推荐使用了]
   List<User> users =session.selectList("com.kuang.mapper.UserMapper.getUserByRowBounds", null,rowBounds);

   for (User user: users){
       System.out.println(user);
  }
   session.close();
}

7.3、分页插件

了解即可，万一以后公司的架构师说要使用，要知道是什么东西！

8、使用注解开发

8.1、面向接口编程

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

关于接口的理解

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

三个面向区别

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

8.2、使用注解开发

• mybatis最初配置信息是基于 XML ,映射语句(SQL)也是定义在 XML 中的。而到MyBatis 3提供了新的基于注解的配置。不幸的是，Java 注解的的表达力和灵活性十分有限。最强大的 MyBatis 映射并不能用注解来构建
• sql 类型主要分成 :
• • @select ()
  • @update ()
  • @Insert ()
  • @delete ()

**注意：**利用注解开发就不需要mapper.xml映射文件了 .

1. 注解在接口上实现

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

2. 需要在核心配置文件中绑定

    <!--绑定接口-->
   <mappers>
       <mapper class="com.hui.dao.UserMapper"/>
   </mappers>
   

3. 测试

    @Test
       public void test(){
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           //底层主要应用反射
           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
           List<User> users = mapper.getUsers();
           for(User user:users){
               System.out.println(user);
           }
           sqlSession.close();
       }
   

本质：反射机制实现

底层：动态代理！

Mybatis详细执行流程

8.3、CRUD

自动提交事务

改造MybatisUtils工具类的getSession( ) 方法，实现事务的自动提交。

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

编写接口，增加注解

public interface UserMapper {
    @Select("select * from mybatis.user")
    List<User> getUsers();
    
    //根据ID查询用户 方法包括多个参数 必须加上@Param
    @Select("select * from mybatis.user where id=#{id}")
    User getUserById(@Param("id") int id2);
   
    //插入一个用户
    @Insert("insert into mybatis.user(id,name,pwd) values (#{id},#{name},#{password})")
    int addUser(User user);
    //更新
    @Update("update mybatis.user set name=#{name},pwd=#{password} where id=#{id}")
    int updateUser(User user);
    //删除
    @Delete("delete from mybatis.user where id=#{uid}")
    int deleteUser(@Param("uid") int id);
}

测试类

public class UserMapperTest {
    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //底层主要应用反射

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
//        查询所有用户
//        List<User> users = mapper.getUsers();
//        for(User user:users){
//            System.out.println(user);
//        }
//        根据ID查询用户
//        User user=mapper.getUserById(1);
//        System.out.print(user);
//        添加用户
//        mapper.addUser(new User(8,"wemwem","123212"));
//        修改用户
//        mapper.updateUser(new User(5,"to","132312"));
//        删除用户
        mapper.deleteUser(8 );
        sqlSession.close();
    }
}

【注意：我们必须要将接口注册绑定都核心配置文件中！】

关于@param()注解

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

#{} ${} 区别

#{}相当于预编译更安全 ${}相当于编译

使用注解和配置文件协同开发，才是MyBatis的最佳实践！

9、Lombok

• java库
• 插件
• 构建工具
• get/set toString 构造方法使用注解开发

使用步骤

1. 在IDEA安装Lombok插件

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

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

3. 在实体类加注解简化

Features
@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
experimental @var
@UtilityClass

说明：

@Data:无参构造、get、set、tostring、hashcode、equals
@AllArgsConstructor:有参，但无参会被覆盖
@NoArgsConstructor：无参

有利有弊，看个人选择，长期使用导致代码的遗忘！

10、多对一处理

多对一的理解：

• 多个学生对应一个老师
• 如果对于学生这边，就是一个多对一的现象，即从学生这边关联一个老师！

数据库设计

CREATE TABLE `teacher` (
  `id` int NOT NULL,
  `name` varchar(30) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

CREATE TABLE `student` (
  `id` int NOT NULL,
  `name` varchar(30) DEFAULT NULL,
  `tid` int DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `fk_tid` (`tid`),
  CONSTRAINT `fk_tid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;

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

INSERT INTO `mybatis`.`teacher`(`id`, `name`) VALUES (1, '王老师');

10.1、测试环境搭建

1. 导入lombok
2. 新建实体类Teacher，Student
3. 建立Mapper接口
4. 建立Mapper.XML文件
5. 在核心配置文件中绑定注册我们的Mapper接口或者文件！【方式很多，随心选】
6. 测试查询是否能成功

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private int id;
    private String name;
    //学生要关联一个老师
    private Teacher teacher;
}  
    
 //  查询所有的学生信息，以及对应的老师信息
    public List<Student> getStudent();

    public List<Student> getStudent2();

 public static void main(String[] args){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> student = mapper.getStudent2();
        for (Student student1 : student) {
            System.out.println(student1);
        }
        sqlSession.close();
    }

10.2、按照查询嵌套查询（子查询）

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

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

    <resultMap id="StudentTeacher" type="Student">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        <!--复杂的属性，我们需要单独处理
            对象：association
            集合：collection
        -->
        <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
    </resultMap>
    <select id="getTeacher" resultType="Teacher">
        select * from mybatis.teacher where id=#{id}
    </select>

10.3、按照结果嵌套查询（联表查询）

  <!--按照结果嵌套查询-->
    <select id="getStudent2" resultMap="StudentTeacher2">
          select s.id sid,s.name sname, t.id tid,t.name tname
          from mybatis.student s,mybatis.teacher t
          where s.tid=t.id
    </select>
    <resultMap id="StudentTeacher2" type="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="Teacher">
            <result property="id" column="tid"/>
            <result property="name" column="tname"/>
        </association>
    </resultMap>

11、一对多的处理

一对多的理解：

• 一个老师拥有多个学生
• 如果对于老师这边，就是一个一对多的现象，即从一个老师下面拥有一群学生（集合）！

11.1、环境搭建

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student {
    private int id;
    private String name;
    private int tid;
}
@NoArgsConstructor
@AllArgsConstructor
@Data
public class Teacher {
    private int id;
    private String name;
    //  一个老师拥有多个学生
    private List<Student> students;
}
public interface TeacherMapper {
    //获取老师
    List<Teacher> getTeacher();
    //获取指定老师下的所有学生及老师的信息
    Teacher getTeacher(@Param("tid") int id);
}
 @Test
public void studentTest(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
    Teacher teacher = mapper.getTeacher(1);
    System.out.println(teacher);
    sqlSession.close();
}
}

11.2、按照结果嵌套查询（联表查询）

  <!--按照结果嵌套查询-->
    <select id="getTeacher" resultMap="TeacherStudent">
           select s.id sid,s.name sname,t.name tname,t.id tid
           from mybatis.student s,mybatis.teacher t
           where s.tid=t.id and t.id=#{tid}
        </select>
    <resultMap id="TeacherStudent" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <!--复杂的属性，我们需要单独处理
           对象：association
           集合：collection
           javaType=""指定属于的类型
           集合中的泛型信息，我们使用oftype获取
       -->
        <collection property="students" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

11.3、按照查询嵌套查询（子查询）

 <select id="getTeacher2" resultMap="TeacherStudent2">
        select * from mybatis.teacher where id=#{tid}
    </select>
    <resultMap id="TeacherStudent2" type="Teacher">
        <collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id"/>
    </resultMap>
    <select id="getStudentByTeacherId" resultType="Student">
        select * from mybatis.student where tid=#{tid}
    </select>

小结

1. 关联-association【多对一】
2. 集合-collection【一对多】
3. javaType与ofType
   • JavaType用来指定实体类中属性的类型
   • ofType用来映射到List或者集合中的Pojo类型，泛型中的约束类型

注意：推荐联表查询，因人而异，选择适合自己的

12、动态SQL

什么是动态SQL？

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

官网描述：
MyBatis 的强大特性之一便是它的动态 SQL。如果你有使用 JDBC 或其它类似框架的经验，你就能体会到根据不同条件拼接 SQL 语句的痛苦。例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL 这一特性可以彻底摆脱这种痛苦。
虽然在以前使用动态 SQL 并非一件易事，但正是 MyBatis 提供了可以被用在任意 SQL 映射语句中的强大的动态 SQL 语言得以改进这种情形。
动态 SQL 元素和 JSTL 或基于类似 XML 的文本处理器相似。在 MyBatis 之前的版本中，有很多元素需要花时间了解。MyBatis 3 大大精简了元素种类，现在只需学习原来一半的元素便可。MyBatis 采用功能强大的基于 OGNL 的表达式来淘汰其它大部分元素。

  -------------------------------
  - if
  - choose (when, otherwise)
  - trim (where, set)
  - foreach
  -------------------------------

12.1、搭建环境

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
    
INSERT INTO `mybatis`.`blog`(`id`, `title`, `author`, `create_time`, `views`) VALUES ('46f0ae15ae9249c7936a0344f99f3971', 'Spring如此简单', '狂神说', '2022-06-15 07:51:06', 9999);
INSERT INTO `mybatis`.`blog`(`id`, `title`, `author`, `create_time`, `views`) VALUES ('6d4dba899bfd481ab153d7db9928dd51', 'Java如此简单', '狂神说', '2022-06-15 07:51:06', 9999);
INSERT INTO `mybatis`.`blog`(`id`, `title`, `author`, `create_time`, `views`) VALUES ('7f7b1be4d10d4ac1b28a86dcf92c53b4', '微服务如此简单', '狂神说', '2022-06-15 07:51:06', 9999);
INSERT INTO `mybatis`.`blog`(`id`, `title`, `author`, `create_time`, `views`) VALUES ('d3cf83da92a143b0818350deae74f148', 'Mybatis如此简单', '狂神说', '2022-06-15 07:51:06', 9999);

1、创建Mybatis基础工程

12.2、IF

<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>
            
 @Test
    public void testQueryBlogIf(){
        SqlSession session = MybatisUtils.getSqlSession();
        BlogMapper mapper = session.getMapper(BlogMapper.class);

        HashMap<String, String> map = new HashMap<String, String>();
        map.put("title","Java如此简单");
        map.put("author","狂神说");
        List<Blog> blogs = mapper.queryBlogIF(map);
        for(Blog blog:blogs){
            System.out.println(blog);
        }

        session.close();
    }            

12.3、trim (where, set)

where

 <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>
        </where>
</select>

Created connection 81412691.
==>  Preparing: select * from blog WHERE title = ? and author = ?

这个“where”标签会知道如果它包含的标签中有返回值的话，它就插入一个‘where’。此外，如果标签返回的内容是以AND 或OR 开头的，则它会剔除掉。

set

同理，上面的对于查询 SQL 语句包含 where 关键字，如果在进行更新操作的时候，含有 set 关键词，我们怎么处理呢？

1、编写接口方法

int updateBlog(Map map);

2、sql配置文件

<!--注意set是用的逗号隔开-->
<update id="updateBlog" parameterType="map">
  update blog
     <set>
         <if test="title != null">
            title = #{title},
         </if>
         <if test="author != null">
            author = #{author}
         </if>
     </set>
  where id = #{id};
</update>
12345678910111213

3、测试

@Test
public void testUpdateBlog(){
   SqlSession session = MybatisUtils.getSession();
   BlogMapper mapper = session.getMapper(BlogMapper.class);

   HashMap<String, String> map = new HashMap<String, String>();
   map.put("title","动态SQL");
   map.put("author","秦疆");
   map.put("id","9d6a763f5e1347cebda43e2a32687a77");

   mapper.updateBlog(map);


   session.close();
}

Created connection 694452085.
==>  Preparing: update blog SET title = ?, author = ? where id = ?;

12.4、choose (when, otherwise)

有时候，我们不想用到所有的查询条件，只想选择其中的一个，查询条件有一个满足即可，使用 choose 标签可以解决此类问题，类似于 Java 的 switch 语句

1、编写接口方法

List<Blog> queryBlogChoose(Map map);

2、sql配置文件

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

3、测试类

@Test
public void testQueryBlogChoose(){
   SqlSession session = MybatisUtils.getSession();
   BlogMapper mapper = session.getMapper(BlogMapper.class);

   HashMap<String, Object> map = new HashMap<String, Object>();
   map.put("title","Java如此简单");
   //map.put("author","狂神说");
   //map.put("views",9999);
   List<Blog> blogs = mapper.queryBlogChoose(map);

   System.out.println(blogs);

   session.close();
}

//对应结果
Created connection 1659367709.
==>  Preparing: select * from blog WHERE title = ?
==> Parameters: Java如此简单(String)
<==    Columns: id, title, author, create_time, views
<==        Row: 6d4dba899bfd481ab153d7db9928dd51, Java如此简单, 狂神说, 2022-06-15 07:51:06, 9999
<==      Total: 1

Created connection 1346201722.
==>  Preparing: select * from blog WHERE author = ?
==> Parameters: 狂神说(String)
<==    Columns: id, title, author, create_time, views
<==        Row: 46f0ae15ae9249c7936a0344f99f3971, Spring如此简单, 狂神说, 2022-06-15 07:51:06, 9999
<==        Row: 6d4dba899bfd481ab153d7db9928dd51, Java如此简单, 狂神说, 2022-06-15 07:51:06, 9999
<==        Row: 7f7b1be4d10d4ac1b28a86dcf92c53b4, 微服务如此简单, 狂神说, 2022-06-15 07:51:06, 9999
<==        Row: d3cf83da92a143b0818350deae74f148, Mybatis如此简单, 狂神说, 2022-06-15 07:51:06, 9999
    
    
Created connection 1346201722.
==>  Preparing: select * from blog WHERE views = ?
==> Parameters: 9999(Integer)
<==    Columns: id, title, author, create_time, views
<==        Row: 46f0ae15ae9249c7936a0344f99f3971, Spring如此简单, 狂神说, 2022-06-15 07:51:06, 9999
<==        Row: 6d4dba899bfd481ab153d7db9928dd51, Java如此简单, 狂神说, 2022-06-15 07:51:06, 9999
<==        Row: 7f7b1be4d10d4ac1b28a86dcf92c53b4, 微服务如此简单, 狂神说, 2022-06-15 07:51:06, 9999
<==        Row: d3cf83da92a143b0818350deae74f148, Mybatis如此简单, 狂神说, 2022-06-15 07:51:06, 9999
<==      Total: 4

SQL片段

有时候可能某个 sql 语句我们用的特别多，为了增加代码的重用性，简化代码，我们需要将这些代码抽取出来，然后使用时直接调用。

提取SQL片段：

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

引用SQL片段：

<select id="queryBlogIf" parameterType="map" resultType="blog">
  select * from blog
   <where>
       <!-- 引用 sql 片段，如果refid 指定的不在本文件中，那么需要在前面加上 namespace -->
       <include refid="if-title-author"></include>
       <!-- 在这里还可以引用其他的 sql 片段 -->
   </where>
</select>
12345678

注意：

①、最好基于 单表来定义 sql 片段，提高片段的可重用性

②、在 sql 片段中不要包括 where

12.5、Foreach

将数据库中前三个数据的id修改为1,2,3；

需求：我们需要查询 blog 表中 id 分别为1,2,3的博客信息

1、编写接口

List<Blog> queryBlogForeach(Map map);

2、编写SQL语句

<select id="queryBlogForeach" parameterType="map" resultType="blog">
  select * from blog
   <where>
       <!--
       collection:指定输入对象中的集合属性
       item:每次遍历生成的对象
       open:开始遍历时的拼接字符串
       close:结束时拼接的字符串
       separator:遍历对象之间需要拼接的字符串
       select * from blog where 1=1 and (id=1 or id=2 or id=3)
     -->
       <foreach collection="ids"  item="id" open="and (" close=")" separator="or">
          id=#{id}
       </foreach>
   </where>
</select>

3、测试

@Test
public void testQueryBlogForeach(){
   SqlSession session = MybatisUtils.getSession();
   BlogMapper mapper = session.getMapper(BlogMapper.class);

   HashMap map = new HashMap();
   List<Integer> ids = new ArrayList<Integer>();
   ids.add(1);
   ids.add(2);
   ids.add(3);
   map.put("ids",ids);

   List<Blog> blogs = mapper.queryBlogForeach(map);

   System.out.println(blogs);

   session.close();
}

Created connection 912672706.
==>  Preparing: select * from blog WHERE ( id=? or id=? or id=? )
==> Parameters: 1(Integer), 2(Integer), 3(Integer)

小结：其实动态 sql 语句的编写往往就是一个拼接的问题，为了保证拼接准确，我们最好首先要写原生的 sql 语句出来，然后在通过 mybatis 动态sql 对照着改，防止出错。多在实践中使用才是熟练掌握它的技巧。

动态SQL在开发中大量的使用，一定要熟练掌握！

13、缓存

简介

1、什么是缓存 [ Cache ]？

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

2、为什么使用缓存？

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

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

• 经常查询并且不经常改变的数据。

Mybatis缓存

• MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
• MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存
• • 默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）
  • 二级缓存需要手动开启和配置，他是基于namespace级别的缓存。
  • 为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

一级缓存

一级缓存也叫本地缓存：

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

测试

1、在mybatis中加入日志，方便测试结果

2、编写接口方法

//根据id查询用户
User queryUserById(@Param("id") int id);

3、接口对应的Mapper文件

<select id="queryUserById" resultType="user">
  select * from user where id = #{id}
</select>

4、测试

@Test
public void testQueryUserById(){
   SqlSession session = MybatisUtils.getSession();
   UserMapper mapper = session.getMapper(UserMapper.class);

   User user = mapper.queryUserById(1);
   System.out.println(user);
   User user2 = mapper.queryUserById(1);
   System.out.println(user2);
   System.out.println(user==user2);

   session.close();
}

5、结果分析

一级缓存失效的四种情况

一级缓存是SqlSession级别的缓存，是一直开启的，我们关闭不了它；

一级缓存失效情况：没有使用到当前的一级缓存，效果就是，还需要再向数据库中发起一次查询请求！

1、sqlSession不同

@Test
public void testQueryUserById(){
   SqlSession session = MybatisUtils.getSession();
   SqlSession session2 = MybatisUtils.getSession();
   UserMapper mapper = session.getMapper(UserMapper.class);
   UserMapper mapper2 = session2.getMapper(UserMapper.class);

   User user = mapper.queryUserById(1);
   System.out.println(user);
   User user2 = mapper2.queryUserById(1);
   System.out.println(user2);
   System.out.println(user==user2);

   session.close();
   session2.close();
}
12345678910111213141516

观察结果：发现发送了两条SQL语句！

结论：每个sqlSession中的缓存相互独立

2、sqlSession相同，查询条件不同

@Test
public void testQueryUserById(){
   SqlSession session = MybatisUtils.getSession();
   UserMapper mapper = session.getMapper(UserMapper.class);
   UserMapper mapper2 = session.getMapper(UserMapper.class);

   User user = mapper.queryUserById(1);
   System.out.println(user);
   User user2 = mapper2.queryUserById(2);
   System.out.println(user2);
   System.out.println(user==user2);

   session.close();
}

观察结果：发现发送了两条SQL语句！很正常的理解

结论：当前缓存中，不存在这个数据

3、sqlSession相同，两次查询之间执行了增删改操作！

增加方法

//修改用户
int updateUser(Map map);

编写SQL

<update id="updateUser" parameterType="map">
  update user set name = #{name} where id = #{id}
</update>

测试

@Test
public void testQueryUserById(){
   SqlSession session = MybatisUtils.getSession();
   UserMapper mapper = session.getMapper(UserMapper.class);

   User user = mapper.queryUserById(1);
   System.out.println(user);

   HashMap map = new HashMap();
   map.put("name","kuangshen");
   map.put("id",4);
   mapper.updateUser(map);

   User user2 = mapper.queryUserById(1);
   System.out.println(user2);

   System.out.println(user==user2);

   session.close();
}

观察结果：查询在中间执行了增删改操作后，重新执行了

结论：因为增删改操作可能会对当前数据产生影响

4、sqlSession相同，手动清除一级缓存

@Test
public void testQueryUserById(){
   SqlSession session = MybatisUtils.getSession();
   UserMapper mapper = session.getMapper(UserMapper.class);

   User user = mapper.queryUserById(1);
   System.out.println(user);

   session.clearCache();//手动清除缓存

   User user2 = mapper.queryUserById(1);
   System.out.println(user2);

   System.out.println(user==user2);

   session.close();
}

一级缓存就是一个map

二级缓存

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

使用步骤

1、开启全局缓存 【mybatis-config.xml】

<setting name="cacheEnabled" value="true"/>

2、去每个mapper.xml中配置使用二级缓存，这个配置非常简单；【xxxMapper.xml】

<cache/>

官方示例=====>查看官方文档
<cache
 eviction="FIFO"
 flushInterval="60000"
 size="512"
 readOnly="true"/>
这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512 个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突。

3、代码测试

• 所有的实体类先实现序列化接口
• 测试代码

@Test
public void testQueryUserById(){
   SqlSession session = MybatisUtils.getSession();
   SqlSession session2 = MybatisUtils.getSession();

   UserMapper mapper = session.getMapper(UserMapper.class);
   UserMapper mapper2 = session2.getMapper(UserMapper.class);

   User user = mapper.queryUserById(1);
   System.out.println(user);
   session.close();

   User user2 = mapper2.queryUserById(1);
   System.out.println(user2);
   System.out.println(user==user2);

   session2.close();
}

结论

• 只要开启了二级缓存，我们在同一个Mapper中的查询，可以在二级缓存中拿到数据
• 查出的数据都会被默认先放在一级缓存中
• 只有会话提交或者关闭以后，一级缓存中的数据才会转到二级缓存中

缓存原理图

EhCache

第三方缓存实现–EhCache: 查看百度百科

Ehcache是一种广泛使用的java分布式缓存，用于通用缓存；

要在应用程序中使用Ehcache，需要引入依赖的jar包

<!-- 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.xml中使用对应的缓存即可

<mapper namespace = “org.acme.FooMapper” > 
   <cache type = “org.mybatis.caches.ehcache.EhcacheCache” /> 
</mapper>

编写ehcache.xml文件，如果在加载时未找到/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>

LSchema-instance"
xsi:noNamespaceSchemaLocation=“http://ehcache.org/ehcache.xsd”
updateCheck=“false”>

```

合理的使用缓存，可以让我们程序的性能大大提升！

• 结尾表明对秦疆老师的感谢之情，做笔记是为了自己以后的复习和对已学知识的复盘。
• 感谢每一位耐心读完文章的您，一起进步！
• 详细请移步B站狂神说Mybatishttps://www.bilibili.com/video/BV1NE411Q7Nx?spm_id_from=333.337.search-card.all.click&vd_source=c77da83e28065a4088b34f45b8d1cc75