>[TOC]


# Mybatis

***

环境：
* JDK1.8
* Mysql5.7
* maven3.6.1
* IDEA

# 1、简介

***

## 1.1、什么是mybatis

* MyBatis 是一款优秀的持久层框架;
* 它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。
* 如何获得Mybatis
```xml
<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
```
* [中文文档](https://mybatis.org/mybatis-3/zh/index.html)
* [英文文档](https://github.com/mybatis/mybatis-3)

## 1.2、持久化

数据持久化

* 持久化就是将程序的数据在持久状态和瞬时状态转化的过程
* 内存：**断电即失**
* 数据库（JDBC）,io文件持久化
* 生活方面的例子：冷藏，罐头

为什么需要持久化

* 不想丢掉一些对象
* 内存太贵

## 1.3、持久层

Dao层，Service层，Controller层

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

## 1.4、为什么需要Mybatis

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

# 2、第一个Mybatis程序

***

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

## 2.1、搭建环境

搭建数据库
```sql
CREATE DATABASE `mybatis`;

USE `mybatis`;

DROP TABLE IF EXISTS `user`;

CREATE TABLE `user` (
`id` int(20) NOT NULL,
`name` varchar(30) DEFAULT NULL,
`pwd` varchar(30) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert  into `user`(`id`,`name`,`pwd`) values (1,'狂神','123456'),(2,'张三','abcdef'),(3,'李四','987654');
```

新建项目

* 新建一个普通maven项目
* 删除src目录
* 导入maven依赖

```xml
    <!--导入依赖-->
    <dependencies>
        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.22</version>
        </dependency>
        <!--mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>
```

## 2.2、创建一个模块

编写MyBatis核心配置文件
查看帮助文档

```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>
    <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://124.221.127.83:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="com/dao/UserMapper.xml"/>
    </mappers>
</configuration>
```

编写mybatis工具类

```java
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            // 使用mybatis工具类获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream 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、编写代码

* 实体类

```java
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接口

```java
public interface UseMapper {
    // 获取全部用户
    List<User> getUserList();

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

    // 添加一个用户
    int addUser(User user);

    // 修改一个用户
    int updateUser(User user);

    // 根据id删除用户
    int deleteUser(int id);
}
```

* mapper

```xml
<?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=绑定一个对应的Dao/Mapper窗口-->
<mapper namespace="com.dao.UseMapper">
    <!--select查询语句-->
    <select id="getUserList" resultType="com.entity.User">
        select *
        from user
    </select>

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

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

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

    <delete id="deleteUser" parameterType="int">
        delete from user where id = #{id}
    </delete>
</mapper>
```

# 3、万能的Map

***

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

```java
    // 万能的Map
    int addUser2(Map<String,Object> map);
```

```xml
    <insert id="addUser2" parameterType="map">
        insert into user (id,pwd) values (#{userid},#{password})
    </insert>
```

Map传递参数，直接在sql中取出key即可！
对象传递参数，直接在sql中取对象的属性即可！
只有一个基本类型参数的情况下，可以直接在sql中取到！
多个参数用Map，**或者注解！**

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

```xml
    <select id="getUserLike" resultType="com.entity.User">
        select * from user where name like "%"#{value}"%"
    </select>
```

# 4、配置解析

***

## 4.1、核心配置文件

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

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

## 4.2、环境变量

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

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

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

## 4.3、属性

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

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

编写一个配置文件

````pro
driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://124.221.127.83:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8
username=root
password=root
````

在核心配置文件中引入

mybatis-config.xml (同时有的话，外面properties优先)

```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>
    <!--引入外部配置文件-->
    <properties resource="db.properties">
        <property name="username" value="root"/>
        <property name="password" value="root"/>
    </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>

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


## 4.4、类型别名 typeAliases

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

```xml
<!--可以给实体类起别名-->
<typeAliases>
    <typeAlias type="com.entity.User" alias="User"/>
</typeAliases>
```

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

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

如果实体类十分多，建议用第二种扫描包的方式。第一种可以DIY别名，第二种不行，如果非要改，需要在实体上增加注解。

```java
@Alias("user")
public class User {
    ...
}
```

## 4.5、设置

| 设置名             | 描述                                                         | 有效值                                                       | 默认   |
| :----------------- | :----------------------------------------------------------- | :----------------------------------------------------------- | :----- |
| cacheEnabled       | 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存。     | true \| false                                                | true   |
| lazyLoadingEnabled | 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置 `fetchType` 属性来覆盖该项的开关状态。 | true \| false                                                | false  |
| logImpl            | 指定 MyBatis 所用日志的具体实现，未指定时将自动查找。        | SLF4J \| LOG4J \| LOG4J2 \| JDK_LOGGING \| COMMONS_LOGGING \| STDOUT_LOGGING \| NO_LOGGING | 未设置 |

## 4.6、映射器

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

方式一: [推荐使用]

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

方式二：

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

* 接口和它的Mapper必须同名
* 接口和他的Mapper必须在同一包下

方式三：

```xml
<mappers>
    <package name="com.dao" />
</mappers>
```

* 接口和它的Mapper必须同名
* 接口和他的Mapper必须在同一包下

## 4.7、作用域和生命周期

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

![image-20220228173708302](assets/image-20220228173708302.png)

**SqlSessionFactoryBuilder:**

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

**SqlSessionFactory:**

- 就是数据库连接池。
- 一旦被创建就应该在应用的运行期间一直存在 ，**没有任何理由丢弃它或重新创建另一个实例 。** 多次重建 SqlSessionFactory 被视为一种代码“坏习惯”。
- 因此 SqlSessionFactory 的最佳作用域是应用作用域。
- 最简单的就是使用单例模式或者静态单例模式。

**SqlSession**：

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

![image-20220228174524811](assets/image-20220228174524811.png)

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

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

***

数据库中的字段

![image-20220301123009394](assets/image-20220301123009394.png)

新建一个项目，拷贝之前，测试实体字段不一致的情况
User

```java
public class User {
    private int id;
    private String name;
    private String password;
}
```

![image-20220301123406863](assets/image-20220301123406863.png)

解决方法：
核心配置文件

* 起别名

```xml
    <select id="getUserById" parameterType="int" resultType="com.entity.User">
        select id, name, pwd as password from user where id = #{id}
    </select>
```

* resultMap 结果集映射

```xml
    <select id="getUserById" resultMap="UserMap" parameterType="int">
        select * from user where id = #{id}
    </select>

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

- `resultMap` 元素是 MyBatis 中最重要最强大的元素。
- ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

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

- resultMap 元素是 MyBatis 中最重要最强大的元素。
- ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
- ResultMap 的优秀之处——你完全可以不用显式地配置它们。
- 如果这个世界总是这么简单就好了。

# 6、日志

***

## 6.1、日志工厂

如果一个数据库操作出现了异常，我们需要排错。日志就是最好的助手。
曾经：sout，debug
现在：日志工厂

 ![image-20220301130041815](assets/image-20220301130041815.png)

- SLF4J
- LOG4J [掌握]
- LOG4J2
- JDK_LOGGING
- COMMONS_LOGGING
- STDOUT_LOGGING [掌握]
- NO_LOGGING

具体使用哪一个，在设置中设定
**STDOUT_LOGGING 标志日志输出**
mybatis-confi中

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

![image-20220301130602068](assets/image-20220301130602068.png)

## 6.2、Log4j

1. 先导包

```xml
        <!--log4j-->
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
```

2. 新建log4j.properties文件

```properties
### set log levels ###
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/hou.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. 配置实现

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

4. log4j的使用

![image-20220301131606082](assets/image-20220301131606082.png)

## 6.3、log4j简单使用

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

```java
 Logger logger = Logger.getLogger(UserDaoTest.class);
```

3. 日志级别

```java
logger.info("info: 测试log4j");
logger.debug("debug: 测试log4j");
logger.error("error:测试log4j");
```

# 7、分页

***

**思考：为什么分页?**

- 减少数据的处理量

## 7.1、使用limit分页

```sql
SELECT * FROM user LIMIT startIndex,pageSize;
SELECT * FROM user LIMIT end; #[0, end]
```

**使用MyBatis实现分页，核心SQL**

1. 接口

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

2. Mapper.xml

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

3. 测试

   ```java
       @Test
       public void getUserByLimit(){
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           UserMapper mapper = sqlSession.getMapper(UserMapper.class);
   
           Map<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分页

不再使用SQL实现分页

1. 接口

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

2. mapper.xml

   ```xml
   <!--分页查询2-->
   <select id="getUserByRowBounds">
       select * from user limit #{startIndex},#{pageSize}
   </select>
   ```

3. 测试

   ```java
   @Test
   public void getUserByRow(){
       SqlSession sqlSession = MybatisUtils.getSqlSession();
       // RowBounds实现
       RowBounds rowBounds = new RowBounds(1, 2);
   
       // 通过java代码层面
       List<User> userList = sqlSession.selectList
           ("com.dao.UserMapper.getUserByRowBounds",
            null,rowBounds);
   
       for (User user : userList) {
           System.out.println(user);
       }
   
       sqlSession.close();
   }
   ```

## 7.3、分页插件

![image-20220301143250719](assets/image-20220301143250719.png)

# 8、使用注解开发

***

## 8.1、面向接口编程

**三个面向区别**

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

## 8.2、使用注解开发

1. 删除 UserMapper.xml

2. UserMapper

   ```java
   public interface UserMapper {
   
       @Select("select * from user")
       List<User> getUsers();
   }
   ```

3. 核心配置 mybatis-config.xml

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

   本质：反射机制

   底层：动态代理

![image-20220301151910709](assets/image-20220301151910709.png)

**Mybatis详细执行流程：**

1. Resource获取全局配置文件
2. 实例化SqlsessionFactoryBuilder
3. 解析配置文件流XMLCondigBuilder
4. Configration所有的配置信息
5. SqlSessionFactory实例化
6. trasactional事务管理
7. 创建executor执行器
8. 创建SqlSession
9. 实现CRUD
10. 查看是否执行成功
11. 提交事务
12. 关闭

![Mybatis详细执行流程](assets/20201017070716720.png)

## 8.3、注解CRUD

编写接口

```java
public interface UserMapper {
    // 获取全部用户
    @Select("select * from user")
    List<User> getUserList();

    // 方法存在多个参数，所有的参数必须加@Param
    @Select("select * from user where id = #{id}")
    User getUserById(@Param("id") int id);

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

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

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

MybatisUtile

```java
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            // 使用mybatis工具类获取sqlSessionFactory对象
            String resource = "mybatis-config.xml";
            InputStream 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(true);
    }

}
```

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

```java
public class UserMapperTest {

    @Test
    public void getUserById(){
        // 获得sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        try{
            // 1.执行 getMapper
            UserMapper userDao = sqlSession.getMapper(UserMapper.class);
            User user = userDao.getUserById(1);

            System.out.println(user);


        }catch(Exception e){
            e.printStackTrace();
        }finally{
            // 关闭
            sqlSession.close();
        }
    }

    @Test
    public void addUser(){
        // 获得sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        try{
            // 1.执行 getMapper
            UserMapper userDao = sqlSession.getMapper(UserMapper.class);
            userDao.addUser(new User(6, "kun","123"));

        }catch(Exception e){
            e.printStackTrace();
        }finally{
            // 关闭
            sqlSession.close();
        }
    }

    @Test
    public void updateUser(){
        // 获得sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        try{
            // 1.执行 getMapper
            UserMapper userDao = sqlSession.getMapper(UserMapper.class);
            userDao.updateUser(new User(6, "fang","123"));

        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //关闭
            sqlSession.close();
        }
    }

    @Test
    public void deleteUser(){
        // 获得sqlSession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        try{
            // 1.执行 getMapper
            UserMapper userDao = sqlSession.getMapper(UserMapper.class);
            userDao.deleteUser(6);

        }catch(Exception e){
            e.printStackTrace();
        }finally{
            //关闭
            sqlSession.close();
        }
    }
}
```

**关于@Param( )注解**

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

**#{} 和 ${}**

* 一般使用#号，防止注入
* 两个都可以使用

# 9、Lombok

***

Lombok项目是一个Java库，它会自动插入编辑器和构建工具中，Lombok提供了一组有用的注释，用来消除Java类中的大量样板代码。仅五个字符(@Data)就可以替换数百行代码从而产生干净，简洁且易于维护的Java类。

使用步骤：

1. 在IDEA中安装Lombok插件，现在已经不需要安装，idea已经内置

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

   ```xml
   <dependency>
       <groupId>org.projectlombok</groupId>
       <artifactId>lombok</artifactId>
       <version>1.18.8</version>
   </dependency>
   ```

3. 在程序上加注解

   在实体类上加注解

   ```java
   @AllArgsConstructor // 有参构造
   @NoArgsConstructor // 无参构造
   @Data // 无参构造，get，set，toString，hashCode
   public class User {
       private int id;
       private String name;
       private String pwd;
   }
   ```

![image-20220301155900195](assets/image-20220301155900195.png)

# 10、多对一处理

****

![image-20220301163509735](assets/image-20220301163509735.png)

多对一：

- 多个学生，对应一个老师
- 对于学生而言，**关联**–多个学生，关联一个老师【多对一】
- 对于老师而言，**集合**–一个老师，有很多个学生【一对多】

SQL语句：

```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
3. 建立Mapper接口
4. 建立Mapper.xml文件
5. 在核心配置文件中绑定注册我们的Mapper接口或者文件 【方式很多，随心选】
6. 测试查询是否能够成功

## 10.1、按照查询嵌套处理

1. 给StudentMapper接口增加方法

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

2. 编写对应打的Mapper文件

   ```xml
   <?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">
   <mapper namespace="com.kuang.dao.StudentMapper">
   
       <!--
       需求：获取所有学生及对应老师的信息
       思路：
           1. 获取所有学生的信息
           2. 根据获取的学生信息的老师ID->获取该老师的信息
           3. 思考问题，这样学生的结果集中应该包含老师，该如何处理呢，数据库中我们一般使用关联查询？
               1. 做一个结果集映射：StudentTeacher
               2. StudentTeacher结果集的类型为 Student
               3. 学生中老师的属性为teacher，对应数据库中为tid。
                  多个 [1,...）学生关联一个老师=> 一对一，一对多
               4. 查看官网找到：association – 一个复杂类型的关联；使用它来处理关联查询
       -->
       <select id="getStudents" resultMap="StudentTeacher">
       select * from student
      </select>
       <resultMap id="StudentTeacher" type="Student">
           <!--association关联属性 property属性名 javaType属性类型 column在多的一方的表中的列名-->
           <association property="teacher"  column="tid" javaType="Teacher" select="getTeacher"/>
       </resultMap>
       <!--
       这里传递过来的id，只有一个属性的时候，下面可以写任何值
       association中column多参数配置：
           column="{key=value,key=value}"
           其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的字段名。
       -->
       <select id="getTeacher" resultType="teacher">
         select * from teacher where id = #{id}
      </select>
   
   </mapper>
   ```

3. 编写完毕去Mybatis配置文件中，注册Mapper!

4. 注意点说明：

   ```xml
   <resultMap id="StudentTeacher" type="Student">
      <!--association关联属性 property属性名 javaType属性类型 column在多的一方的表中的列名-->
      <association property="teacher"  column="{id=tid,name=tid}" javaType="Teacher" select="getTeacher"/>
   </resultMap>
   <!--
   这里传递过来的id，只有一个属性的时候，下面可以写任何值
   association中column多参数配置：
      column="{key=value,key=value}"
      其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的字段名。
   -->
   <select id="getTeacher" resultType="teacher">
     select * from teacher where id = #{id} and name = #{name}
   </select>
   ```

5. 测试

   ```java
   @Test
   public void testGetStudents(){
      SqlSession session = MybatisUtils.getSession();
      StudentMapper mapper = session.getMapper(StudentMapper.class);
   
      List<Student> students = mapper.getStudents();
   
      for (Student student : students){
          System.out.println(
                  "学生名:"+ student.getName()
                          +"\t老师:"+student.getTeacher().getName());
     }
   }
   ```

## 10.2、按照结果嵌套查询

除了上面这种方式，还有其他思路吗？

我们还可以按照结果进行嵌套处理；

1. 接口方法编写

   ```java
   public List<Student> getStudents2();
   ```

2. 编写对应的mapper文件

   ```xml
       <!--
       按查询结果嵌套处理
       思路：
       1. 直接查询出结果，进行结果集的映射
       -->
       <select id="getStudents2" resultMap="StudentTeacher2">
           select s.id sid, s.name sname, t.name tname, t.id tid
           from student s,
                teacher t
           where s.tid = t.id
       </select>
   
       <resultMap id="StudentTeacher2" type="Student">
           <!--
           id是作为唯一标识的，当和其他对象实例对比的时候，
           这个id很有用，尤其是应用到缓存和内嵌的结果映射。
           result可以有多个，分别对应数据库中的各个字段和实体类中的属性。
           -->
           <id property="id" column="sid"/>
           <result property="name" column="sname"/>
           <!--关联对象property 关联对象在Student实体类中的属性-->
           <association property="teacher" javaType="Teacher">
               <id property="id" column="tid"/>
               <result property="name" column="tname"/>
           </association>
       </resultMap>
   ```

3. 去mybatis-config文件中注入【此处应该处理过了】

   ```xml
       <!--绑定接口-->
       <mappers>
           <mapper resource="com/dao/TeacherMapper.xml"/>
           <mapper resource="com/dao/StudentMapper.xml"/>
       </mappers>
   ```

4. 测试

   ```java
       @Test
       public void testGetStudents2() {
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
   
           List<Student> students = mapper.getStudents2();
   
           for (Student student : students) {
               System.out.println(student);
           }
           sqlSession.close();
       }
   ```

小结

- 按照查询进行嵌套处理就像SQL中的子查询
- 按照结果进行嵌套处理就像SQL中的联表查询

回顾Mysql多对一查询方式：

- 子查询
- 联表查询

# 11、一对多处理

***

比如：一个老师拥有多个学生！
对于老师而言，就是一对多的关系！

## 11.1、环境搭建

1. 环境搭建，和刚才一样
   **实体类：**

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

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

   ..... 和之前一样，搭建测试的环境！

## 11.2、按照结果嵌套查询

1. TeacherMapper接口编写方法

   ```java
   // 获取指定老师，及老师下的所有学生
   Teacher getTeacher(@Param("tid") int id);
   ```

2. 编写接口对应的Mapper配置文件

   ```xml
       <!--
       思路:
       1. 从学生表和老师表中查出学生id，学生姓名，老师姓名
       2. 对查询出来的操作做结果集映射
           1. 集合的话，使用collection！
               JavaType和ofType都是用来指定对象类型的
               JavaType是用来指定entity中属性的类型
               ofType-相当于泛型-指定的是映射到list集合属性中entity的类型。
       -->
       <select id="getTeacher" resultMap="TeacherStudent">
           select s.id sid, s.name sname , t.name tname, t.id tid
           from student s,teacher t
           where s.tid = t.id and t.id=#{tid}
       </select>
   
       <resultMap id="TeacherStudent" type="Teacher">
           <id property="id" column="tid"/>
           <result property="name" column="tname"/>
           <collection property="students" ofType="Student">
               <result property="id" column="sid" />
               <result property="name" column="sname" />
               <result property="tid" column="tid" />
           </collection>
       </resultMap>
   ```

3. 将Mapper文件注册到MyBatis-config文件中

   ```xml
       <!--绑定接口-->
       <mappers>
           <mapper resource="com/dao/TeacherMapper.xml"/>
           <mapper resource="com/dao/StudentMapper.xml"/>
       </mappers>
   ```

4. 测试

   ```java
       @Test
       public void test() {
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
           Teacher teacher = mapper.getTeacher(1);
           List<Student> students = teacher.getStudents();
           for (Student student : students) {
               System.out.println(student);
           }
           sqlSession.close();
       }
   ```

## 11.3、按照查询嵌套处理

1. TeacherMapper接口编写方法

   ```java
   public Teacher getTeacher2(int id);
   ```

2. 编写接口对应的Mapper配置文件

   ```xml
       <select id="getTeacher2" resultMap="TeacherStudent2">
           select * from teacher where id = #{tid}
       </select>
       <resultMap id="TeacherStudent2" type="Teacher">
           <id property="id" column="id"/>
           <result property="name" column="name"/>
           <!--column是一对多的外键 , 写的是一的主键的列名-->
           <collection property="students" ofType="Student" column="id" select="getStudentByTeacherId"/>
       </resultMap>
       <select id="getStudentByTeacherId" resultType="Student">
           select * from student where tid = #{id}
       </select>
   ```

3. 将Mapper文件注册到MyBatis-config文件中

4. 测试

   ```java
       @Test
       public void test() {
           SqlSession sqlSession = MybatisUtils.getSqlSession();
           TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
           Teacher teacher = mapper.getTeacher2(1);
           System.out.println(teacher);
           sqlSession.close();
       }
   ```

**小结**

1. 关联-association
2. 集合-collection
3. 所以association是用于一对一和多对一，而collection是用于一对多的关系
4. javaType和ofType都是用来指定对象类型的
   - JavaType是用来指定entity中属性的类型
   - ofType指定的是映射到list集合属性中entity的类型，泛型的约束类型

**注意说明：**

1. 保证SQL的可读性，尽量通俗易懂
2. 根据实际要求，尽量编写性能更高的SQL语句
3. 注意属性名和字段不一致的问题
4. 注意一对多和多对一 中：字段和属性对应的问题
5. 尽量使用Log4j，通过日志来查看自己的错误

**面试高频：**

* Mysql引擎
* InnoDB底层原理
* 索引
* 索引优化

# 12、动态SQL

***

什么是动态SQL：动态SQL指的是根据不同的查询条件 , 生成不同的Sql语句.

```java
官网描述：
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
  -------------------------------
```

我们之前写的 SQL 语句都比较简单，如果有比较复杂的业务，我们需要写复杂的 SQL 语句，往往需要拼接，而拼接 SQL ，稍微不注意，由于引号，空格等缺失可能都会导致错误。

那么怎么去解决这个问题呢？这就要使用 mybatis 动态SQL，通过 `if, choose, when, otherwise, trim, where, set, foreach`等标签，可组合成非常灵活的SQL语句，从而在提高 SQL 语句的准确性的同时，也大大提高了开发人员的效率。

## 12.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
```

1. 创建mybatis基础工程
2. IDUtils工具类
3. 实体类编写

```java
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Blog {
    private String id;
    private String title;
    private String author;
    private Date createTime;
    private int views;
}
```

4. mapper接口和xml文件

```java
public interface BlogMapper {
    // 插入数据
    int addBlog(Blog blog);
}

    <insert id="addBlog" parameterType="Blog">
        insert into blog (id, title, author, create_time, views)
        values (#{id},#{title},#{author},#{createTime},#{views});
    </insert>
```
5. mybatis核心配置文件，下环线自动转换

```xml
    <settings>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>

    <typeAliases>
        <typeAlias type="com.entity.Blog" alias="Blog"/>
    </typeAliases>

```
6. 插入数据

```java
    @Test
    public void addInitBlog(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        Blog blog = new Blog();
        blog.setId(IDUtils.genId());
        blog.setTitle("Mybatis如此简单");
        blog.setAuthor("狂神说");
        blog.setCreateTime(new Date());
        blog.setViews(9999);

        mapper.addBlog(blog);

        blog.setId(IDUtils.genId());
        blog.setTitle("Java如此简单");
        mapper.addBlog(blog);

        blog.setId(IDUtils.genId());
        blog.setTitle("Spring如此简单");
        mapper.addBlog(blog);

        blog.setId(IDUtils.genId());
        blog.setTitle("微服务如此简单");
        mapper.addBlog(blog);

        sqlSession.close();
    }
```

## 12.2、关键字

### if

需求：根据作者名字和博客名字来查询博客！如果作者名字为空，那么只根据博客名字查询，反之，则根据作者名来查询

1. 编写接口类

   ```java
   // 需求1
   List<Blog> queryBlogIf(Map map);
   ```

2. 编写SQL语句

   ```xml
   <!--需求1：
   根据作者名字和博客名字来查询博客！
   如果作者名字为空，那么只根据博客名字查询，反之，则根据作者名来查询
   -->
   <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>
   ```

3. 测试

   ```java
   @Test
   public void testQueryBlogIf(){
      SqlSession session = MybatisUtils.getSession();
      BlogMapper mapper = session.getMapper(BlogMapper.class);
   
      HashMap<String, String> map = new HashMap<String, String>();
      map.put("title","Mybatis如此简单");
      map.put("author","狂神说");
      List<Blog> blogs = mapper.queryBlogIf(map);
   
      System.out.println(blogs);
   
      session.close();
   }
   ```

### where

修改上面的SQL语句；

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

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

### choose

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

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

MyBatis 提供了 choose 元素。if标签是与(and)的关系，而 choose 是或(or)的关系。

choose标签是按顺序判断其内部when标签中的test条件出否成立，如果有一个成立，则 choose 结束。当 choose 中所有 when 的条件都不满则时，则执行 otherwise 中的sql。类似于Java 的 switch 语句，choose 为 switch，when 为 case，otherwise 则为 default。

### set

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

```xml
<!--注意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>
```

### trim

```xml
    <insert id="addBlog" parameterType="Blog">
        insert into blog
        <trim prefix="(" suffix=")" suffixOverrides=",">
            <if test="id != null">
                id,
            </if>
            <if test="title != null">
                title,
            </if>
            <if test="author != null">
                author,
            </if>
            <if test="createTime != null">
                create_time,
            </if>
            <if test="views != 0">
                views
            </if>
        </trim>
        values
        <trim prefix="(" suffix=")" suffixOverrides=",">
        <if test="id != null">
            #{id},
        </if>
        <if test="title != null">
            #{title},
        </if>
        <if test="author != null">
            #{author},
        </if>
        <if test="createTime != null">
            #{createTime},
        </if>
        <if test="views != 0">
            #{views}
        </if>
        </trim>;
    </insert>

```

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

### SQL片段

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

提取SQL片段：

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

引用SQL片段：

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

注意：

1. 最好基于 单表来定义 sql 片段，提高片段的可重用性
2. 在 sql 片段中不要包括 where

### ForEach

- 动态 SQL 的另一个常见使用场景是对集合进行遍历（尤其是在构建 IN 条件语句的时候）。
- foreach 元素的功能非常强大，它允许你指定一个集合，声明可以在元素体内使用的集合项（item）和索引（index）变量。它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符。这个元素也不会错误地添加多余的分隔符，看它多智能！
- 提示你可以将任何可迭代对象（如 List、Set 等）、Map 对象或者数组对象作为集合参数传递给  foreach。当使用可迭代对象或者数组时，index 是当前迭代的序号，item 的值是本次迭代获取到的元素。当使用 Map 对象（或者  Map.Entry 对象的集合）时，index 是键，item 是值。

> 将数据库中前三个数据的id修改为1,2,3；
>
> 需求：我们需要查询 blog 表中 id 分别为1,2,3的博客信息

1. 编写接口

   ```java
   List<Blog> queryBlogForeach(Map map);
   ```

2. 编写SQL语句

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

3. 测试

   ```java
   @Test
   public void testQueryBlogForeach(){
       SqlSession sqlSession = MybatisUtils.getSqlSession();
       BlogMapper mapper = sqlSession.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);
       for (Blog blog : blogs) {
           System.out.println(blog);
       }
   
       sqlSession.close();
   }
   ```

### 小结

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

# 13、缓存

***

## 13.1、简介
1. 什么是缓存
- 存在内存中的临时数据。
- 将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上（关系型数据库查询文件）查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。

2. 为什么使用缓存

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

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

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

## 13.2、Mybatis缓存

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

## 13.3、一级缓存

一级缓存也叫本地缓存：

与数据库同一次会话期间查询到的数据会放在本地缓存中。

以后如果需要获取相同的数据，直接从缓存中拿，没必须再去查询数据库；

测试

1. 在mybatis中加入日志，方便测试结果
2. 编写接口方法

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

3. 接口对应的Mapper文件

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

4. 测试

```java
@Test
public void testQueryUserById(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.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);

    sqlSession.close();
}
```

5. 结果分析

![image-20220313144802945](assets/image-20220313144802945.png)

> **一级缓存失效的四种情况**

一级缓存是SqlSession级别的缓存，是一直开启的，我们关闭不了它；
一级缓存失效情况：没有使用到当前的一级缓存，效果就是，还需要再向数据库中发起一次查询请求！

1. sqlSession不同

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

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

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

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

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

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

   结论：**因为增删改操作可能会对当前数据产生影响**
   
4. sqlSession相同，手动清除一级缓存

   结论：清理缓存相当于刷新内存

> 小结：**一级缓存默认是开启的，只有一次SqlSession中有效，也就是拿到连接到关闭连接的区间段**-----相当于一个map

## 13.4、二级缓存

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

> **使用步骤**

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

```xml
<!--虽然默认已经开启了，但是还是需要显示的声明，以便其他开发者知道-->
<setting name="cacheEnabled" value="true"/>
```

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

```xml
<cache/>

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

3. 代码测试

   所有的实体类先实现序列化接口

   测试代码
```java
@Test
public void test(){
    SqlSession sqlSession1 = MybatisUtils.getSqlSession();
    SqlSession sqlSession2 = MybatisUtils.getSqlSession();

    UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
    UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);

    User user1 = mapper1.queryUserById(1);
    System.out.println(user1);
    sqlSession1.close();

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

    sqlSession2.close();
}
```

> **结论**

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

## 13.5、缓存原理

![缓存原理](assets/20201030140755274.png)