SSM框架学习笔记1-Mybatis

最新推荐文章于 2024-11-09 12:43:52 发布

aoliaoliaoo

最新推荐文章于 2024-11-09 12:43:52 发布

阅读量128

点赞数

分类专栏： SSM框架文章标签： java 数据库 mybatis

本文链接：https://blog.csdn.net/aoliaoliaoo/article/details/120268243

版权

SSM框架专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Mybatis

1、简介

1.1、概念

一款半自动的ORM（对象关系映射）持久层框架
免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作
通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（普通老式 Java 对象）为数据库中的记录
解除sql与程序代码的耦合
提供xml标签，支持编写动态sql
Mybatis官方文档 : http://www.mybatis.org/mybatis-3/zh/index.html
GitHub : https://github.com/mybatis/mybatis-3

1.2、持久化

数据持久化
- 持久化是将程序数据在持久状态和瞬时状态间转换的机制
- JDBC、文件IO都是持久化机制
- 由于内存缺陷：断电即失、内存价格昂贵等，所以需要将数据持久化来缓存到外存

1.3、持久层

Dao层，数据访问对象。完成持久化工作的代码块。

1.4、详细执行流程

在这里插入图片描述

2、第一个mybatis程序

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

2.1、准备数据库

CREATE DATABASE `mybatis`;
 
USE `mybatis`;
CREATE TABLE
IF
	NOT EXISTS `user` (
	`id` INT ( 4 ) NOT NULL,
	`name` VARCHAR ( 30 ) DEFAULT NULL,
	`password` VARCHAR ( 30 ) DEFAULT NULL,
	PRIMARY KEY ( `id` ) 
	) ENGINE = INNODB DEFAULT CHARSET = utf8;
	
	INSERT INTO `user`(`id`,`name`,`password`) VALUES (1,'zhangsan','123456'),(2,'lisi','123456'),(3,'wangwu','123456');

2.2、pom.xml配置

<!--  junit  -->
<!-- https://mvnrepository.com/artifact/junit/junit -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13.2</version>
    <scope>test</scope>
</dependency>
<!--  mybatis  -->
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.7</version>
</dependency>
<!--  mysql  -->
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.26</version>
</dependency>

<!-- 在build中配置resources，避免出现资源导出失败的问题 -->
<resources>
    <resource>
        <directory>src/main/java</directory>
        <includes>
            <include>**/*.properties</include>
            <include>**/*.xml</include>
        </includes>
    </resource>
    <resource>
        <directory>src/main/resources</directory>
        <includes>
            <include>**/*.properties</include>
            <include>**/*.xml</include>
        </includes>
    </resource>
</resources>

2.3、编写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核心配置文件-->
<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <!-- 填写数据库参数 -->
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=GMT"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>
    <!--注册mapper-->
    <mappers>
        <!--注意，不是org.mybatis.example，要用斜杆/-->
        <mapper resource="org/mybatis/example/BlogMapper.xml"/>
    </mappers>
</configuration>

2.4、编写MyBatis工具类

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 {
        //1、获取SqlSessionFactory对象
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //2、从SqlSessionFactory对象中获取SqlSession
    public static SqlSession getsqlsession(){
        //不自动提交事务，增删改时需要写commit()
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //加上true后自动提交事务，增删改时不需要再写commit()
        //SqlSession sqlSession = sqlSessionFactory.openSession(true);
        return sqlSession;
    }
}

2.5、编写pojo实体类

//user表的实体类
public class User {
    private int id;  //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;
    }
    //重写 toString()方法，方便查看打印结果，快捷键：fn+alt+insert
    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", pwd='" + pwd + '\'' +
                '}';
    }
    
    //get set
    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;
    }
}

2.6、编写Mapper接口类（Dao）

import com.leijiao.pojo.User;
import java.util.List;

public interface UserMapper {
    List<User> selectUser();
}

2.7、编写Mapper.xml配置文件（DaoImpl）

<?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绑定一个mapper接口-->
<mapper namespace="com.leijiao.mapper.UserMapper">
    <!-- select查询语句：id对应namespace中的方法名，parameterType参数类型，resultType参数返回类型  -->
    <select id="selectUser" resultType="com.leijiao.pojo.User">
        select * from user
    </select>
</mapper>

2.8、mybatis-config.xml中注册mapper

注意：所有mapper配置文件都需要在mybatis-config.xml中注册

<mapper resource="com/leijiao/mapper/UserMapper.xml" />

2.9、编写测试类

import com.leijiao.pojo.User;
import com.leijiao.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;
import java.util.List;

public class UserMapperTest {

    @Test
    public void test(){
        SqlSession getsqlsession = MybatisUtils.getsqlsession();
        UserMapper mapper = getsqlsession.getMapper(UserMapper.class);
        List<User> users = mapper.selectUser();
        for (User user : users) {
            System.out.println(user);
        }
        getsqlsession.close();
    }
}

3、CRUD

3.1、 select

<!--  通过id查询用户  -->
<select id="selectUserById" parameterType="int" resultType="com.leijiao.pojo.User">
    select * from user where id = #{id}
</select>

@Test
public void selectUserById(){
    SqlSession getsqlsession = MybatisUtils.getsqlsession();
    UserMapper mapper = getsqlsession.getMapper(UserMapper.class);
    int id = 1;
    User user = mapper.selectUserById(id);
    System.out.println(user);
    getsqlsession.close();
}

3.2、 insert

<!--  新增用户  -->
<insert id="insertUser" parameterType="com.leijiao.pojo.User">
    insert into user (id,name,password) values (#{id},#{name},#{password})
</insert>

@Test
public void insertUser(){
    SqlSession getsqlsession = MybatisUtils.getsqlsession();
    UserMapper mapper = getsqlsession.getMapper(UserMapper.class);
    User user = new User(4,"测试","123456");
    mapper.insertUser(user);
    //增删改需要提交事务
    getsqlsession.commit();
    getsqlsession.close();
}

3.2、update

<!--  修改用户  -->
<update id="updateUser" parameterType="com.leijiao.pojo.User">
    update user set name = #{name},password=#{password} where id=#{id}
</update>

@Test
public void updateUser(){
    SqlSession getsqlsession = MybatisUtils.getsqlsession();
    UserMapper mapper = getsqlsession.getMapper(UserMapper.class);
    User user = new User(4, "测试修改", "12345678");
    mapper.updateUser(user);
    getsqlsession.commit();
    getsqlsession.close();
}

3.4、delete

<!--  删除用户  -->
<delete id="deleteUser" parameterType="int">
    delete from user where id = #{id}
</delete>

@Test
public void deleteUser(){
    SqlSession getsqlsession = MybatisUtils.getsqlsession();
    UserMapper mapper = getsqlsession.getMapper(UserMapper.class);
    mapper.deleteUser(4);
    getsqlsession.commit();
    getsqlsession.close();
}

3.5、注意点

若未设置自动提交事务，增删改操作需要提交事务getsqlsession.commit()
标签需要与sql匹配

3.6、传参Map

如果参数过多，我们可以考虑直接使用Map实现，如果参数比较少，直接传递参数即可

<!--  根据用户名和密码查询用户（使用map）  -->
<select id="selectUserByMap" parameterType="map" resultType="com.leijiao.pojo.User">
    select * from user where name = #{name} and password = #{password}
</select>

@Test
public void selectUserByMap(){
    SqlSession getsqlsession = MybatisUtils.getsqlsession();
    UserMapper mapper = getsqlsession.getMapper(UserMapper.class);
    HashMap<String, Object> stringObjectHashMap = new HashMap<>();
    stringObjectHashMap.put("name","zhangsan");
    stringObjectHashMap.put("password","123456");
    User user = mapper.selectUserByMap(stringObjectHashMap);
    System.out.println(user);
    getsqlsession.close();
}

3.7、模糊查询like

在java代码中添加sql通配符

<!--  模糊查询用户like  -->
<select id="selectUserLike" resultType="com.leijiao.pojo.User">
    select * from user where name like #{name}
</select>

@Test
public void selectUserLike(){
SqlSession getsqlsession = MybatisUtils.getsqlsession();
UserMapper mapper = getsqlsession.getMapper(UserMapper.class);
//此处加入通配符%
List<User> users = mapper.selectUserLike("%an%");
    for (User user : users) {
    	System.out.println(user);
    }
    getsqlsession.close();
}

在sql语句中拼接通配符，会引起sql注入

<!--  模糊查询用户like  -->
<select id="selectUserLike" resultType="com.leijiao.pojo.User">
    <!--在此处加入通配符% -->
    select * from user where name like "%"#{name}"%"
</select>

@Test
public void selectUserLike(){
SqlSession getsqlsession = MybatisUtils.getsqlsession();
UserMapper mapper = getsqlsession.getMapper(UserMapper.class);
//此处加入通配符%
List<User> users = mapper.selectUserLike("an");
    for (User user : users) {
    	System.out.println(user);
    }
    getsqlsession.close();
}

4、配置解析和优化

4.1、核心配置文件

mybatis-config.xml

configuration（配置）
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
        environment（环境变量）
            transactionManager（事务管理器）
            dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）
<!-- 注意元素节点的顺序！顺序不对会报错 -->

4.2、环境配置environments

可以配置多套运行环境，用default指定（每个 SqlSessionFactory 实例只能选择一种环境）

transactionManager：默认是JDBC
dataSource：默认是POOLED连接池

4.3、映射器mappers

定义映射SQL语句文件

<!-- 使用相对于类路径的资源引用 -->
<mappers>
  <mapper resource="com/leijiao/mapper/UserMapper.xml"/>
</mappers>

<!--不会使用这种方式-->
<!-- 使用完全限定资源定位符（URL） 
<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
</mappers>

<!-- 使用映射器接口实现类的完全限定类名
	 需要配置文件名称和接口名称一致，并且位于同一目录 
-->
<mappers>
  <mapper class="com.leijiao.mapper.UserMapper"/>
</mappers>

<!-- 将包内的映射器接口实现全部注册为映射器
	 需要配置文件名称和接口名称一致，并且位于同一目录
-->
<mappers>
  <package name="com.leijiao.mapper"/>
</mappers>

4.4、属性优化properties

将数据库连接参数提取出来，放到配置文件中，再引入

在resource下新建db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8&serverTimezone=GMT
username=root
password=123456

在mybatis-config.xml中引入db.properties

<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<!--configuration核心配置文件-->
<configuration>
    <!--  引入外部配置文件  -->
    <properties resource="db.properties">
        <!--  优先使用外部的参数  -->
        <!--<property name="username" value="root"/>-->
        <!--<property name="password" value="1111111"/>-->
    </properties>
    <environments default="development">
        <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>
    </environments>
    <!--注册mapper-->
    <mappers>
        <mapper resource="com/leijiao/mapper/UserMapper.xml" />
    </mappers>
</configuration>

4.5、类型别名优化typeAliases

4.5.1、给类起别名

实体类少的时候用这种方式，可以自定义别名！

mybatis-config.xml

<!--  类别名  -->
<typeAliases>
    <typeAlias type="com.leijiao.pojo.User" alias="User"></typeAlias>
</typeAliases>

Mapper.xml

<!--  resultType只需要写别名User即可  -->
<select id="selectUser" resultType="User">
    select * from user
</select>

4.5.2、给包起别名

实体类较多的时候用这种方式，若要自定义别名需要加注解！

指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean，在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名，若有注解，则别名为其注解值。

mybatis-config.xml

<!--  包别名  -->
<typeAliases>
    <package name="com.leijiao.pojo"/>
</typeAliases>

无注解时，Mapper.xml

<select id="selectUser" resultType="user">
    select * from user
</select>

实体类有注解，Mapper.xml中用注解的名称

@Alias("xxx")
public class User {
    ...
}

<select id="selectUser" resultType="xxx">
    select * from user
</select>

4.6、设置settings

记住3个
- 懒加载lazyLoadingEnabled
- 日志实现logImpl
- 缓存开启关闭cacheEnabled
完整的settings

<settings>
  <setting name="cacheEnabled" value="true"/>
  <setting name="lazyLoadingEnabled" value="true"/>
  <setting name="multipleResultSetsEnabled" value="true"/>
  <setting name="useColumnLabel" value="true"/>
  <setting name="useGeneratedKeys" value="false"/>
  <setting name="autoMappingBehavior" value="PARTIAL"/>
  <setting name="autoMappingUnknownColumnBehavior" value="WARNING"/>
  <setting name="defaultExecutorType" value="SIMPLE"/>
  <setting name="defaultStatementTimeout" value="25"/>
  <setting name="defaultFetchSize" value="100"/>
  <setting name="safeRowBoundsEnabled" value="false"/>
  <setting name="mapUnderscoreToCamelCase" value="false"/>
  <setting name="localCacheScope" value="SESSION"/>
  <setting name="jdbcTypeForNull" value="OTHER"/>
  <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
</settings>

4.7、生命周期和作用域

生命周期和作用域至关重要，错误的使用会导并发问题

在这里插入图片描述

SqlSessionFactoryBuilder ：创建了SqlSessionFactory之后就不需要它了，所以用局部变量
SqlSessionFactory ：可以被认为是数据库连接池。一旦创建了就要长期保存，它的生命周期就等同于 MyBatis 的应用周期，最佳作用域是应用作用域
SqlSession：当于一个数据库连接（Connection 对象）。最佳的作用域是请求或方法作用域，用完之后需要关闭，避免占用资源（sqlSession.close）
Maper：代表一个具体的业务

5、结果集映射ResultMap

解决属性名和字段名不一致的问题：实体类表中的字段名和数据库表中的字段名不一致

出现问题的例子

user表字段：id，name，password
User实体类

public class User {
 
    private int id;  //id
    private String name;   //姓名
    private String pwd;   //密码和数据库不一样！
    
    //构造
    //set/get
    //toString()
}

mapper接口

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

mapper.xml

<!--  通过id查询用户  -->
<select id="selectUserById" parameterType="int" resultType="com.leijiao.pojo.User">
    select * from user where id = #{id}
</select>

测试出现pwd=‘null’
- mybatis会根据这些查询的列名(会将列名转化为小写,数据库不区分大小写) , 去对应的实体类中查找相应列名的set方法设值 , 由于找不到setPwd() , 所以password返回null

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

//得到结果pwd=null
//User{id=1, name='zhangsan', pwd='null'}

解决办法

方法一：为列名指定别名 , 别名和java实体类的属性名一致

<select id="selectUserById" resultType="User">
    select id , name , pwd as password from user where id = #{id}
</select>

方法二：使用结果集映射->ResultMap 【推荐】

<!--  resultMap结果集映射  -->
<resultMap id="UserMap" type="com.leijiao.pojo.User">
    <!-- id为主键 -->
    <id column="id" property="id"/>
    <!-- column是数据库表的列名 , property是对应实体类的属性名 -->
    <result column="name" property="name"/>
    <result column="password" property="pwd"/>
</resultMap>
<!--  resultType改成resultMap  -->
<select id="selectUserById" parameterType="int" resultMap="UserMap">
    select * from user where id = #{id}
</select>

6、日志工厂logImpl

6.1、标准日志

<!--  设置  -->
<settings>
    <!--  标准日志输出  -->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>

6.2、Log4j日志

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

使用步骤

pom.xml依赖

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

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/leijiao.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

mybatis-config.xml中setting设置日志实现

<!--  设置  -->
<settings>
    <!--  log4j日志输出  -->
    <setting name="logImpl" value="LOG4J"/>
</settings>

在程序中使用Log4j进行输出
- 控制台有打印日志
- 生成一个xxx.log日志文件（路径需要配置：log4j.appender.file.File=./log/leijiao.log）

import com.leijiao.pojo.User;
import com.leijiao.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.apache.log4j.Logger;
import org.junit.Test;

public class UserMapperTest {

    //注意导包：org.apache.log4j.Logger
    static Logger logger = Logger.getLogger(UserMapperTest.class);

    @Test
    public void selectUser(){
        //打印日志
        logger.info("info：进入selectUser方法");
        logger.debug("debug：进入selectUser方法");
        logger.error("error: 进入selectUser方法");
        
        SqlSession getsqlsession = MybatisUtils.getsqlsession();
        UserMapper mapper = getsqlsession.getMapper(UserMapper.class);
        User user = mapper.selectUserById(1);
        System.out.println(user);
        getsqlsession.close();
    }
}

7、分页

查询大量数据的时候，我们往往使用分页进行查询，也就是每次处理小部分数据，这样对数据库压力就在可控范围内。

7.1、limit

在sql层面实现分页

Mapper接口，参数为map

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

Mapper.xml

<!--  limit分页  -->
<select id="selectUserLimit" parameterType="map" resultType="com.leijiao.pojo.User">
    select * from user limit #{startIndex},#{pageSize}
</select>

在测试类中传入参数测试

@Test
public void selectUser(){
    SqlSession getsqlsession = MybatisUtils.getsqlsession();
    UserMapper mapper = getsqlsession.getMapper(UserMapper.class);
    int startIndex = 0;  //第几页
    int pageSize = 2;  //每页显示几个
    HashMap<String, Integer> map = new HashMap<>();
    map.put("startIndex",startIndex);
    map.put("pageSize",pageSize);
    List<User> users = mapper.selectUserLimit(map);
    for (User user : users) {
        System.out.println(user);
    }
    getsqlsession.close();
}

7.2、RowBounds

在Java代码层面实现分页

Mapper接口

//RowBounds分页
List<User> selectUserRowBounds();

Mapper.xml

<!--  RowBounds分页  -->
<select id="selectUserRowBounds" resultType="com.leijiao.pojo.User">
    select * from user
</select>

测试类

@Test
public void selectUserRowBounds(){
    SqlSession getsqlsession = MybatisUtils.getsqlsession();
    int startIndex = 0;  //第几页
    int pageSize = 2;  //每页显示几个
    RowBounds rowBounds = new RowBounds(startIndex,pageSize);
    List<User> users = getsqlsession.selectList("com.leijiao.mapper.UserMapper.selectUserRowBounds", null, rowBounds);
    for (User user : users) {
        System.out.println(user);
    }
    getsqlsession.close();
}

7.3、PageHelper

是一款分页插件

官方文档：https://pagehelper.github.io/

8、使用注解开发

使用注解开发，就不需要mapper.xml文件

8.1、@Param()

用于给方法参数起一个名字
- 在方法只接受一个参数的情况下，可以不使用@Param
- 在方法接受多个参数的情况下，建议一定要使用@Param注解给参数命名
- 如果参数是 JavaBean ，则不能使用@Param
- 不使用@Param注解时，参数只能有一个，并且是Javabean

8.2、@select ()

mapper接口

@Select("select * from user where id = #{id}")
List<User> selectUserById(@Param("id") int id);

核心配置mybatis-config.xml，使用class绑定接口

<mapper class="com.leijiao.mapper.UserMapper" />

测试

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

8.3、@Insert ()

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

8.4、@update ()

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

8.5、@delete ()

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

9、LomBok

LomBok是java库、插件、构建工具，使用后实体类可以不需要编写getter、setter、构造器等方法

使用步骤：

IDEA安装Lombok插件

pom.xml依赖

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.16.10</version>
</dependency>

实体类

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

//user表的实体类
//@Data注解，生成GET,SET,ToString,equals,hashCode
//@AllArgsConstructor，生成有参构造
//@NoArgsConstructor，生成无参构造
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private int id;  //id
    private String name;   //姓名
    private String password;   //密码
}

10、多对一和一对多处理

10.1、多对一association

10.1.1、环境准备

1、数据库准备(多个学生对应一个老师)

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(`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');

2、实体类

@Data
public class Student {
    private int id;
    private String name;
	//多个学生对应一个老师，对象用association标签
    private Teacher teacher;
}

@Data
public class Teacher {
    private int id;
    private String name;
}

3、mapper接口

public interface StudentMapper {
}

public interface TeacherMapper {
}

4、mapper.xml

<mapper namespace="com.leijiao.mapper.StudentMapper">
</mapper>

<mapper namespace="com.leijiao.mapper.TeacherMapper">
</mapper>

5、mybatis-config.xml

<!--注册mapper-->
<mappers>
	<mapper resource="com/leijiao/mapper/TeacherMapper.xml" />
	<mapper resource="com/leijiao/mapper/StudentMapper.xml" />
</mappers>

10.1.2、子查询

按查询嵌套处理实际上就是SQL中的子查询

StudentMapper接口

//获取所有学生及对应老师的信息
public List<Student> getStudents();

StudentMapper.xml

<!-- 获取所有学生及对应老师的信息
按查询嵌套处理
    1. 获取所有学生的信息
    2. 根据获取的学生信息的老师ID->获取该老师的信息
    3. association:一个复杂类型的关联；使用它来处理关联查询
        1. 做一个结果集映射：StudentTeacher
        2. StudentTeacher结果集的类型为 Student
        3. 学生中老师的属性为teacher，对应数据库中为tid。
           多个 [1,...）学生关联一个老师=> 一对一，一对多
-->
<select id="getStudents" resultMap="StudentTeacher">
    select * from student
</select>
<resultMap id="StudentTeacher" type="com.leijiao.pojo.Student">
    <!--association关联属性  property属性名 javaType属性类型 column在多的一方的表中的列名-->
    <association property="teacher"  column="tid" javaType="com.leijiao.pojo.Teacher" select="getTeacher"/>
</resultMap>
<select id="getTeacher" resultType="com.leijiao.pojo.Teacher">
    select * from teacher where id = #{id}
</select>

10.1.3、联表查询

按结果嵌套查询实际上就是SQL中的联表查询

StudentMapper接口

//获取所有学生及对应老师的信息
public List<Student> getStudents2();

StudentMapper.xml

<!--获取所有学生及对应老师的信息
按查询结果嵌套处理
    1. 直接查询出结果，进行结果集的映射
-->
<select id="getStudents2" 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="com.leijiao.pojo.Student">
    <result property="id" column="sid"/>
    <result property="name" column="sname"/>
    <!--关联对象property 关联对象在Student实体类中的属性-->
    <association property="teacher" javaType="com.leijiao.pojo.Teacher">
        <result property="name" column="tname"/>
    </association>
</resultMap>

10.2、一对多collection

10.2.1、环境准备

1、实体类

@Data
public class Student {
    private int id;
    private String name;
    private int tid;
}

@Data
public class Teacher {
    private int id;
    private String name;
	//一个老师对应多个学生，集合用collection标签
    private List<Student> students;
}

其余和10.1.1一样的操作

10.2.2、子查询

TeacherMapper接口

//获取指定老师，及老师下的所有学生
public Teacher getTeacher(int id);

TeacherMapper.xml

<!--  按查询嵌套处理  -->
<select id="getTeachers" resultMap="StudentTeacher">
    select * from teacher whre id = #{id}
</select>
<resultMap id="StudentTeacher" type="com.leijiao.pojo.Teacher">
    <collection property="students" javaType="ArrayList" ofType="com.leijiao.pojo.Studen" column="id" select="selectStudent"/>
</resultMap>
<select id="selectStudent" resultType="com.leijiao.pojo.Student">
    select * from student where tid = #{id}
</select>

10.2.3、联表查询

TeacherMapper接口

//获取指定老师，及老师下的所有学生
public Teacher getTeacher2(int id);

TeacherMapper.xml

<!--  按结果嵌套处理  -->
<select id="getTeachers2" resultMap="TeacherStudent">
    select t.id tid, t.name tname, s.id sid, s.name sname, s.tid stid
    from teacher t, student s
    where t.id=s.tid and s.tid = #{id}
</select>
<resultMap id="TeacherStudent" type="com.leijiao.pojo.Teacher">
    <result property="id" column="tid"></result>
    <result property="name" column="tname"></result>
    <collection property="students" ofType="com.leijiao.pojo.Student">
        <result property="id" column="sid"></result>
        <result property="name" column="sname"></result>
        <result property="tid" column="stid"></result>
    </collection>
</resultMap>

10.3、注意点

关联-association
集合-collection
javaType和ofType都是用来指定对象类型的
- JavaType是用来指定pojo中属性的类型
- ofType指定的是映射到list集合属性中pojo的类型。

11、动态SQL

动态SQL指的是根据不同的查询条件 , 生成不同的Sql语句
语句
- if
- choose (when, otherwise)
- trim (where, set)
- foreach

11.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

pojo实体类Blog.java

import java.util.Date;

@Data
public class Blog {
    private String id;
    private String title;
    private String author;
    private Date createTime;
    private int views;

}

Mapper接口

public interface BlogMapper {
    //新增一个博客，造数据用
	int addBlog(Blog blog);
}

Mapper.xml配置

<mapper namespace="com.leijiao.mapper.BlogMapper">
    <insert id="addBlog" parameterType="com.leijiao.pojo.Blog">
        insert into blog (id, title, author, create_time, views)
        values (#{id},#{title},#{author},#{createTime},#{views})
    </insert>
</mapper>

mybatis-config.xml核心配置

<settings>
    <!--  标准日志输出  -->
    <setting name="logImpl" value="STDOUT_LOGGING"/>
    <!--  开启下划线驼峰自动转换  -->
    <setting name="mapUnderscoreToCamelCase" value="true"/>
</settings>
<!--注册mapper-->
<mappers>
    <mapper resource="com/leijiao/mapper/BlogMapper.xml" />
</mappers>

工具类IDutil.java，生成uuid

import java.util.UUID;

//抑制警告
@SuppressWarnings("all")
public class IDUtil {
    public static String getId(){
        return UUID.randomUUID().toString().replace("-","");
    }
}

测试类，造数据

@Test
public void test(){
    SqlSession getsqlsession = MybatisUtils.getsqlsession();
    BlogMapper mapper = getsqlsession.getMapper(BlogMapper.class);
    Blog blog = new Blog();
    blog.setId(IDUtil.getId());
    blog.setTitle("标题1");
    blog.setAuthor("leijiao");
    blog.setCreateTime(new Date());
    blog.setViews(9999);
    mapper.addBlog(blog);
    blog.setId(IDUtil.getId());
    blog.setTitle("标题2");
    mapper.addBlog(blog);

    blog.setId(IDUtil.getId());
    blog.setTitle("标题3");
    mapper.addBlog(blog);

    blog.setId(IDUtil.getId());
    blog.setTitle("标题4");
    mapper.addBlog(blog);
}

11.2、if+where语句

Mapper接口

//需求：根据作者名字和博客标题来查询博客！如果作者名字为空，那么只根据博客标题查询，反之，则根据作者名来查询
List<Blog> queryBlogIf(Map map);

Mapper.xml配置
- 使用标签，如果它包含的标签中有返回值的话，它就插入一个‘where；如果标签返回的内容是以AND 或OR 开头的，会剔除掉

<select id="queryBlogIf" parameterType="map" resultType="com.leijiao.pojo.Blog">
    select * from blog
    <where>
        <if test="title!= null">
            title=#{title}
        </if>
        <if test="author != null">
            and author=#{author}
        </if>
    </where>
</select>

11.3、if+set语句

Mapper接口

//需求：根据id修改博客标题和作者名字！如果作者名字为空，那么只修改博客标题，反之，则修改作者名字
int updateBlog(Map map);

Mapper.xml配置
- 使用标签，会自动剔除逗号，作用同理标签

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

11.4、choose+when+otherwise语句

查询条件有一个满足即可，类似于 Java 的 switch 语句

Mapper接口

List<Blog> queryBlogChoose(Map map);

Mapper.xml配置

<select id="queryBlogChoose" parameterType="map" resultType="com.leijiao.pojo.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>

11.5、sql片段

提取常用的sql片段，使用时直接调用，可以增加代码的重用性，简化代码。

注意：
- 最好基于单表来定义 sql 片段，提高片段的可重用性
- 在 sql 片段中不要包括 where

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

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

11.6、foreach

Mapper接口

List<Blog> queryBlogForeach(Map map);

Mapper.xml

<select id="queryBlogForeach" parameterType="map" resultType="com.leijiao.pojo.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>

测试

@Test
public void testQueryBlogForeach(){
    SqlSession session = MybatisUtils.getsqlsession();
    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();
}

12、缓存

缓存：缓存是在内存中的临时数据，经常查询并且不经常改变的数据可以放在缓存中，可以减少和数据库的交互次数，减少系统开销，提高系统效率
mybatis缓存：MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。分为一级缓存和二级缓存两种。

12.1、mybatis缓存原理

在这里插入图片描述

12.2、一级缓存

SqlSession级别的缓存，也称为本地缓存
默认情况下，只有一级缓存开启
与数据库同一次会话期间查询到的数据会放在本地缓存中
以后如果需要获取相同的数据，直接从缓存中拿，没必须再去查询数据库

12.2.1、例子

Mapper接口

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

Mapper.xml

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

测试

@Test
public void testQueryUserById(){
    SqlSession getsqlsession = MybatisUtils.getsqlsession();
    UserMapper mapper = getsqlsession.getMapper(UserMapper.class);
	//查询id=1的用户
    User user = mapper.queryUserById(1);
    System.out.println(user);
    //再次查询id=1的用户
    User user2 = mapper.queryUserById(1);
    System.out.println(user2);
    
    System.out.println(user==user2);
    getsqlsession.close();
}

日志结果分析（需要打开标准日志输出，参考6.1）
- 从日志中看到，只执行了1次sql查询，对象1=对象2

Opening JDBC Connection
Created connection 1403704789.
==>  Preparing: select * from user where id = ?
==> Parameters: 1(Integer)
<==    Columns: id, name, password
<==        Row: 1, zhangsan, 123456
<==      Total: 1
User(id=1, name=zhangsan, password=123456)
User(id=1, name=zhangsan, password=123456)
true
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@53aad5d5]
Returned connection 1403704789 to pool.

12.2.2、失效的四种情况

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

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

1、sqlSession不同（每个sqlSession中的缓存相互独立）

测试：获取2个sqlSession，分别查询id=1的用户

@Test
public void testQueryUserById2(){
    SqlSession getsqlsession1 = MybatisUtils.getsqlsession();
    SqlSession getsqlsession2 = MybatisUtils.getsqlsession();
    UserMapper mapper1 = getsqlsession1.getMapper(UserMapper.class);
    UserMapper mapper2 = getsqlsession2.getMapper(UserMapper.class);

    //使用getsqlsession1查询
    User user = mapper1.queryUserById(1);
    System.out.println(user);
    //使用getsqlsession2查询
    User user2 = mapper2.queryUserById(1);
    System.out.println(user2);

    System.out.println(user==user2);
    getsqlsession1.close();
    getsqlsession2.close();
}

日志结果分析
- 从日志可以看出，sqlSession不同，执行了两次sql查询，对象1!=对象2
- 因为每个sqlSession中的缓存相互独立，所以要查询2次

Opening JDBC Connection
Created connection 1403704789.
==>  Preparing: select * from user where id = ?
==> Parameters: 1(Integer)
<==    Columns: id, name, password
<==        Row: 1, zhangsan, 123456
<==      Total: 1
User(id=1, name=zhangsan, password=123456)
Opening JDBC Connection
Created connection 888473870.
==>  Preparing: select * from user where id = ?
==> Parameters: 1(Integer)
<==    Columns: id, name, password
<==        Row: 1, zhangsan, 123456
<==      Total: 1
User(id=1, name=zhangsan, password=123456)
false
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@53aad5d5]
Returned connection 1403704789 to pool.
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@34f5090e]
Returned connection 888473870 to pool.

2、sqlSession相同，查询条件不同（当前缓存中，不存在这个数据）

测试：相同的sqlSession，第一次查询id=1的用户，第二次查询id=2的用户

@Test
public void testQueryUserById3(){
    SqlSession getsqlsession = MybatisUtils.getsqlsession();
    UserMapper mapper1 = getsqlsession.getMapper(UserMapper.class);
    UserMapper mapper2 = getsqlsession.getMapper(UserMapper.class);

    //sqlSession相同，查询id=1的用户
    User user = mapper1.queryUserById(1);
    System.out.println(user);
    //sqlSession相同，查询id=2的用户
    User user2 = mapper2.queryUserById(2);
    System.out.println(user2);

    System.out.println(user==user2);
    getsqlsession.close();
}

测试结果分析
- 从日志可以看出，sqlSession相同，查询条件不同，执行了2次sql查询，对象1!=对象2
- 因为查询条件不一样，当前缓存中不存在这个数据，所以要查询2次

Opening JDBC Connection
Created connection 1403704789.
==>  Preparing: select * from user where id = ?
==> Parameters: 1(Integer)
<==    Columns: id, name, password
<==        Row: 1, zhangsan, 123456
<==      Total: 1
User(id=1, name=zhangsan, password=123456)
==>  Preparing: select * from user where id = ?
==> Parameters: 2(Integer)
<==    Columns: id, name, password
<==        Row: 2, lisi, 123456
<==      Total: 1
User(id=2, name=lisi, password=123456)
false
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@53aad5d5]
Returned connection 1403704789 to pool.

Process finished with exit code 0

3、sqlSession相同，两次查询之间执行了增删改操作（增删改操作可能会对当前数据产生影响）

Mapper接口

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

Mapper.xml

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

测试

@Test
public void test(){
    SqlSession getsqlsession = MybatisUtils.getsqlsession();
    UserMapper mapper = getsqlsession.getMapper(UserMapper.class);
    //查询id=2的用户
    User user = mapper.queryUserById(2);
    System.out.println(user);
    //修改id=1的用户
    HashMap map = new HashMap();
    map.put("name","测试111");
    map.put("id",1);
    mapper.updateUser(map);
    //修改后再次查询id=2的用户
    User user2 = mapper.queryUserById(2);
    System.out.println(user2);

    System.out.println(user==user2);
    getsqlsession.close();
}

日志结果分析
- 从日志中可以看出，修改前之前一次sql查询，修改后又执行了一次sql查询，对象1!=对象2
- 因为增删改操作可能会对当前数据产生影响，所以要查询2次

Opening JDBC Connection
Created connection 1403704789.
==>  Preparing: select * from user where id = ?
==> Parameters: 1(Integer)
<==    Columns: id, name, password
<==        Row: 1, zhangsan, 123456
<==      Total: 1
User(id=1, name=zhangsan, password=123456)
==>  Preparing: update user set name = ? where id = ?
==> Parameters: 测试111(String), 1(Integer)
<==    Updates: 1
==>  Preparing: select * from user where id = ?
==> Parameters: 1(Integer)
<==    Columns: id, name, password
<==        Row: 1, 测试111, 123456
<==      Total: 1
User(id=1, name=测试111, password=123456)
false
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@53aad5d5]
Returned connection 1403704789 to pool.

4、sqlSession相同，手动清除一级缓存（ session.clearCache()）

测试

@Test
public void testQueryUserById4(){
    SqlSession getsqlsession = MybatisUtils.getsqlsession();
    UserMapper mapper = getsqlsession.getMapper(UserMapper.class);

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

    //清除缓存
    getsqlsession.clearCache();

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

日志结果分析
- 从日志可以看出，清除缓存前执行了一次sql查询，清除缓存后又执行了一次sql查询，对象1!=对象2
- 因为缓存被手动清除了，缓存中不存在这个数据，所以要查询2次

Opening JDBC Connection
Created connection 1403704789.
==>  Preparing: select * from user where id = ?
==> Parameters: 1(Integer)
<==    Columns: id, name, password
<==        Row: 1, 测试111, 123456
<==      Total: 1
User(id=1, name=测试111, password=123456)
==>  Preparing: select * from user where id = ?
==> Parameters: 1(Integer)
<==    Columns: id, name, password
<==        Row: 1, 测试111, 123456
<==      Total: 1
User(id=1, name=测试111, password=123456)
false
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@53aad5d5]
Returned connection 1403704789 to pool.

12.3、二级缓存

需要手动开启和配置，通过缓存接口Cache自定义
也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存
基于namespace级别的缓存，一个名称空间，对应一个二级缓存
工作机制
- 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中
- 未开启二级缓存：如果当前会话关闭了，这个会话对应的一级缓存就没了。开启二级缓存：会话提交或者关闭以后，一级缓存中的数据会转存到二级缓存中，新的会话查询信息（同一个Mapper中的查询）可以在二级缓存中拿到数据
- 不同的mapper查出的数据会放在自己对应的缓存（map）中

使用步骤

mybatis-config.xml开启全局缓存

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

每个Mapper.xml中配置使用二级缓存

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

测试

@Test
public void testQueryUserById5(){
    SqlSession session = MybatisUtils.getsqlsession();
    SqlSession session2 = MybatisUtils.getsqlsession();

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

    User user = mapper.queryUserById(1);
    System.out.println(user);
    //查询完id=1后，关闭session，数据会存到二级缓存中
    session.close();

    //再次查询id=1时，会从二级缓存中取到数据，不会再执行一次sql查询
    User user2 = mapper2.queryUserById(1);
    System.out.println(user2);
    //对象1=对象2
    System.out.println(user==user2);
    session2.close();
}

日志结果分析
- 从日志可以看出，第一次sql查询后关闭session，数据会存到二级缓存中，第二次再次查询不需要执行sql查询，直接从二级缓存中取到数据。

Opening JDBC Connection
Created connection 1380806038.
==>  Preparing: select * from user where id = ?
==> Parameters: 1(Integer)
<==    Columns: id, name, password
<==        Row: 1, 测试111, 123456
<==      Total: 1
User(id=1, name=测试111, password=123456)
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@524d6d96]
Returned connection 1380806038 to pool.
Cache Hit Ratio [com.leijiao.mapper.UserMapper]: 0.5
User(id=1, name=测试111, password=123456)
true

12.4、EhCache第三方缓存

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

pom.xml依赖

<!--  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.xml配置

<!--  ehcache第三方缓存  -->
<cache type = "org.mybatis.caches.ehcache.EhcacheCache" />

编写ehcache.xml

<?xml version="1.0" encoding="UTF8"?>
<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>

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，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。

–>

```