新增：《初识MyBatis | SQL映射文件》

repos/courses/mybatis/01-MyBatis基础/04-SQL映射文件之查询元素.md

@@ -0,0 +1,519 @@
+---
+title: SQL映射文件之查询元素
+author: 查尔斯
+date: 2020/12/27 23:35
+categories:
+ - MyBatis快速入门
+tags:
+ - MyBatis
+ - ORM框架
+---
+
+# SQL映射文件之查询元素
+
+## 前言
+
+**C：** 在上一篇，笔者带大家对 MyBatis 的核心配置文件做了介绍。本篇开始，笔者将带你学习 MyBatis 的 SQL 映射文件，它是 MyBatis 中亮点最多的部分（翻回去看看 MyBatis 特点，主要优势都在这儿），同时也是未来我们使用 MyBatis 开发时接触最多的部分。
+
+不过你也别担心，MyBatis 在 SQL 语句映射方面异常强大，但 SQL 映射文件却是相当简单。
+
+下方是 SQL 映射文件的标签模板，笔者将花两三篇对其中常用的一些标签的常用使用方式进行介绍。
+
+**mapper** 根标签
+
+- cache-ref  引用其它命名空间的缓存配置
+- **cache**  配置给定命名空间的缓存
+- ***resultMap***  （自定义结果集映射配置）用来描述数据库结果集和对象的对应关系，是最复杂也是最强大的元素
+- ~~parameterMap~~ （自定义参数映射配置）此元素已被废弃，并可能在将来被移除！请使用行内参数映射。
+- **sql**  可以重用的 SQL 块
+- **insert**  映射插入语句
+- **update**  映射更新语句
+- **delete**  映射删除语句
+- **select**  映射查询语句
+
+![202012271107691](../../../public/img/2020/12/27/202012271107691.png)
+
+## mapper元素
+
+mapper 元素是 SQL 映射文件的根标签，在该标签内有一个属性 namespace（命名空间），可以理解为当前 SQL 映射文件的标识。
+
+**传统 SqlSession 开发中** ，mapper 元素的 namespace 属性和下方子元素的 id 属性联合保证了 SQL 语句的唯一标识。
+
+```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="userMapper">
+    <select id="selectList" resultType="User">
+        SELECT * FROM `user`
+    </select>
+</mapper>
+```
+
+```java
+List<User> userList = sqlSession.selectList("userMapper.selectList");
+```
+
+**SqlSession 的 Mapper 接口开发中** ，mapper 元素的 namespace 属性必须命名为对应的 Mapper 接口的全限定类名，下方子元素也要和对应 Mapper 接口中的方法一 一对应。
+
+```java
+package com.example.mapper;
+// ...略...
+public interface UserMapper {
+
+    /**
+     * 查询用户列表
+     * @return /
+     */
+    List<User> selectList();
+	
+}
+```
+
+```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.example.mapper.UserMapper">
+    <!-- List<User> selectList();  -->
+    <select id="selectList" resultType="User">
+        SELECT * FROM `user`
+    </select>
+</mapper>
+```
+
+::: tip 笔者说
+Mapper 接口开发是我们上篇中最后部分讲解过的 SqlSession 使用方式，以后也是主要的写法，很好理解，GKD掌握。
+:::
+
+## select元素
+
+在每一个项目中，查询都是应用最频繁也是应用最困难的部分。 在 SQL 映射文件中，select 元素就是用于编写查询 SQL 的，它是 MyBatis 中最常用的元素之一。
+
+select 元素有很多属性，可以很详细的来配置每条语句的行为细节。
+
+- **id** 命名空间中唯一的标识符
+
+  Mapper 接口开发中，id 值需要和接口中对应方法的名字保持一致
+
+- **parameterType** 传入SQL语句的参数类型
+
+  可以为参数类型的全限定类名或别名
+
+  Mapper接口开发中，parameterType 值需要和接口中对应方法的参数类型保持一致
+
+- **resultType** SQL语句返回值类型（详细解释见 resultMap 元素部分）
+
+  可以为返回值类型的全限定类名或别名
+
+  Mapper接口开发中，resultType 值需要和接口中对应方法的返回值类型保持一致
+
+  **注意：** 如果返回值类型是集合，那么 resultType 值应该表示为集合的泛型类型，而不是集合类型。
+
+接下来，笔者通过几个示例来带大家掌握下 select 元素的使用。
+
+::: tip 笔者说
+笔者只是介绍了使用最为频繁的几个属性，如果想了解更多的属性含义，可以前往[官网](https://mybatis.org/mybatis-3/zh/sqlmap-xml.html)查看。
+:::
+
+### 用户名查询
+
+在《快速入门》篇的数据库基础上，我们先来实现一个根据用户名的模糊查询。
+
+首先，在 Mapper 接口中我们添加一个方法。
+
+```java
+public interface UserMapper {
+
+    /**
+     * 根据用户名模糊查询
+     * @param name 用户名
+     * @return 用户列表
+     */
+    List<User> selectByName(String name);
+
+}
+```
+
+然后我们在 SQL 映射文件中再添加一个与该方法对应的查询元素。
+
+```xml
+<!-- List<User> selectByName(String name); -->
+<!-- 通过#{参数名}即可获取传入的值 -->
+<select id="selectByName" parameterType="string" resultType="User">
+    select * from user where name like concat('%', #{name}, '%')
+</select>
+```
+
+测试一下：
+
+```java
+class TestMyBatis {
+
+    @Test
+    void testSelectByName() throws IOException {
+        // 获取SqlSession对象
+        try (SqlSession sqlSession = MyBatisUtils.openSession()) {
+
+            // 获取 Mapper 接口
+            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
+            // 执行 SQL
+            List<User> userList = userMapper.selectByName("J");
+
+            // 遍历数据
+            userList.forEach(System.out::println);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}
+```
+
+**控制台输出：** 
+
+```sql
+-- 输出的 SQL 语句
+select * from user where name like concat('%', ?, '%')
+```
+
+```
+User [id=1, name=Jone, age=18, email=Jone@126.com]
+User [id=2, name=Jack, age=20, email=Jack@126.com]
+```
+
+#### #{}和${}的区别
+
+在控制台输出的 MyBatis 日志中，我们可以看到最后执行的 SQL 就是我们在传统 JDBC 开发中，为了解决 SQL 注入攻击而编写的 SQL 形式。
+
+之所以输出如此，是因为我们使用了 #{} 的形式来使用参数，\#{}表示一个占位符号，可以接收简单类型值或 POJO 属性值，通过 #{} 可以实现 preparedStatement 向占位符中设置值，自动进行 Java 类型和 JDBC 类型转换。#{} 可以有效防止 SQL 注入。
+
+**注意：** #{} 占位符不能放置在字符串中，即：select * from user where name like '%#{name}%' 是错误的。
+
+---
+
+其实在 MyBatis 中还有占位符：${}，但是基本不使用，至于原因，我们试试看就知道了。
+
+```xml
+<!-- List<User> selectByName(String name); -->
+<!-- ${参数名} 可以直接放在字符串中 -->
+<select id="selectByName" parameterType="string" resultType="User">
+    select * from user where name like '%${name}%'
+</select>
+```
+
+**控制台输出：** 
+
+```sql
+-- 输出的 SQL 语句
+select * from user where name like '%J%'
+```
+
+这回知道原因了吧？ **总结一下它们的区别（面试题）** ：
+
+-  在使用`#{}`参数语法时，MyBatis 会创建 `PreparedStatement` 参数占位符，并通过占位符安全地设置参数（就像使用 ? 一样）[1]
+- 在使用 `${}` 时，MyBatis 会将 SQL 中的 `${}` 替换成对应变量的值。适合需要直接插入一个不转义的字符串时使用。
+- 使用 #{} 可以有效的防止 SQL 注入，提高系统安全性。
+
+### 多参数查询
+
+我们也都知道，在 Java 中定义方法的时候，返回值类型只能设定为一个具体类型，但是方法的参数是可以定义 N 个的，那么在面对这种方法时，MyBatis 查询元素的 parameterType 该如何使用呢？
+
+其实也非常简单，**有三种方式比较流行** ：
+
+- 将多个参数封装到 POJO / 自定义对象中
+- 将多个参数封装到 Map / List 集合中
+- 将多个参数通过 @Param 注解标注
+
+我们通过一个案例感受下不同方式的区别： **案例需求：根据用户名、年龄查询用户列表** 
+
+#### 封装到POJO
+
+首先，在 Mapper 接口中我们添加一个方法。
+
+```java
+public interface UserMapper {
+
+    /**
+     * 根据用户名和年龄查询
+     * @param user 用户信息
+     * @return 用户列表
+     */
+    List<User> selectByUser(User user);
+
+}
+```
+
+然后我们在 SQL 映射文件中再添加一个与该方法对应的查询元素。
+
+```xml
+<!-- List<User> selectByUser(User user); -->
+<!-- 在 parameterType 为对象时, #{属性名} 可以获取对象中的属性值 -->
+<select id="selectByUser" parameterType="User" resultType="User">
+    select
+        * 
+    from
+        user 
+    where 
+        name like concat('%', #{name}, '%')
+        and age = #{age}
+</select>
+```
+
+测试一下：
+
+```java
+class TestMyBatis {
+
+    @Test
+    void testSelectByUser() throws IOException {
+        // 获取SqlSession对象
+        try (SqlSession sqlSession = MyBatisUtils.openSession()) {
+
+            // 获取 Mapper 接口
+            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
+            // 执行 SQL
+            User user = new User();
+            user.setName("J");
+            user.setAge(20);
+            List<User> userList = userMapper.selectByUser(user);
+
+            // 遍历数据
+            userList.forEach(System.out::println);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}
+```
+
+**控制台输出：** 
+
+```sql
+-- 输出的 SQL 语句
+select * from user where name like concat('%', ?, '%') and age = ?
+```
+
+```
+User [id=2, name=Jack, age=20, email=Jack@126.com]
+```
+
+#### 封装到Map集合
+
+::: tip 笔者说
+笔者个人比较喜欢这一种，Map 集合总是那么"万金油"。
+:::
+
+首先，在 Mapper 接口中我们添加一个方法。
+
+```java
+public interface UserMapper {
+
+    /**
+     * 根据用户名和年龄查询
+     * @param params 条件参数
+     * @return 用户列表
+     */
+    List<User> selectByMap(Map<String, Object> params);
+
+}
+```
+
+然后我们在 SQL 映射文件中再添加一个与该方法对应的查询元素。
+
+```xml
+<!-- List<User> selectByMap(Map<String, Object> params); -->
+<!-- 在 parameterType 为 Map 集合时, #{map的键名} 可以获取集合的值 -->
+<select id="selectByMap" parameterType="map" resultType="User">
+    select
+        * 
+    from
+        user 
+    where 
+        name like concat('%', #{name}, '%')
+        and age = #{age}
+</select>
+```
+
+测试一下：
+
+```java
+class TestMyBatis {
+
+    @Test
+    void testSelectByMap() throws IOException {
+        // 获取SqlSession对象
+        try (SqlSession sqlSession = MyBatisUtils.openSession()) {
+
+            // 获取 Mapper 接口
+            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
+            // 执行 SQL
+            Map<String, Object> params = new HashMap<>();
+            params.put("name", "J");
+            params.put("age", 20);
+            List<User> userList = userMapper.selectByMap(params);
+
+            // 遍历数据
+            userList.forEach(System.out::println);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}
+```
+
+**控制台输出：** 
+
+```sql
+-- 输出的 SQL 语句
+select * from user where name like concat('%', ?, '%') and age = ?
+```
+
+```
+User [id=2, name=Jack, age=20, email=Jack@126.com]
+```
+
+#### @Param注解
+
+::: tip 笔者说
+@Param 注解与上述两种方式有些不同，如果你使用了该注解，那么 parameterType 就不需要再手动指定了，使用 **普通类型参数** （Java中的 int、double、String...... 这些都属于普通类型参数，而对象和集合就不属于普通类型参数了）的方法一般都推荐使用它。
+:::
+
+首先，在 Mapper 接口中我们添加一个方法。
+
+```java
+public interface UserMapper {
+
+    /**
+     * 根据用户名和年龄查询
+     * @param name 用户名
+     * @param age 年龄
+     * @return 用户列表
+     */
+    // @Param("参数名") 注解中传入的参数名才是占位符要使用到的名字
+    List<User> selectByParam(@Param("name") String name, @Param("age") Integer age);
+
+}
+```
+
+然后我们在 SQL 映射文件中再添加一个与该方法对应的查询元素。
+
+```xml
+<!-- List<User> selectByParam(@Param("name") String name, @Param("age") Integer age); -->
+<!-- #{@Param注解设定的名} 可以用来取出对应参数的值 -->
+<select id="selectByParam" resultType="User">
+    select
+        * 
+    from
+        user 
+    where 
+        name like concat('%', #{name}, '%')
+        and age = #{age}
+</select>
+```
+
+测试一下：
+
+```java
+class TestMyBatis {
+
+    @Test
+    void testSelectByParam() throws IOException {
+        // 获取SqlSession对象
+        try (SqlSession sqlSession = MyBatisUtils.openSession()) {
+
+            // 获取 Mapper 接口
+            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
+            // 执行 SQL
+            List<User> userList = userMapper.selectByParam("j", 20);
+
+            // 遍历数据
+            userList.forEach(System.out::println);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}
+```
+
+**控制台输出：** 
+
+```sql
+-- 输出的 SQL 语句
+select * from user where name like concat('%', ?, '%') and age = ?
+```
+
+```
+User [id=2, name=Jack, age=20, email=Jack@126.com]
+```
+
+::: warning 使用注意
+超过 3 个以上的 **普通类型参数** 最好封装成对象或 Map 来入参（特别是在常规的增加和修改操作时，字段较多，封装成对象比较方便），而参数固定的业务方法，最好使用 @Param 来入参（这种方法比较灵活，代码的可读性高，可以清晰看出来这个接口方法的所需的参数是什么，并且对于固定的接口方法，参数一般是固定的，所以可以使用直接参数入参即可，无需封装对象。例如：修改个人密码的方法，根据 id 删除用户的方法，根据 id 查看用户明细的方法，都可以采取这种方式）
+::: 
+
+## sql元素
+
+在同一个 SQL 映射文件中，经常面临着重复 SQL 的问题，尤其是查询类 SQL 。效果如下：
+
+```xml
+<select id="selectByName" resultType="User">
+    select 
+        id, name, age, email
+    from
+        user
+    where name like concat('%', #{name}, '%')
+</select>
+```
+
+```xml
+<select id="selectById" resultType="User">
+    select 
+        id, name, age, email
+    from
+        user
+    where id = #{id}
+</select>
+```
+
+使用 sql 元素可以让我们得以复用一些 SQL语句。
+
+```xml
+<!-- 定义可重用 SQL 段 -->
+<sql id="selectUser">
+    select 
+        id, name, age, email
+    from
+        user
+</sql>
+
+<select id="selectByName" resultType="User">
+    <!-- 引用 SQL -->
+    <include refid="selectUser"/>
+    where name like concat('%', #{name}, '%')
+</select>
+
+<select id="selectById" resultType="User">
+    <include refid="selectUser"/>
+    where id = #{id}
+</select>
+```
+
+## 参考文献
+
+[1]MyBatis 官网. XML 映射文件[EB/OL]. https://mybatis.org/mybatis-3/zh/sqlmap-xml.html. 2020-12-26
+
+## 后记
+
+本篇中，select 元素是重点，笔者列了好多个示例，你一定要将示例代码完整"临摹" + "思考"一遍，这样才能达到笔者所说的技术学习的第二步、第三步。
+
+::: info 笔者说
+对于技术的学习，笔者一贯遵循的步骤是：先用最最简单的 demo 让它跑起来，然后学学它的最最常用 API 和 配置让自己能用起来，最后熟练使用的基础上，在空闲时尝试阅读它的源码让自己能够洞彻它的运行机制，部分问题出现的原因，同时借鉴这些技术实现来提升自己的代码高度。
+
+所以在笔者的文章中，前期基本都是小白文，仅仅穿插很少量的源码研究。当然等小白文更新多了，你们还依然喜欢，后期会不定时专门对部分技术的源码进行解析。
+:::
+

repos/courses/mybatis/01-MyBatis基础/05-SQL映射文件之增删改元素.md

@@ -0,0 +1,342 @@
+---
+title: SQL映射文件之增删改元素
+author: 查尔斯
+date: 2020/12/27 23:55
+categories:
+ - MyBatis快速入门
+tags:
+ - MyBatis
+ - ORM框架
+---
+
+# SQL映射文件之增删改元素
+
+## 前言
+
+**C：** 在上一篇，笔者带大家对 MyBatis SQL 映射文件的 select 元素、sql 元素进行了学习。本篇，笔者将带你学习 MyBatis SQL 映射文件中的 insert、update、delete元素，这三个可以说是 SQL 映射文件中最为简单的，别愣神，快跟上我。
+
+![202012271125273](../../../public/img/2020/12/27/202012271125273.jpg)
+
+## insert元素
+
+**案例需求：新增用户，PeiQi，18，PeiQi@126.com** 
+
+首先，在 Mapper 接口中我们添加一个方法。
+
+```java
+public interface UserMapper {
+
+    /**
+     * 添加用户
+     * @param user 用户信息
+     * @return 影响行数
+     */
+    int insert(User user);
+
+}
+```
+
+::: tip 笔者说
+insert、update、delete 这类操作，本身默认就是返回影响的行数，所以不需要对 resultType 进行指定。在定义这类接口方法的时候设置返回值类型为 int 即可。
+:::
+
+然后我们在 SQL 映射文件中再添加一个与该方法对应的查询元素。
+
+```xml
+<!-- int insert(User user); -->
+<insert id="insert" parameterType="User">
+    insert into user (name, age, email) values(#{name}, #{age}, #{email})
+</insert>
+```
+
+测试一下：
+
+```java
+class TestMyBatis {
+
+    @Test
+    void testInsert() {
+        // 获取SqlSession对象
+        try (SqlSession sqlSession = MyBatisUtils.openSession()) {
+
+            // 获取 Mapper 接口
+            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
+            // 执行 SQL
+            User user = new User();
+            user.setName("PeiQi");
+            user.setAge(18);
+            user.setEmail("PeiQi@126.com");
+            int rows = userMapper.insert(user);
+			
+            System.out.println("影响行数为：" + rows);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+```
+
+**控制台输出：** 
+
+```sql
+-- 输出的 SQL 语句
+insert into user (name, age, email) values(?, ?, ?)
+```
+
+```
+影响行数为：1
+```
+
+---
+
+输出的结果一如既往的表示成功了，但是当你前往数据库查看时，却并没有新增数据。
+
+![202012271125276](../../../public/img/2020/12/27/202012271125276.png)
+
+仔细看看执行日志吧！相比于查询元素，插入元素执行多了一行日志，大白话理解就是：**JDBC 连接正在回滚事务** 。
+
+![202012271126381](../../../public/img/2020/12/27/202012271126381.png)
+
+这是因为我们在获取 SqlSession 的时候，采用的是开启事务的方式。开启事务对于查询没什么大影响，但是对于增删改，如果你不提交事务，就意味着不会将数据持久化到数据库。
+
+所以改动一下测试代码吧：
+
+```java
+class TestMyBatis {
+    @Test
+    void testInsert() {
+        // 获取SqlSession对象
+        try (SqlSession sqlSession = MyBatisUtils.openSession()) {
+
+            // 获取 Mapper 接口
+            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
+            // 执行 SQL
+            User user = new User();
+            user.setName("PeiQi");
+            user.setAge(18);
+            user.setEmail("PeiQi@126.com");
+            int rows = userMapper.insert(user);
+			
+            System.out.println("影响行数为：" + rows);
+			
+            // 提交事务
+            sqlSession.commit();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
+```
+
+这回测试之后就正常了。
+
+![202012271127794](../../../public/img/2020/12/27/202012271127794.png)
+
+### 获取自增主键值
+
+我们在一些支持自动生成主键的数据库中设置了主键自增，当数据插入之后，我们可能需要用到刚生成的主键值，这时候传统的方法是自己去手动查询一次，而 MyBatis 则是通过在插入元素上添加几个属性就可以解决了。
+
+```xml
+<!-- int insert(User user); -->
+<!-- 
+    【useGeneratedKeys:】（仅适用于 insert 和 update）表示要获取自动生成的主键
+    这会令 MyBatis 使用 JDBC 的 getGeneratedKeys 方法来取出由数据库内部生成的主键
+    （比如：像 MySQL 和 SQL Server 这样的关系型数据库管理系统的自动递增字段），默认值：false。 
+    【keyProperty】:（仅适用于 insert 和 update）表示获取到自动生成主键之后应该映射到对象的哪个属性中
+    MyBatis 会使用 getGeneratedKeys 的返回值或 insert 语句的 selectKey 子元素设置它的值，默认值：未设置（unset）。
+    如果生成列不止一个，可以用逗号分隔多个属性名称。 [1]
+  -->
+<insert id="insert" parameterType="User" useGeneratedKeys="true" keyProperty="id">
+    insert into user (name, age, email) values(#{name}, #{age}, #{email})
+</insert>
+```
+
+测试一下：
+
+```java
+class TestMyBatis {
+
+    @Test
+    void testInsert() {
+        // 获取SqlSession对象
+        try (SqlSession sqlSession = MyBatisUtils.openSession()) {
+
+            // 获取 Mapper 接口
+            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
+            // 执行 SQL
+            User user = new User();
+            user.setName("PeiQi");
+            user.setAge(18);
+            user.setEmail("PeiQi@126.com");
+            System.out.println("插入前：" + user);
+            int rows = userMapper.insert(user);
+            System.out.println("影响行数为：" + rows);
+            System.out.println("插入后：" + user);
+			
+            // 提交事务
+            sqlSession.commit();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    
+}
+```
+
+**控制台输出：** 
+
+```
+插入前：User [id=null, name=PeiQi, age=18, email=PeiQi@126.com]
+影响行数为：1
+插入后：User [id=8, name=PeiQi, age=18, email=PeiQi@126.com]
+```
+
+## update元素
+
+再来试试 update 元素。**案例需求：将id为1的用户年龄改为20。** 
+
+首先，在 Mapper 接口中我们添加一个方法。
+
+```java
+public interface UserMapper {
+
+    /**
+     * 修改用户
+     * @param user 用户信息
+     * @return 影响行数
+     */
+    int update(User user);
+
+}
+```
+
+然后我们在 SQL 映射文件中再添加一个与该方法对应的查询元素。
+
+```xml
+<!-- int update(User user); -->
+<update id="update" parameterType="User">
+    update user set age = #{age} where id = #{id}
+</update>
+```
+
+测试一下：
+
+```java
+class TestMyBatis {
+
+    @Test
+    void testUpdate() {
+        // 获取SqlSession对象
+        try (SqlSession sqlSession = MyBatisUtils.openSession()) {
+
+            // 获取 Mapper 接口
+            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
+            // 执行 SQL
+            User user = new User();
+            user.setId(1L);
+            user.setAge(20);
+            int rows = userMapper.update(user);
+			
+            System.out.println("影响行数为：" + rows);
+			
+            // 提交事务
+            sqlSession.commit();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}
+```
+
+**控制台输出：** 
+
+```sql
+-- 输出的 SQL 语句
+update user set age = ? where id = ?
+```
+
+```
+影响行数为：1
+```
+
+## delete元素
+
+再来试试 delete 元素。**案例需求：将id为1的用户删除。** 
+
+首先，在 Mapper 接口中我们添加一个方法。
+
+```java
+public interface UserMapper {
+
+    /**
+     * 根据ID删除用户
+     * @param id 用户ID
+     * @return 影响行数
+     */
+    int deleteById(@Param("id") Long id);
+
+}
+```
+
+然后我们在 SQL 映射文件中再添加一个与该方法对应的查询元素。
+
+```xml
+<!-- int deleteById(@Param("id") Long id); -->
+<delete id="deleteById">
+    delete from user where id = #{id}
+</delete>
+```
+
+测试一下：
+
+```java
+class TestMyBatis {
+
+    @Test
+    void testDeleteById() {
+        // 获取SqlSession对象
+        try (SqlSession sqlSession = MyBatisUtils.openSession()) {
+
+            // 获取 Mapper 接口
+            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
+            // 执行 SQL
+            int rows = userMapper.deleteById(1L);
+			
+            System.out.println("影响行数为：" + rows);
+			
+            // 提交事务
+            sqlSession.commit();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}
+```
+
+**控制台输出：** 
+
+```sql
+-- 输出的 SQL 语句
+delete from user where id = ?
+```
+
+```
+影响行数为：1
+```
+
+## 参考文献
+
+[1]MyBatis 官网. XML 映射文件[EB/OL]. https://mybatis.org/mybatis-3/zh/sqlmap-xml.html. 2020-12-26
+
+## 后记
+
+你就看看，它们使用起来简单不？这还能有理由说学不动、学不会吗？
+
+::: info 笔者说
+对于技术的学习，笔者一贯遵循的步骤是：先用最最简单的 demo 让它跑起来，然后学学它的最最常用 API 和 配置让自己能用起来，最后熟练使用的基础上，在空闲时尝试阅读它的源码让自己能够洞彻它的运行机制，部分问题出现的原因，同时借鉴这些技术实现来提升自己的代码高度。
+
+所以在笔者的文章中，前期基本都是小白文，仅仅穿插很少量的源码研究。当然等小白文更新多了，你们还依然喜欢，后期会不定时专门对部分技术的源码进行解析。
+:::
+

repos/courses/mybatis/01-MyBatis基础/06-SQL映射文件之自定义映射元素.md

@@ -0,0 +1,397 @@
+---
+title: SQL映射文件之自定义映射元素
+author: 查尔斯
+date: 2020/12/28 00:07
+categories:
+ - MyBatis快速入门
+tags:
+ - MyBatis
+ - ORM框架
+---
+
+# SQL映射文件之自定义映射元素
+
+## 前言
+
+**C：** 在上一篇，笔者带大家对 MyBatis SQL 映射文件的 insert、update、delete元素做了介绍。到此，CRUD 的基本操作我们就介绍完了。本篇，笔者将带你学习 MyBatis SQL 映射文件的 resultMap 元素，它是 MyBatis 中号称"最强"的元素。有多强？容易令人头秃。
+
+![202012281130648](../../../public/img/2020/12/28/202012281130648.jpg)
+
+## resultMap元素
+
+要介绍 resultMap 元素，那必然要先详细提一下 resultType 属性。
+
+### resultType属性
+
+在 select 元素中，我们一直在使用 resultType 属性，我们可以用它来指定 SQL 查询完后的 ResultSet（结果集）到底映射为哪种类型。
+
+下方的示例中，resultType 代表的就是将查询回来的所有结果数据映射为User类型的对象。
+
+```xml
+<select id="selectById" resultType="User">
+    select 
+        id, name, age, email
+    from
+        user
+    where 
+        id = #{id}
+</select>
+```
+
+MyBatis 会按照 SQL 查询出的结果数据的列名或别名来映射。
+
+![202012281131280](../../../public/img/2020/12/28/202012281131280.png)
+
+如果列名和属性名不能匹配上，可以在 SELECT 语句中设置列别名来完成匹配，效果如下。
+
+```xml
+<select id="selectById" resultType="User">
+    select 
+        id, name as username, age, email
+    where 
+        id = #{id}
+</select>
+```
+
+![202012281131380](../../../public/img/2020/12/28/202012281131380.png)
+
+### 简单自定义映射
+
+在学习了上面的知识后，你会发现上面的例子没有一个需要显式配置 `ResultMap`，这就是 `ResultMap` 的优秀之处：你完全可以不用显式地配置它们。
+
+::: tip 笔者说
+实际上 `resultType` 属性的实现原理就是 `ResultMap`， MyBatis 在幕后会自动创建一个 `ResultMap`，再根据属性名来映射列到 JavaBean 的属性上。所以记得注意 **二者不能同时存在** 。
+:::
+
+虽然上面的例子不用显式配置 `ResultMap`，但为了讲解，我们来看看如果在刚刚的示例中，显式使用外部的 `resultMap` 会怎样，这也是解决列名不匹配的另外一种方式。[1]
+
+```xml
+<!-- 
+    自定义映射
+        id属性：resultMap的唯一标识
+        type属性：要映射为的Java类型全限定类名或别名
+-->
+<resultMap id="userMap" type="User">
+    <!-- 
+        用来映射主键列，可以帮助提高整体性能（建议配置）
+            property：Java类型的属性名
+            column：结果集的列名或别名
+    -->
+    <id column="id" property="id"/>
+    <!-- 用来映射普通列 -->
+    <result column="name" property="username"/>
+</resultMap>
+
+<select id="selectById" resultMap="userMap">
+    select 
+        id, name, age, email
+    from
+        user
+    where id = #{id}
+</select>
+```
+
+::: tip 笔者说
+在简单自定义映射时，我们仅仅需要对结果集列名和类属性名不一致的情况作映射规则指定，其他一致的，MyBatis 依然可以帮助我们自动映射好。
+但是当出现复杂的自定义映射时，MyBatis 将会进入映射"罢工"状态，未指明自定义映射规则的部分将不再进行自动映射，看看下方的例子吧。
+:::
+
+### 复杂自定义映射[难点]
+
+除了上述简单的自定义映射元素外，在 resultMap 元素中，还有两个用于进行复杂映射的子元素（多表操作）：
+
+- **association** 映射到 JavaBean 的某个“复杂类型”属性，例如：JavaBean类
+
+- **collection** 映射到 JavaBean 的某个“复杂类型”属性，例如：集合
+
+我们通过两个案例分别体会一下这两个子元素。
+
+#### association案例 
+
+**案例需求：根据ID查询用户信息，同时将该用户的角色信息也查询出来。** 
+
+刚才我们做了那么多练习，数据库搞的太乱了，**我们先重置回 MyBatis 第一篇的数据库** ，并做一些数据库上的调整。
+
+```sql
+-- 创建并初始化数据表 role
+CREATE TABLE `role`  (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
+  `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '角色名',
+  PRIMARY KEY (`id`) USING BTREE
+) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '角色表' ROW_FORMAT = Compact;
+
+INSERT INTO `role` VALUES (1, '超级管理员');
+INSERT INTO `role` VALUES (2, '普通管理员');
+
+-- 为 user 表添加 roleId 列
+ALTER TABLE `user` ADD COLUMN `roleId` bigint(0) NULL COMMENT '角色id';
+-- 为 user 表做一些角色修改
+UPDATE user SET roleId = 1 WHERE id BETWEEN 1 AND 3;
+UPDATE user SET roleId = 2 WHERE id > 3;
+```
+
+根据数据库改动，创建及改动 POJO：
+
+```java
+/**
+ * 角色 POJO
+ * @author Charles7c
+ */
+public class Role {
+    private Long id;
+    private String name;
+    // 省略 getter/setter 、toString
+}
+```
+
+```java
+/**
+ * 用户 POJO
+ * @author Charles7c
+ */
+public class User {
+    private Long id;
+    private String name;
+    private Integer age;
+    private String email;
+    private Long roleId;
+    // 角色对象属性
+    private Role role;
+    // 省略 getter/setter 、toString
+}
+```
+
+改造好数据库之后，我们直接来改造一下 SQL 映射文件中的对应查询。
+
+```xml
+<resultMap id="userMap" type="User">
+    <id column="id" property="id"/>
+    <!-- 复杂的类型关联：一对一映射，映射对象属性
+            property：对象属性在映射类中的名字
+            javaType：对象属性的类型全限定类名或别名
+    -->
+    <association property="role" javaType="Role">
+        <!-- 和外层的映射一样的，"俄罗斯套娃" -->
+        <id column="rid" property="id"/>
+        <result column="rname" property="name"/>
+    </association>
+</resultMap>
+
+<select id="selectById" resultMap="userMap">
+    select 
+        u.*,
+        r.id as rid,
+        r.name as rname
+    from
+        user u
+        left join role r on u.roleId = r.id
+    where u.id = #{id}
+</select>
+```
+
+![202012281132193](../../../public/img/2020/12/28/202012281132193.png)
+
+测试一下：
+
+```java
+class TestMyBatis {
+
+    @Test
+    void testSelectById() {
+        // 获取SqlSession对象
+        try (SqlSession sqlSession = MyBatisUtils.openSession()) {
+
+            // 获取 Mapper 接口
+            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
+            // 执行 SQL
+            User user = userMapper.selectById(2L);
+			
+            System.out.println(user);
+            System.out.println(user.getRole());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}
+```
+
+**控制台输出：** 
+
+```sql
+-- 输出的 SQL 语句
+select u.*, r.id as rid, r.name as rname from user u left join role r on u.roleId = r.id where u.id = ?
+```
+
+```
+User [id=2, name=null, age=null, email=null]
+Role [id=1, name=超级管理员]
+```
+
+---
+
+看看这结果，MyBatis 映射是不是"罢工"了？解决方法有两种：
+
+1. 挨个的把所有结果集列与对应类属性映射好
+
+2. 在 MyBatis 核心配置文件中，更改自动映射的默认级别
+
+   ```xml
+   <settings>
+       <!-- 自动映射行为设置 -->
+       <setting name="autoMappingBehavior" value="FULL"/>
+   </settings>
+   ```
+
+   再来试试，看看控制台输出的结果。
+
+   ```
+   User [id=2, name=Jack, age=20, email=Jack@126.com]
+   Role [id=1, name=超级管理员]
+   ```
+
+#### collection案例
+
+**案例需求：根据ID查询用户信息，同时将该用户的联系人列表也查询出来。** 
+
+我们再来做一些数据库上的调整。
+
+```sql
+-- 创建并初始化数据表 linkuser
+CREATE TABLE `linkuser`  (
+  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键',
+  `name` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '联系人名',
+  `phone` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '联系电话',
+  `address` varchar(255) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL COMMENT '联系地址',
+  `userId` bigint(20) NULL DEFAULT NULL COMMENT '用户id',
+  PRIMARY KEY (`id`) USING BTREE
+) ENGINE = InnoDB AUTO_INCREMENT = 3 CHARACTER SET = utf8 COLLATE = utf8_general_ci COMMENT = '联系人表' ROW_FORMAT = Compact;
+
+INSERT INTO `linkuser` VALUES (1, '张三', '18822233311', '北京西城区', 2);
+INSERT INTO `linkuser` VALUES (2, '李四', '18822233322', '北京东城区', 2);
+```
+
+根据数据库改动，创建及改动 POJO：
+
+```java
+/**
+ * 联系人 POJO
+ * 
+ * @author Charles7c
+ */
+public class LinkUser {
+    private Long id;
+    private String name;
+    private String phone;
+    private String address;
+    private Long userId;
+    // 省略 getter/setter 、toString
+}
+```
+
+```java
+/**
+ * 用户 POJO
+ * 
+ * @author Charles7c
+ */
+public class User {
+    private Long id;
+    private String name;
+    private Integer age;
+    private String email;
+    private Long roleId;
+    // 角色对象属性
+    private Role role;
+    // 联系人列表
+    private List<LinkUser> linkUserList;
+    // 省略 getter/setter 、toString
+}
+```
+
+改造好数据库之后，我们直接来改造一下 SQL 映射文件中的对应查询。
+
+```xml
+<resultMap id="userMap" type="User">
+    <id column="id" property="id"/>
+    <!-- 复杂类型集合，一对多，映射集合属性
+            property：集合属性在映射类中的名字
+            ofType：集合属性的泛型全限定类名或别名
+    -->
+    <collection property="linkUserList" ofType="LinkUser">
+        <id column="lkuid" property="id"/>
+        <result column="lkuname" property="name"/>
+        <result column="lkuphone" property="phone"/>
+        <result column="lkuaddress" property="address"/>
+    </collection>
+</resultMap>
+
+<select id="selectById" resultMap="userMap">
+    select 
+        u.*,
+        lku.id as lkuid,
+        lku.name as lkuname,
+        lku.phone as lkuphone,
+        lku.address as lkuaddress
+    from
+        user u
+        left join linkuser lku on u.id = lku.userId
+    where 
+        u.id = #{id}
+</select>
+```
+
+![202012281133167](../../../public/img/2020/12/28/202012281133167.png)
+
+测试一下：
+
+```java
+class TestMyBatis {
+
+    @Test
+    void testSelectById() {
+        // 获取SqlSession对象
+        try (SqlSession sqlSession = MyBatisUtils.openSession()) {
+
+            // 获取 Mapper 接口
+            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
+            // 执行 SQL
+            User user = userMapper.selectById(2L);
+			
+            System.out.println(user);
+			
+            user.getLinkUserList().forEach(System.out::println);
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}
+```
+
+**控制台输出：** 
+
+```sql
+-- 输出的 SQL 语句
+select u.*, lku.id as lkuid, lku.name as lkuname, lku.phone as lkuphone, lku.address as lkuaddress from user u left join linkuser lku on u.id = lku.userId where u.id = ?
+```
+
+```
+User [id=2, name=Jack, age=20, email=Jack@126.com]
+LinkUser [id=1, name=张三, phone=18822233311, address=北京西城区, userId=null]
+LinkUser [id=2, name=李四, phone=18822233322, address=北京东城区, userId=null]
+```
+
+## 参考文献
+
+[1]MyBatis 官网. XML 映射文件[EB/OL]. https://mybatis.org/mybatis-3/zh/sqlmap-xml.html. 2020-12-26
+
+## 后记
+
+大多数人在学到复杂自定义映射时都容易犯迷糊，所以笔者说过如果要学习 Hibernate 框架，开局容易深入难，因为 Hibernate 这框架中经常要处理类似的映射，年轻人慢慢来，加油！
+
+::: info 笔者说
+对于技术的学习，笔者一贯遵循的步骤是：先用最最简单的 demo 让它跑起来，然后学学它的最最常用 API 和 配置让自己能用起来，最后熟练使用的基础上，在空闲时尝试阅读它的源码让自己能够洞彻它的运行机制，部分问题出现的原因，同时借鉴这些技术实现来提升自己的代码高度。
+
+所以在笔者的文章中，前期基本都是小白文，仅仅穿插很少量的源码研究。当然等小白文更新多了，你们还依然喜欢，后期会不定时专门对部分技术的源码进行解析。
+:::

repos/courses/mybatis/01-MyBatis基础/07-SQL映射文件之缓存元素.md

@@ -0,0 +1,218 @@
+---
+title: SQL映射文件之缓存元素
+author: 查尔斯
+date: 2020/12/28 00:17
+categories:
+ - MyBatis快速入门
+tags:
+ - MyBatis
+ - ORM框架
+---
+
+# SQL映射文件之缓存元素
+
+## 前言
+
+**C：**  在上一篇，笔者带大家对 MyBatis SQL 映射文件的 resultMap 元素做了介绍，它大概是 MyBatis 学习中第一个 "坎儿"，没跨过来的同学也没关系，慢慢来，切勿急躁，先看看本篇再说。本篇，笔者将带你学习 MyBatis SQL 映射文件的 cache 元素。
+
+cache 即缓存，任何应用都不可缺少的一个组成部分，但凡想提升性能，缓存就得拿出来说道说道。MyBatis 中自然也少不了缓存的存在，下面我们去看看吧。
+
+## cache元素
+
+cache 元素，是用于开启 MyBatis 二级缓存的关键。在 MyBatis 中缓存分为一级缓存和二级缓存 。
+
+### 一级缓存
+
+**一级缓存主要指的是 Session 缓存，默认是开启并生效的** 。
+
+一级缓存存在两种作用域范围：[2]
+
+- `SESSION`（默认）**在同一个 SqlSession 中多次执行同一个查询，除第一次走数据库，剩下的都走缓存** 。
+- `STATEMENT` 每执行完一个 Mapper 中的语句后都会将一级缓存清除（不推荐配置）。
+
+测试一下一级缓存的 `SESSION` 作用域范围：(随便找两个查询试试就可以)
+
+```java
+class TestMyBatis {
+
+    @Test
+    void testSelectByList() {
+        // 获取SqlSession对象
+        try (SqlSession sqlSession = MyBatisUtils.openSession()) {
+
+            // 获取 Mapper 接口
+            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
+			
+            // 执行不同 SQL
+            List<User> userList1 = userMapper.selectList();
+            List<User> userList2 = userMapper.selectByName("J");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}
+```
+
+很显然它执行了两条 SQL，和缓存根本搭不上关系。
+
+![202012281138752](../../../public/img/2020/12/28/202012281138752.png)
+
+再来试试执行两次相同的 SQL 查询。
+
+```java
+class TestMyBatis {
+
+    @Test
+    void testSelectByList() {
+        // 获取SqlSession对象
+        try (SqlSession sqlSession = MyBatisUtils.openSession()) {
+
+            // 获取 Mapper 接口
+            UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
+            // 执行相同 SQL
+            List<User> userList1 = userMapper.selectList();
+            List<User> userList2 = userMapper.selectList();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}
+```
+
+结果显而易见，MyBatis 在同一个 SqlSession 中，对相同的 SQL 查询，只执行了一次，第二次则直接使用了缓存。
+
+![202012281139250](../../../public/img/2020/12/28/202012281139250.png)
+
+### 二级缓存
+
+**二级缓存是指 mapper 映射文件。** 二级缓存的作用域是同一个 namespace 下的 mapper 映射文件内容，**多个 SqlSession 之间是共享的** 。
+
+::: warning 笔者说
+可以通过核心配置文件中的 settings 元素的 cacheEnabled 对所有二级缓存进行全局性开/关设置（默认值为true）。
+:::
+
+```xml
+<settings>
+    <setting name="cacheEnabled" value="true"/>
+</settings>
+```
+
+在测试二级缓存前，我们需要先对指定的 SQL 映射文件启用二级缓存，即添加一个 cache 元素。
+
+```xml
+<!-- 对于同一个 SQL 映射文件来讲，只能使用一个 cache 元素 -->
+<cache/>
+```
+
+上面我们仅仅添加了一个空 cache 元素 ，但其实它已经采用了很多缓存默认值，大致如下：[1]
+
+- 映射语句文件中的所有 select 语句的结果将会被缓存。
+- 映射语句文件中的所有 insert、update 和 delete 语句会刷新缓存（哪怕最后没提交事务也会刷新缓存）。
+- 缓存会使用最近最少使用算法（LRU, Least Recently Used）算法来清除不需要的缓存。
+- 缓存不会定时进行刷新（也就是说，没有刷新间隔）。
+- 缓存会保存列表或对象（无论查询方法返回哪种）的 1024 个引用。
+- 缓存会被视为读/写缓存，这意味着获取到的对象并不是共享的，可以安全地被调用者修改，而不干扰其他调用者或线程所做的潜在修改。
+
+你也可以通过修改 cache 元素的属性来调整二级缓存。
+
+```xml
+<!-- 这个更高级的配置创建了一个 FIFO 缓存，每隔 60 秒刷新，最多可以存储结果对象或列表的 512  个引用，而且返回的对象被认为是只读的，因此对它们进行修改可能会在不同线程中的调用者产生冲突。  -->
+<cache
+    eviction="FIFO"
+    flushInterval="60000"
+    size="512"
+    readOnly="true"/>
+```
+
+**eviction** 代表缓存清除策略：（默认的清除策略是 LRU）
+
+- `LRU`  最近最少使用：移除最长时间不被使用的对象  
+- `FIFO`  先进先出：按对象进入缓存的顺序来移除它们 
+- `SOFT`  软引用：基于垃圾回收器状态和软引用规则移除对象     
+- `WEAK` – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。          
+
+**flushInterval** 代表缓存刷新间隔：（默认情况是不设置，也就是没有刷新间隔，缓存仅仅会在调用语句时刷新）它的属性值可以被设置为任意的正整数，设置的值应该是一个以毫秒为单位的合理时间量。        
+
+**size** 代表可以缓存的对象引用数目：（默认值是 1024）它的属性值可以被设置为任意正整数，但要注意欲缓存对象的大小和运行环境中可用的内存资源。        
+
+**readOnly** 代表缓存中的对象是否只读：（默认值是 false），它的属性值可以被设置为 true 或 false。只读的缓存会给所有调用者返回缓存对象的相同实例，因此这些对象不能被修改，这就提供了可观的性能提升。而可读写的缓存会（通过序列化）返回缓存对象的拷贝，速度上会慢一些，但是更安全（ **建议** ）。
+
+---
+
+赶快测试一下吧：
+
+```java
+class TestMyBatis {
+
+    @Test
+    void testSelectByList() {
+        try {
+            // 获取SqlSession对象
+            SqlSession sqlSession1 = MyBatisUtils.openSession();
+            // 执行
+            UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
+            List<User> userList1 = userMapper1.selectList();
+            // 【执行关闭操作，将 SqlSession 中的数据写到二级缓存区域】
+            sqlSession1.close();
+			
+            // 获取SqlSession对象
+            SqlSession sqlSession2 = MyBatisUtils.openSession();
+            // 执行
+            UserMapper userMapper2 = sqlSession2.getMapper(UserMapper.class);
+            List<User> userList2 = userMapper2.selectList();
+            sqlSession2.close();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}
+```
+
+控制台报错了，User 没有序列化，上方 readOnly 属性刚介绍完，它默认值为 false，表示每次会通过序列化返回缓存对象的拷贝，以此实现可读写的缓存。
+
+![202012281139256](../../../public/img/2020/12/28/202012281139256.png)
+
+```java
+public class User implements Serializable{
+    // 略
+}
+```
+
+再测试之后，控制台输出如下，Cache Hit Ratio 表示缓存命中率，开启二级缓存后，每执行一次查询，系统都会计算一次二级缓存的命中率。第一次查询也是先从缓存中查询，只不过缓存中一定是没有的，所以命中率为0，然后再从DB中查询后缓存到二级缓存中。第二次查询的时候是从二级缓存中读取的，这一次的命中率为1/2=0.5。 当然，若有第三次查询，则命中率为1/3=0.66 ，依此类推。[3]
+
+![202012281139540](../../../public/img/2020/12/28/202012281139540.png)
+
+## cache-ref元素
+
+当我们想要在多个命名空间中共享相同的缓存配置和实例时，cache-ref 元素就可以派上用场了，当同时使用了 cache 元素和 cache-ref 元素时，cache 元素的优先级更高。
+
+```xml
+<!-- namespace：要共享二级缓存的某 SQL 映射文件的 namespace 的值 -->
+<cache-ref namespace="com.example.mapper.UserMapper"/>
+```
+
+::: tip 笔者说
+二级缓存也不是万能的，需要根据实际情况来，当查询操作远远多于增删改操作的情况下，并且业务对数据的实时性要求不高的时候可以采用二级缓存，否则增删改频繁刷新二级缓存将会降低系统性能，而缓存又会导致实时效果差。
+而且 MyBatis 的二级缓存也存在着一些缺陷，使用 MyBatis 二级缓存必须有一个前提：保证所有的增删改查都在同一个 namespace 下才行，不然容易出现数据不一致问题，例如：当两个 SQL 映射文件中均存在对同一个表的操作，那么其中一方修改了表，只会引发该 SQL 映射文件的二级缓存清空，而不会清空另一个的。
+:::
+
+## 参考文献
+
+[1]MyBatis 官网. XML 映射文件[EB/OL]. https://mybatis.org/mybatis-3/zh/sqlmap-xml.html. 2020-12-26
+
+[2]花好夜猿. Mybatis【面试题】讲讲Mybatis的缓存-简答[EB/OL]. https://blog.csdn.net/qq_23202687/article/details/103708458. 2019-12-26
+
+[3]陈浩翔. 你真的懂Mybatis缓存机制吗[EB/OL]. https://mp.weixin.qq.com/s/h2x15k71rClaHjcz7u2dlQ. 2018-07-10
+
+## 后记
+
+SQL 映射文件的初步学习终于结束了，幸好有之前的文章雏形，但就这样还花费了半天时间整理和完善，但愿它能给小白用户带来一份系统的学习方案。
+
+::: info 笔者说
+对于技术的学习，笔者一贯遵循的步骤是：先用最最简单的 demo 让它跑起来，然后学学它的最最常用 API 和 配置让自己能用起来，最后熟练使用的基础上，在空闲时尝试阅读它的源码让自己能够洞彻它的运行机制，部分问题出现的原因，同时借鉴这些技术实现来提升自己的代码高度。
+
+所以在笔者的文章中，前期基本都是小白文，仅仅穿插很少量的源码研究。当然等小白文更新多了，你们还依然喜欢，后期会不定时专门对部分技术的源码进行解析。
+:::