# Mybatis简介在前面JDBC的学习中，虽然我们能够通过JDBC来连接和操作数据库，但是这实在是太麻烦了，哪怕只是完成一个SQL语句的执行，都需要编写大量的代码，更不用说如果我还需要进行实体类映射，将数据转换为我们可以直接操作的实体类型，JDBC虽然进行了接口的定义，但是还不够方便，我们需要一种更加简洁高效的方式来和数据库进行交互。接下来隆重介绍我们本章节的主角： ![image-20230306163528771](https://s2.loli.net/2024/08/12/J7rWH6iIqUMEgjP.png) MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Ordinary Java Object,普通的 Java对象)映射成数据库中的记录。这一块内容很多很杂，各位小伙伴一定要多实践，多尝试，否则会忘得很快。 ## 走进Mybatis 在正式使用Mybatis之前，我们先来学习一些前置内容和准备工作。 ### XML语言概述在开始介绍Mybatis之前，我们先来给大家介绍一下XML语言，XML语言发明最初是用于数据的存储和传输，它是由一个一个的标签嵌套而成，一般长这样： ```xml 阿伟怎么又在玩电动啊 10 男 ``` 如果你学习过前端知识，你会发现它和HTML几乎长得一模一样！但是请注意，虽然它们长得差不多，但是他们的意义却不同，HTML主要用于通过编排来展示数据，而XML主要是存放数据，它更像是一个配置文件！当然，浏览器也是可以直接打开XML文件的。一个XML文件存在以下的格式规范： - 必须存在一个根节点，将所有的子标签全部包含。 - 可以但不必须包含一个头部声明（主要是可以设定编码格式） - 所有的标签必须成对出现，有些可以单独，可以嵌套但不能交叉嵌套 - 区分大小写。 - 标签中可以存在属性，比如上面的`type="1"`就是`inner`标签的一个属性，属性的值由单引号或双引号包括。 XML文件也可以使用注释： ```xml ``` 那如果我们的内容中出现了`<`或是`>`字符，那该怎么办呢？我们就可以使用XML的转义字符来代替： ![img](https://s2.loli.net/2024/08/12/bYBle7VIq6DNang.jpg) 如果嫌一个一个改太麻烦，也可以使用CD来快速创建不解析区域： ```xml <><>是一点都不懂哦>>>]]> ``` 那么，我们现在了解了XML文件的定义，现在该如何去解析一个XML文件呢？比如我们希望将定义好的XML文件读取到Java程序中，这时该怎么做呢？ JDK为我们内置了一个叫做`org.w3c`的XML解析库，我们来看看如何使用它来进行XML文件内容解析： ```java // 创建DocumentBuilderFactory对象 DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); // 创建DocumentBuilder对象 try { DocumentBuilder builder = factory.newDocumentBuilder(); Document d = builder.parse("file:mappers/test.xml"); // 每一个标签都作为一个节点 NodeList nodeList = d.getElementsByTagName("test"); // 可能有很多个名字为test的标签 Node rootNode = nodeList.item(0); // 获取首个 NodeList childNodes = rootNode.getChildNodes(); // 一个节点下可能会有很多个节点，比如根节点下就囊括了所有的节点 //节点可以是一个带有内容的标签（它内部就还有子节点），也可以是一段文本内容 for (int i = 0; i < childNodes.getLength(); i++) { Node child = childNodes.item(i); if(child.getNodeType() == Node.ELEMENT_NODE) //过滤换行符之类的内容，因为它们都被认为是一个文本节点 System.out.println(child.getNodeName() + "：" +child.getFirstChild().getNodeValue()); // 输出节点名称，也就是标签名称，以及标签内部的文本（内部的内容都是子节点，所以要获取内部的节点） } } catch (Exception e) { e.printStackTrace(); } ``` 当然，学习和使用XML只是为了更好地去认识Mybatis的工作原理，以及如何使用XML来作为Mybatis的配置文件，这是在开始之前必须要掌握的内容（使用Java读取XML内容不要求掌握，但是需要知道Mybatis就是通过这种方式来读取配置文件的）不仅仅是Mybatis，包括后面的Spring等众多框架都会用到XML来作为框架的配置文件。 ### 初次使用MyBatis 那么我们首先来感受一下Mybatis给我们带来的便捷，就从搭建环境开始，中文文档网站：https://mybatis.org/mybatis-3/zh_CN/getting-started.html，还是老规矩，我们直接先下载好Mybatis的依赖Jar包：https://github.com/mybatis/mybatis-3/releases 如果使用Maven可以直接引入： ```xml org.mybatis mybatis 3.5.16 ``` 依赖变多之后，我们可以将其放到一个单独的文件夹，不然会很繁杂： ![QQ_1723452238551](https://s2.loli.net/2024/08/12/Y7ykK3idxSvUT1r.png) 依赖导入完成后，我们就可以编写Mybatis的配置文件了（现在不是在Java代码中配置了，而是通过一个XML文件去配置，这样就使得硬编码的部分大大减少，项目后期打包成Jar运行不方便修复，但是通过配置文件，我们随时都可以去修改，就变得很方便了，同时代码量也大幅度减少，配置文件填写完成后，我们只需要关心项目的业务逻辑而不是如何去读取配置文件）我们按照官方文档给定的提示，在项目根目录下新建名为`mybatis-config.xml`的文件，并填写以下内容： ```xml ``` 我们发现，在最上方还引入了一个叫做DTD（文档类型定义）的东西，它提前帮助我们规定了一些标签以及这些标签应该具有哪些属性，这些标签是Mybatis专属的配置标签，我们也必须要按照对应的方式来进行配置。接着我们就可以使用DTD中声明的各种标签进行配置的编写了，最外层需要使用`configuration`标签进行囊括，内部首先需要编写环境配置，我们的项目可能会分多个环境进行编写，比如我们在开发的时候可能连接的是自己本地的数据库，但是项目部署到服务器上之后，可能会连接其他的数据库，所以我们可以提供多个环境配置，只不过这里我们只是做开发，只需要配置一个`environment`即可： ```xml ``` 在`environment`中我们可以配置两个部分，一个是事务管理器，还有一个是数据源，事务管理器我们这里直接使用JDBC即可，有关其他事务管理器我们会在后续Spring课程中为大家介绍。数据源中配置就是驱动、连接地址、用户名和密码，按照之前JDBC的方式进行配置即可，最后还有一个数据源类型配置我们也会放在后续Spring阶段再给各位小伙伴进行介绍。配置文件完成后，接着我们就可以通过Java来使用Mybatis了，首先我们要介绍的是`SqlSessionFactoryBuilder`它用于构建`SqlSessionFactory`对象，每个基于 MyBatis 的应用都是以一个 SqlSessionFactory 的实例为核心的，使用也很简单，这里我们使用的是XML的形式进行配置的： ```java public static void main(String[] args) throws FileNotFoundException { //使用build方法来创建SqlSessionFactory，这里我们通过文件输入流传入配置文件 SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(new FileInputStream("mybatis-config.xml")); } ``` 虽然SqlSessionFactory也可以使用`Configuration`进行纯Java配置，但是相比XML文件来说，配置起来非常麻烦，要构建大量对象，这里我们就不仅讲解了，各位小伙伴也可以前往官方文档深入了解：https://mybatis.org/mybatis-3/zh_CN/getting-started.html ```java public SqlSessionFactory build(InputStream inputStream); //手动指定配置文件中多个环境的其中一个 public SqlSessionFactory build(InputStream inputStream, String environment); //手动配置一些属性，通过Properties对象来传递 public SqlSessionFactory build(InputStream inputStream, Properties properties); public SqlSessionFactory build(InputStream inputStream, String environment, Properties properties); ``` 既然有了 SqlSessionFactory，顾名思义，我们可以从中获得 SqlSession 的实例，每一个SqlSession都代表一个会话，也就相当于我们之前通过命令行访问MySQL的一个窗口，不同会话之间相互隔离，不受影响： ```java try (SqlSession session = sqlSessionFactory.openSession(true)) { //由于SqlSession需要在使用结束后关闭，这里我们也可以使用try-with-resource来编写 //这里的参数是设置自动提交，和之前JDBC一样 } ``` ![QQ_1723455145061](https://s2.loli.net/2024/08/12/eq3LwI1paXucYNl.png) SqlSession接口中为我们预设了非常多的增删改查操作： ```java public interface SqlSession extends Closeable { T selectOne(String statement); T selectOne(String statement, Object parameter); List selectList(String statement); ... int insert(String statement); int insert(String statement, Object parameter); int update(String statement); int update(String statement, Object parameter); int delete(String statement); int delete(String statement, Object parameter); ``` 可以看到，针对于增删改查这类操作，Mybatis已经把每一种操作都预设好了，并且查询的返回结果直接就是我们需要的实体类型，相比JDBC来说方便太多了，那么我们该如何去使用这些方法呢？由于Mybatis并不知道我们具体需要执行的SQL语句，以及需要返回哪些数据作为结果，因此我们同样需要编写配置文件来告诉Mybatis我们要做什么。我们可以在项目目录下创建一个新的`mappers`目录，然后创建一个新的文件`TestMapper.xml`作为我们的SQL语句映射配置，并添加以下内容： ```xml ``` 这里我们添加了映射器（Mapper）的DTD来方便我们后续的配置，其中mapper标签用于囊括后续编写的所有SQL映射，`namespace`属性用于区分不同的映射器（一个项目可以有多个Mapper配置文件，用于分类存放不同业务的SQL映射）以及后续我们会介绍的接口绑定等。接着我们就可以开始尝试编写一个测试用的SQL语句映射了，假设我们需要查询user表中所有数据，首先构建一个实体类： ```java @Data public class User { //属性名称必须和数据库中字段名称一一对应，不然会赋值失败 int id; String name; int age; } ``` 接着我们在配置文件中添加一个新的映射，由于这里我们需要使用到`select`语句，所以使用名字为select的标签： ```xml ``` 由于一个Mapper文件中可以存在多个SQL语句映射，这里的`id`是用于区分其他SQL语句映射的，后面的`resultType`代表SQL语句查询结果需要转换的实体类型，其他未使用的参数我们会在后续课程中逐步介绍。标签的中间就是我们具体要进行查询的SQL语句了，这和我们之前使用JDBC是差不多的。现在我们已经完成了Mapper配置文件的编写，接着我们需要将其添加到一开始的Mybatis配置文件中，使得Mybatis可以在一开始的时候正常加载。 ```xml ... ``` 最后在程序中使用我们定义好的SQL语句映射也很简单，假设现在我们需要执行刚刚编写好的查询操作，只需要通过SqlSession提供的预设方法即可： ```java try (SqlSession session = sqlSessionFactory.openSession(true)) { List users = session.selectList("selectAllUser"); //直接填写我们刚刚编写的映射id users.forEach(System.out::println); //直接查询并自动转换为对应类型 } ``` Mybatis非常智能，只需要配置一个映射关系，就能够直接将查询结果转化为一个实体类，属性会自动按照字段名称进行一一对应，免去了我们之前使用JDBC查询实体类的很多步骤。 ## Mybatis详解从这一部分开始我们就正式来学习一下Mybatis的使用方式。 ### 查询操作前面我们带各位小伙伴大概熟悉了一下Mybatis的配置流程，这一节我们来详细介绍一下如何配置查询操作。由于`SqlSessionFactory`一般只需要创建一次，因此我们可以创建一个工具类来集中创建`SqlSession`，这样会更加方便一些： ```java public class MybatisUtil { //在类加载时就进行创建 private static SqlSessionFactory sqlSessionFactory; static { try { sqlSessionFactory = new SqlSessionFactoryBuilder().build(new FileInputStream("mybatis-config.xml")); } catch (FileNotFoundException e) { e.printStackTrace(); } } /** * 获取一个新的会话 * @param autoCommit 是否开启自动提交（跟JDBC是一样的，如果不自动提交，则会变成事务操作） * @return SqlSession对象 */ public static SqlSession openSession(boolean autoCommit){ return sqlSessionFactory.openSession(autoCommit); } } ``` 现在我们只需要在main方法中直接使用工具类就能快速创建一个新的会话，然后查询结果了： ```java try(SqlSession sqlSession = MybatisUtil.openSession(true)) { List users = sqlSession.selectList("selectUser"); users.forEach(System.out::println); } ``` 查询操作在XML配置中使用一个select标签进行囊括，这里我们通过一个例子来介绍一下最基本的查询需要配置的参数，假设我们现在需要编写一个根据ID查询用户的操作，首先我们需要指定它的id，建议把id名称起的有代表性一点： ```xml ``` 接着是我们需要进行查询的参数，这里我们需要根据用户ID查询，那么传入的参数就是一个int类型的参数，参数也可以是字符串类型的，类型名称： 1. 如果是基本类型，需要使用`_int`这样前面添加下划线。 2. 如果是JDK内置的包装类型或是其他类型，可以直接使用其名称，比如`String`、`int`（Integer的缩写）、`Long` 3. 如果是自己编写的类型，需要完整的包名+类名才可以。当然，如果各位小伙伴觉得非常麻烦，我们也可以直接不填这个属性，Mybatis会自动判断： ```xml ``` 接下来就是编写我们的SQL语句了，由于这里我们需要通过一个参数来查询，所以需要填入一个占位符，通过使用`#{xxx}`或是`${xxx}`来填入我们给定的属性，名称我们先随便起一个： ```xml ``` 实际上Mybatis也是通过`PreparedStatement`首先进行一次预编译，来有效地防止SQL注入问题，但是如果使用`${xxx}`就不再是通过预编译，而是直接传值，因此对于常见的一些查询参数，我们一般都使用`#{xxx}`来进行操作保证安全性。最后我们查询到结果后，一般都是将其转换为对应的实体类对象，所以说这里我们之间填写之前建好的实体类名称，使用resultType属性来指定： ```xml ``` 当然，如果你觉得像这样每次都要写一个完整的类名太累了，也可以为它起个别名，我们只需要在Mybatis的配置文件中进行编写即可： ```xml ``` 也可以直接扫描整个包下的所有实体类，自动起别名，默认情况下别名就是类的名称： ```xml ``` 这样，SQL语句映射配置我们就编写好了，接着就是Java这边进行调用了： ```java //这里我们填写刚刚的id，然后将我们的参数填写到后面 User user = session.selectOne("selectUserById", 1); System.out.println(user); ``` 这样就可以成功查询到ID为1的用户信息了： ![QQ_1723625949253](https://s2.loli.net/2024/08/14/iQcgRtofhPlDU7T.png) 可以看到Mybatis直接省去了我们之前使用JDBC读取ResultSet的部分，直接转换为对应的实体类，当然，如果你不需要转换为实体类，Mybatis也为我们提供了多种转换方案，比如转换为一个Map对象： ```java //使用Map类型变量进行接受，Key为String类型，Value为Object类型 Map user = session.selectOne("selectUserById", 1); System.out.println(user); ``` 我们可以尝试接着来写一个同时查询ID和年龄的查询操作，为了方便这里我们就不写parameterType属性了： ```xml ``` 因为这里需要多个参数，我们可以使用一个Map或是具有同样参数的实体类来传递，显然Map用起来更便捷一些，注意key的名称需要与我们编写的SQL语句中占位符一致： ```java User user = session.selectOne("selectUserByIdAndAge", Map.of("id", 1, "age", 18)); System.out.println(user); ``` 是不是感觉还是挺简单的？我们接着来看下面这种情况，实体类中定义的属性名称和我们数据库中的名称似乎有点不太一样，这会导致Mybatis自动处理出现问题： ```java @Data public class User { int uid; String username; int age; } ``` 运行后发现，Mybatis虽然可以查询到对应的记录，但是转换的实体类数据并没有被添加上去，这是因为数据库字段名称与类中字段名称不匹配导致的，我们可以手动配一个resultMap来解决这种问题，直接在Mapper中添加： ```xml ``` 这里我们在resultMap标签中配置了一些result标签，每一个result标签都可以配置数据库字段和类属性的对应关系，这样Mybatis就可以按照我们的配置来正确找到对应的位置并赋值了，没有手动配置的字段会按照之前默认的方式进行赋值。配置完成后，最终只需要将resultType改为resultMap并指定对应id即可，然后就能够正确查询了。这里有一个RowBounds参数，用于实现分页效果，但是其分页功能是对查询到的数据进行划分，非常鸡肋，这里不进行介绍，了解即可。我们再来尝试编写一下查询一个列表，查询列表时，resultType无需设置为list这种类型，而是使用List内部所包含的类型，所以这里还是填写`com.test.User`类型或是Map类型： ```xml ``` 由于返回的结果是一个列表，这里我们需要使用`selectList`方法来执行，如果使用之前的`selectOne`会导致异常： ```java List user = session.selectList("selectUsers"); System.out.println(user); ``` 我们同样可以进行简单的条件查询，比如我们想要查询所有年龄大于等于18岁的用户： ```xml ``` 注意由于这里是XML配置，其中一些字符被用作标签表示，无法代表其原本的意思，比如小于、大于符号，分别需要使用`<`和`>`来进行转义。 ```java List user = session.selectList("selectUsersByAge", 18); ``` 我们接着来看一个比较特殊的选择方法`selectMap`，它可以将查询结果以一个Map的形式表示，只不过这和我们之前说的Map不太一样，它返回的Map是使用我们想要的属性作为Key，然后得到的结果作为Value的Map，它适用于单个数据查询或是多行数据查询： ```java //最后一个参数为我们希望作为key的属性 Map user = session.selectMap("selectUserById", 1, "id"); ``` 此时得到的结果就是： ![QQ_1723711033070](https://s2.loli.net/2024/08/15/skVRAyvo8KqjxE7.png) 可以看到这个Map中确实使用的是id作为Key，然后查询得到的实体对象作为Value。还有一个比较特殊的选择操作是`selectCursor`，它可以得到一个`Cursor`对象，同样是用于列表查询的，只不过使用起来和我们之前JDBC中的ResultSet比较类似，也是通过迭代器的形式去进行数据的读取，官方解释它主要用于惰性获取数据，提高性能： ```java public interface Cursor extends Closeable, Iterable { ... } ``` 可以看到它本身是实现了Iterable接口的，表明它可以获取迭代器或是直接使用foreach来遍历： ```java Cursor cursor = session.selectCursor("selectUsers"); for (User user : cursor) { System.out.println(user); } ``` 只不过这种方式在大部分请情况下还是用的比较少，我们主要还是以`selectOne`和`selectList`为主。最后还有一个普通的`select`方法，它支持我们使用Lambda的形式进行查询结果的处理： ```java session.select("selectUsers", context -> { //使用ResultHandler来处理结果 System.out.println(context.getResultObject()); }); ``` 结果会自动进行遍历并依次执行我们传入的Lambda表达式。 ### 指定构造方法通过前面的学习，我们已经知道如何使用Mybatis进行各种查询操作。我们知道，Mybatis在执行完查询语句后，会自动将查询的结果转换为我们所需要的实体类，那么它具体是怎么做的呢？实际上Mybatis一开始会通过我们实体类默认的无参构造得到一个最初的对象，然后通过反射进行赋值，我们可以手动编写一个带调试信息的无参构造： ```java public User() { System.out.println("????"); } ``` ![QQ_1723726330745](https://s2.loli.net/2024/08/15/7vFVPi3xXSfGtye.png) 可以看到Mybatis确实调用了我们的无参构造方法来构建对象，属性则是通过反射进行赋值，这里截取部分Mybatis源代码进行演示： ```java //这里的object就是刚刚构造好的实体类对象，prop是要设置的值的字段信息，value就是要设置的值 private void setBeanProperty(PropertyTokenizer prop, Object object, Object value) { try { //Invoker是Mybatis内部编写一个用于反射设置对象属性值的工具 Invoker method = metaClass.getSetInvoker(prop.getName()); Object[] params = { value }; try { method.invoke(object, params); //通过Invoker为传入的实体类对象赋值 } catch (Throwable t) { throw ExceptionUtil.unwrapThrowable(t); } } catch (Throwable t) { ... } } ``` 由于Mybatis默认情况下直接通过无参构造来创建实体类对象，如果我们的类中存在其他的构造方法覆盖掉默认的无参构造，那么Mybatis会选择可用的构造方法来进行构造。但是如果存在多个构造方法，Mybatis会出现问题： ```java @ToString public class User { ... public User(int id) { this.id = id; } public User(String name, int age) { this.name = name; this.age = age; } } ``` 运行时出现错误： ``` Exception in thread "main" org.apache.ibatis.exceptions.PersistenceException: ### Error querying database. Cause: org.apache.ibatis.executor.ExecutorException: No constructor found in com.test.User matching [java.lang.Integer, java.lang.String, java.lang.Integer] ### The error may exist in file:mappers/TestMapper.xml ``` 此时由于类中存在多个构造方法，而Mybatis不知道该如何选择，那么就会告诉我们找不到合适的构造方法，要解决这种问题也很简单，我们不需要删除这些多余的构造方法，只需添加一个无参构造或是全参构造即可，注意全参构造必须与查询结果字段参数一一对应。但是注意，Mybatis仅仅是使用这种方式进行对象的构建，而字段的赋值无论是什么构造方法，都会使用反射进行一次赋值： ```java public User(int id, String name, int age) { this.id = id; this.name = name; this.age = age + 20; //这里我们让age在赋值时增加一次 } ``` 我们会发现，就算像这样进行了修改，最终的结果依然是被赋值为数据库中的结果，也就是说构造方法在默认情况下仅仅只是用于构造一个单纯的对象罢了。如果需要让Mybatis完全使用构造方法进行对象构建与赋值工作，那么我们需要在XML中手动编写配置，同样需要使用resultMap来完成： ```xml ``` 这一次我们在resultMap中添加constructor标签，表示我们的查询结果直接使用指定的构造方法来处理。接着我们需要配置一下constructor里面的内容，使其符合我们指定构造方法的定义，比如现在我们有一个这样的构造方法： ```java public User(int id, String name) { this.id = id; this.name = name + "同学"; } ``` 那么对应的XML配置编写为，使用arg标签来代表每一个参数，主键可以使用idArg来表示，有助于优化性能： ```xml ``` 注意参数的顺序，必须和构造方法的顺序一致，否则会导致Mybatis无法确认。指定构造方法后，若此字段被填入了构造方法作为参数，将不会通过反射给字段单独赋值，而构造方法中没有传入的字段，依然会被反射赋值。 ### 接口绑定之前我们演示了，如何创建一个映射器来将结果快速转换为实体类，但是这样可能还是不够方便，我们每次都需要去找映射器对应操作的名称，而且还要知道对应的返回类型，再通过`SqlSession`来执行对应的方法，能不能再方便一点呢？我们可以通过`namespace`来将各种操作绑定到一个接口上，然后使用方法的形式来表示，注意接口的参数和返回值必须正确对应，否则可能会出现问题： ```java public interface TestMapper { User selectUserById(int id); } ``` 接着将Mapper文件的命名空间修改为我们的接口完整名称： ```xml ``` 这里建议将对应的xml配置也放到放到同包中，作为内部资源： ![QQ_1723457472353](https://s2.loli.net/2024/08/12/N3bTsDLtlS1mckq.png) 作为内部资源后，我们需要修改一下配置文件中的mapper文件目录，不使用url而是resource表示是Jar内部的文件： ```xml ``` 现在我们可以直接通过`SqlSession`获取我们编写接口的实现类，这个实现类是由Mybatis根据我们的配置自动生成的，不需要我们做任何事情： ```java try(SqlSession sqlSession = MybatisUtil.openSession(true)) { TestMapper mapper = sqlSession.getMapper(TestMapper.class); //直接获取实现类 //这里调用我们编写的接口方法 mapper.selectUser().forEach(System.out::println); } ``` 是不是感觉非常强大？那肯定有人好奇，TestMapper明明是一个我们自己定义接口啊，Mybatis也不可能提前帮我们写了实现类啊，那这接口怎么就出现了一个实现类呢？我们可以通过调用`getClass()`方法来看看实现类是个什么： ```java TestMapper testMapper = sqlSession.getMapper(TestMapper.class); System.out.println(testMapper.getClass()); ``` 我们发现，得到的类名称很奇怪`class jdk.proxy2.$Proxy4`，它其实是通过动态代理生成的，相当于在程序运行过程中动态生成了一个实现类，而不是预先定义好的，有关Mybatis这一部分的原理，我们放在最后一节进行讲解。我们接着来看更方便的用法，有些时候，我们的查询操作可能需要不止一个参数： ```xml ``` 一种最简单的方式就是和之前一样，我们使用一个Map作为参数，然后将这些参数添加到Map中进行传递： ```java User selectUserByIdAndAge(Map map); ``` ```java TestMapper mapper = session.getMapper(TestMapper.class); System.out.println(mapper.selectUserByIdAndAge(Map.of("id", 1, "age", 18))); ``` 只不过，这样编写实在是太复杂了，要是由一种更简单的方式就好了，我们也可以直接将这两个参数定义到形参列表中： ```java User selectUserByIdAndAge(int id, int age); ``` 只不过这种方式查询的话，Mybatis会并不能正确获取对应的参数： ``` ### Cause: org.apache.ibatis.binding.BindingException: Parameter 'id' not found. Available parameters are [arg1, arg0, param1, param2] at org.apache.ibatis.exceptions.ExceptionFactory.wrapException(ExceptionFactory.java:30) ``` 这是因为Java代码编译后形参名称无法保留，导致Mybatis无法确定具体哪个参数交什么名字，所以默认情况下它们将会以 param 加上它们在参数列表中的位置来命名，比如：#{param1}、#{param2}等，这里id实际上就是param1： ```sql select * from user where id = #{param1} and age = #{param2} ``` 当然，如果你实在需要使用对应的属性名称，我们也可以手动添加一个`@Param`注解来指定某个参数的名称： ```java User selectUserByIdAndAge(@Param("id") int id, @Param("age") int age); ``` 这样Mybatis就可以正确识别了。 ### 复杂查询前面我们介绍了简单查询，只不过有些时候可能会遇到比较麻烦的查询，这一节我们来介绍一下一对一、一对多、多对一的查询实现方式。首先来看最简单的一对一查询，假设我们每个用户都有一个自己的详细信息表： ![QQ_1723792352474](https://s2.loli.net/2024/08/16/M4SX2Woa9CybQUw.png) 这里的id与用户id一致，作为用户id的逻辑外键，表示对应用户的详细信息。对应的实体类为： ```java @Data public class UserDetail { int id; String description; Date register; String avatar; } @Data public class User { int id; String name; int age; UserDetail detail; } ``` 现在我们希望查询User时，同时将用户的详细信息包含在内，像这种一对一查询该怎么实现呢？我们现在同样需要使用`resultMap`来自定义映射规则 ```xml ``` MyBatis 有两种不同的方式加载关联： - 嵌套结果映射：使用嵌套的结果映射来处理连接结果的重复子集。 - 嵌套 Select 查询：通过执行另外一个 SQL 映射语句来加载期望的复杂类型。我们先来看第一种方式，这里我们需要使用关联查询将用户的详细信息一并获取，然后配置关联查询相关信息，最后由Mybatis来对查询的结果进行处理即可，首先是关联查询的SQL语句，这里我们直接使用左连接： ```sql select * from user left join user_detail on user.id = user_detail.id where user.id = #{id} ``` ![QQ_1723794339355](https://s2.loli.net/2024/08/16/ITDpQg3dA7aL9o1.png) 接着我们需要在resultMap编写好对应关系，一对一查询我们可以使用association标签来进行指定，其中property就是需要进行一对一处理的对象，在此标签内部填写需要进行一对一映射的对象属性： ```xml ``` 这里的column和javaType可以不填，Mybatis一般情况下可以自动完成推断，配置完成后，我们在查询时Mybatis就可以自动把额外信息也封装好了： ![QQ_1723796178911](https://s2.loli.net/2024/08/16/3e6fAudX7G9qFsU.png) 我们接着来看第二种方式，使用嵌套select语句进行查询，也就是说，我们可以在查询user表的时候，同时查询user_detail表的对应信息，分别执行两个选择语句，最后再由Mybatis将其结果合并，效果和第一种方法是一样的： ```xml ``` 这里我们分别配置了两个select标签用于分别查询用户基本信息和详细信息，并使用association标签的select属性来指定关联查询操作，得到结果是一样的： ![QQ_1723796178911](https://s2.loli.net/2024/08/16/3e6fAudX7G9qFsU.png) 我们可以开启Mybatis的日志来观察具体执行的操作，这里我们需要在Mybatis配置文件中添加： ```xml ``` 这样Mybatis运行时就会打印日志到控制台了： ``` ... Opening JDBC Connection Created connection 1962329560. ==> Preparing: select * from user where id = ? ==> Parameters: 1(Integer) <== Columns: id, name, age <== Row: 1, 小明, 18 ====> Preparing: select * from user_detail where id = ? ====> Parameters: 1(Integer) <==== Columns: id, description, register, avatar <==== Row: 1, 我是一个阳光开朗大男孩, 2024-08-16 15:15:03, https://www.baidu.com <==== Total: 1 <== Total: 1 User(id=1, name=小明, age=18, detail=UserDetail(id=1, description=我是一个阳光开朗大男孩, register=Fri Aug 16 15:15:03 CST 2024, avatar=https://www.baidu.com)) Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@74f6c5d8] Returned connection 1962329560 to pool. ``` Mybatis日志中，`==>`向右的箭头就是发送给MySQL服务器的SQL语句以及其参数列表，`<==`向左的箭头就是得到的结果，可以看到这里一共执行了两次SQL语句，分别是user表和user_detail表的查询操作。一对一查询非常简单，我们接着来看一对多查询，现在来一个新的表，用于存放用户借阅的图书，对应实体类如下： ```java @Data public class Book { int bid; String title; } @Data public class User { int id; String name; int age; List books; //直接得到用户所属的所有书籍信息 } ``` 其中`book`表设计如下，其中uid作为用户id的逻辑外键，表示这本书是谁借的： ![QQ_1723733068017](https://s2.loli.net/2024/08/15/8RlcWkFe7yb2nXT.png) 对于一对多查询，我们也可以进行关联查询来让Mybatis自动解析结果并封装为对象，首先还是关联查询的SQL语句，这里我们让user左连接到book表中： ```sql select * from user left join book on user.id = book.uid where user.id = #{id} ``` ![QQ_1723802885239](https://s2.loli.net/2024/08/16/4Ijp6iU5P9X2N8u.png) 此时由于出现了多行数据，我们需要配置一个`collection`标签来让其可以正确处理关联的集合结果，Mybatis会根据我们配置的属性自动将关联数据变为一个集合并存放在对象中： ```xml ``` 我们需要在resultMap中完整编写需要查询对象的属性对应关系以及在collection中编写关联查询的集合内类型相关属性对应关系，当然这个关系哪怕只写一个Mybatis也可以自动推断其他的，不过建议还是写完整一点： ![QQ_1723734667720](https://s2.loli.net/2024/08/15/udbylhUV7GT9znm.png) 了解了一对多，那么多对一又该如何查询呢，比如每个用户现在都有一个小组，但是他们目前都是在同一个小组中，此时我们查询所有用户信息的时候，需要自动携带他们的小组： ![QQ_1723818427656](https://s2.loli.net/2024/08/16/gl5qZpvAc6Lk4Fi.png) 这里我们需要修改一下user表来记录每一个用户所属的小组id，这里使用gid作为分组id的逻辑外键： ![QQ_1723818596301](https://s2.loli.net/2024/08/16/dsWXt4pEATocyRO.png) 接着是实体类设计： ```java @Data public class Group { int id; String name; } @Data public class User { int id; String name; int age; Group group; } ``` 接着就是编写SQL映射，实际上这里跟我们之前的一对一非常类似，我们只需要让查询出来的每一个用户都左连接分组信息即可，这样Mybatis就可以通过association来自动处理了： ```sql select *, groups.name as gname from user left join `groups` on user.gid = groups.id ``` 注意SQL语句中一些字段存在歧义，我们需要手动为其起个别名，接着就是XML编写了： ```xml ``` 这样我们就可以成功实现多对一查询了，这与之前的一对一比较类似。 ### DML操作前面我们介绍了查询操作，我们接着来看修改相关操作。Mybatis为我们的DML操作提供了几个预设方法： ```java int insert(String statement); int insert(String statement, Object parameter); int update(String statement); int update(String statement, Object parameter); int delete(String statement); int delete(String statement, Object parameter); ``` 可以看到，这些方法默认情况下返回的结果都是`int`类型的，这与我们之前JDBC中是一样的，它代表执行SQL后受影响的行数。我们来尝试编写一个插入操作，Mybatis为我们提供的插入操作非常快捷，我们可以直接让一个User对象作为参数传入，即可在配置中直接解析其属性到insert语句中，这里需要用到insert标签： ```xml insert into user (name, age) values (#{name}, #{age}) ``` 这里我们将parameterType类型设置为我们的实体类型，这样下面在使用`#{name}`时Mybatis就会自动调用类中对应的Get方法来获取结果，不过，即使这里不指定具体类型，Mybatis也能完成自动推断，非常智能。有些时候，我们的数据插入后使用的是一个自增主键ID，那么这个自增的主键值我们该如何获取到呢？Mybatis为我们提供了一些参数用于处理这种问题： ```xml insert into user (name, age) values (#{name}, #{age}) ``` 这里`useGeneratedKeys`设置为`true`表示我们希望获取数据库生成的键，`keyProperty`设置为User类中的需要获取自增结果的属性名，`keyColumn`为数据库中自增的字段名称，但是一般情况下不需要手动设置，但是某些数据库（像 PostgreSQL）中，当主键列不是表中的第一列的时候，必须设置。这样我们就可以获取到自增后的值了，接着我们什么都不需要做，Mybatis会在查询完后自动为我们的User对象赋值： ![QQ_1723824700173](https://s2.loli.net/2024/08/17/OUWu97HmpPNyB1K.png) 是不是感觉很方便？和之前一样，我们也可以直接将其绑定到一个接口上： ```java public interface TestMapper { int addUser(User user); } ``` 注意返回类型必须是int或是long这类数字类型，表示生效的行数，然后这里我们传入的参数直接写成对应的类型即可。我们接着来看修改操作，比如要根据ID修改用户的年龄： ```xml update user set age = #{age} where id = #{id} ``` ```java int setUserAgeById(User user); ``` 这里的参数我们依然选择使用User，和之前insert一样，Mybatis会从传入的对象中自动获取需要的参数，当然我们也可以将此方法设计为两个参数的形式： ```java int setUserAgeById(@Param("age") int age, @Param("id") int id); ``` 删除操作则更为简单，假设我们要根据用户的id进行数据的删除： ```xml delete from user where id = #{id} ``` 这些操作相比查询操作来说非常简单就可以实现，这里就不多做介绍了。 ### 事务操作我们可以在获取`SqlSession`关闭自动提交来开启事务模式，和JDBC其实都差不多，在创建SqlSession的时候不填写参数默认使用的就是事务模式： ```java try (SqlSession session = sqlSessionFactory.openSession(false)) { ... } ``` 我们发现，在关闭自动提交后，我们的内容是没有进入到数据库的： ```java try(SqlSession session = MybatisUtils.openSession(false)) { TestMapper mapper = session.getMapper(TestMapper.class); mapper.deleteUserById(1); //虽然日志中已经提示生效1行，但是并没有提交 } ``` SqlSession接口中为我们提供了事务操作相关的方法，这里我们可以直接尝试进行事务的提交： ```java TestMapper mapper = session.getMapper(TestMapper.class); mapper.deleteUserById(7); session.commit(); //通过SqlSession进行事务提交 ``` 注意，如果我们在提交事务之前，没有进行任何的DML操作，也就是删除、更新、插入的其中任意一种操作，那么调用`commit`方法则不会进行提交，当然如果仍然需要提交的话也可以使用`commit(true)`来强制提交。我们接着来测试一下回滚操作： ```java TestMapper mapper = session.getMapper(TestMapper.class); mapper.deleteUserById(1); System.out.println(mapper.selectUserById(1)); //此时由于数据被删除，无法查到 session.rollback(); //进行回滚操作 System.out.println(mapper.selectUserById(1)); //之前被删除的数据回来了 ``` 事务相关操作非常简单，这里就暂时先介绍这么多。 ### 动态SQL 在之前JDBC讲解的时候，我们就提到过批量执行语句的问题，当我们要执行很多条语句时，大家可能会一个一个地提交： ```java //现在要求把下面所有用户都插入到数据库中 List users = List.of("小刚", "小强", "小王", "小美", "小黑子"); //使用for循环来一个一个执行insert语句 for (String user : users) { statement.executeUpdate("insert into user (name, age) values ('" + user + "', 18)"); } ``` 虽然这样看似非常完美，也符合逻辑，但是实际上我们每次执行SQL语句，都像是去厨房端菜到客人桌上一样，我们每次上菜的时候只从厨房端一个菜，效率非常低，但是如果我们每次上菜推一个小推车装满N个菜一起上，效率就会提升很多，而数据库也是这样，我们每一次执行SQL语句，都需要一定的时间开销，但是如果我把这些任务合在一起告诉数据库，效率会截然不同： ![QQ_1722352388506](https://s2.loli.net/2024/07/30/7lxfue9jU8nMYLQ.png) 可见，使用循环操作执行数据库相关操作实际上非常耗费资源，不仅带来网络上的额外开销，还有数据库的额外开销，我们更推荐大家使用批处理来优化这种情况，一次性提交一个批量操作给数据库。需要在Mybatis中开启批处理，我们只需要在创建SqlSession时进行一些配置即可： ```java factory.openSession(ExecutorType.BATCH, autoCommit); ``` 在使用`openSession`时直接配置`ExecutorType`为BATCH即可，这样SqlSession会开启批处理模式，在多次处理相同SQL时会尽可能转换为一次执行，开启批处理后，无论是否处于事务模式下，我们都需要`flushStatements()`来一次性提交之前是所有批处理操作： ```java TestMapper mapper = session.getMapper(TestMapper.class); for (int i = 1; i <= 5; i++) { mapper.deleteUserById(i); } session.flushStatements(); ``` 此时日志中可以看到Mybatis在尽可能优化我们的SQL操作： ![QQ_1724050907084](https://s2.loli.net/2024/08/19/b2ZexXIYiHSsM7v.png) 除了使用批处理之外，Mybatis还为我们提供了一种更好的方式来处理这种问题，我们可以使用动态SQL来一次性生成一个批量操作的SQL语句，这里先介绍一下什么是动态SQL。 > 动态 SQL 是 MyBatis 的强大特性之一。如果你使用过 JDBC 或其它类似的框架，你应该能理解根据不同条件拼接 SQL 语句有多痛苦，例如拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。利用动态 SQL，可以彻底摆脱这种痛苦。简单来说，动态SQL在执行时可以进行各种条件判断以及循环拼接等操作，极大地提升了SQL语句编写的的灵活性。我们先来看看条件判断，在编写SQL时，我们可以添加一些用于条件判断的标签到SQL语句中，比如我们希望在根据ID查询用户时，如果查询的ID大于3，那么必须同时要满足大于18岁这个条件，这看似是一个很奇怪的查询条件，但是在我们进入到公司后确实可能会遇到这些奇葩需求，此时动态SQL就能很轻松实现这个操作： ```xml ``` 这里我们使用`if`标签表示里面的内容会在判断条件满足时拼接到后面，如果不满足，那么就不拼接里面的内容到原本的SQL中，其中test属性就是我们需要填写的判断条件，它采用OGNL表达式进行编写，语法与Java比较相似，如果各位小伙伴比较感兴趣也可以前往：https://commons.apache.org/dormant/commons-ognl/ 详细了解。可以看到，当我们查询条件不同时，Mybatis会选择性拼接我们的SQL语句： ![QQ_1724052613799](https://s2.loli.net/2024/08/19/fSOXZdTjFR4oMgP.png) 除了if操作之外，Mybatis还针对多分支情况提供了choose操作，它类似于Java中的switch语句，比如现在我们希望在查询用户时，ID等于1的必须同时要满足小于18岁，ID等于2的必须满足等于18岁，其他情况的必须满足大于18岁，我们可以像这样进行编写： ```xml ``` 注意在`when`中不允许使用`<`或是`>`这种模糊匹配的条件。最后我们再来介绍一下`foreach`操作，它与Java中的for类似，可以实现批量操作，这非常适合处理我们前面说的批量执行SQL的问题： ```java for (int i = 1; i <= 5; i++) { mapper.deleteUserById(i); } ``` 但是实际上这种情况完全可以简写为一个SQL语句： ```sql DELETE FROM users WHERE id IN (1, 2, 3, 4, 5); ``` 所以，现在我们使用foreach来完成它就很简单了： ```xml delete from user where id in #{item} ``` 其中collection就是我们需要遍历的集合或是数组等任意可迭代对象，item和index分别代表我们在foreach标签中使用每一个元素和下标的变量名称，最后open和close用于控制起始和结束位置添加的符号，separator用于控制分隔符，现在执行以下操作： ```java session.delete("deleteUsers", List.of(1, 2, 3, 4, 5)); ``` 最后实际执行的SQL为： ![QQ_1724059653501](https://s2.loli.net/2024/08/19/rFP1oJNM56ZebA4.png) 是不是感觉有点那味了？我们再来看一个例子，比如现在我们想要批量插入一些用户到数据库里面，原本Java应该这样写，但是这是一种极其不推荐的做法： ```java TestMapper mapper = session.getMapper(TestMapper.class); List users = List.of(new User("小美", 17), new User("小张", 18), new User("小刘", 19)); for (User user : users) { mapper.insertUser(user); } ``` 实际上这种操作完全可以浓缩为一个SQL语句： ```sql INSERT INTO user (name, age) VALUES ('小美', 17), ('小张', 18), ('小刘', 19); ``` 那这时又可以直接使用咱们的动态SQL来完成操作了： ```xml insert into user (name, age) values (#{user.name}, #{user.age}) ``` ![QQ_1724060416443](https://s2.loli.net/2024/08/19/DRAt7hbdZizqpSk.png) 通过使用动态SQL语句，我们基本上可以解决大部分的SQL查询和批量处理场景了。 ### 缓存机制其实缓存机制我们在之前学习IO流的时候已经提及过了，我们可以提前将一部分内容放入缓存，下次需要获取数据时，就可以直接从缓存中读取，这样的话相当于直接从内存中获取而不是再去向数据库索要数据，效率会更高，缓存的概念在我们后续的学习中还会经常遇见，它也是现在提高数据获取效率的良好解决方案。 Mybatis为了查询效率，同样内置了一个缓存机制，我们在查询时，如果Mybatis缓存中存在数据，那么我们就可以直接从缓存中获取，而不是再去向数据库进行请求，节省性能开销。 ![image-20230306163638882](https://s2.loli.net/2024/08/20/Vn4fQlW1roPMaDH.png) Mybatis的缓存机制有些复杂，存在一级缓存和二级缓存，我们首先来看一下一级缓存，默认情况下，只启用了本地的会话缓存，也就是一级缓存，它仅仅对一个会话中的数据进行缓存（一级缓存强制启用，无法关闭，只能做调整）也就是每一个SqlSession都有有一个对应的缓存，我们来看看下面这段代码： ```java TestMapper mapper = session.getMapper(TestMapper.class); System.out.println(mapper.selectUserById(1)); System.out.println(mapper.selectUserById(1)); //再次获取 ``` 这里我们连续获取了两次ID为1的用户，我们会在日志中惊奇地发现，这里的查询操作实际上只进行了一次： ![QQ_1724167595196](https://s2.loli.net/2024/08/20/OlFMk4gEYTZf2NC.png) 我们去掉类上的`@Data`注解，会发现得到的两个对象实际上就是同一个： ![QQ_1724167645759](https://s2.loli.net/2024/08/20/4iTIlZgFa3JS5RM.png) 也就是说我们第二次查询不仅压根就没执行SQL语句，甚至直接没有重新构造对象，而是直接获取之前创建好的。可见，Mybatis确实存在着缓存机制来进行性能优化。那么如果我修改了数据库中的内容，缓存还会生效吗： ```java System.out.println(mapper.selectUserById(1)); mapper.updateAgeById(1, 19); System.out.println(mapper.selectUserById(1)); ``` 此时由于我们更新了数据库中的数据，那么之前缓存的内容也会跟着失效，第二次获取的时候会进行重新查询。也就是说Mybatis知道我们对数据库里面的数据进行了修改，所以之前缓存的内容可能就不是当前数据库里面最新的内容了。但是一定注意，一级缓存只针对于单个会话，多个会话之间不相通。因此，一个会话DML操作只会重置当前会话的缓存，不会重置其他会话的缓存，我们可以来试验一下： ```java try(SqlSession s1 = MybatisUtils.openSession(true); SqlSession s2 = MybatisUtils.openSession(true)) { TestMapper m1 = s1.getMapper(TestMapper.class); TestMapper m2 = s2.getMapper(TestMapper.class); System.out.println(m1.selectUserById(1)); m2.updateAgeById(1, 19); System.out.println(m1.selectUserById(1)); } ``` 可以看到，会话1在重复查询数据时，即使会话2已经修改了数据，但是依然没有影响会话1之中的缓存。一级缓存给我们提供了很高速的访问效率，但是它的作用范围实在是有限，如果一个会话结束，那么之前的缓存就全部失效了，但是我们希望缓存能够扩展到所有会话都能使用，无论哪个会话对于数据的查询缓存都可以直接被所有会话使用。我们可以通过二级缓存来实现，二级缓存默认是关闭状态，要开启二级缓存，我们需要在映射器XML文件中添加： ```xml ``` 二级缓存是Mapper级别的，只要是使用这个Mapper的会话，都会关联到这个二级缓存，无论哪个会话失效，它之前查询的缓存依然会存在于二级缓存中，依然可以被其他会话直接使用。我们可以对cache标签进行一些配置： ```xml ``` 其中，`size`表示最大的缓存对象数量，当缓存达到上限时，会根据`eviction`配置的策略进行清理： * `LRU` – 最近最少使用：移除最长时间不被使用的对象。 * `FIFO` – 先进先出：按对象进入缓存的顺序来移除它们。 * `SOFT` – 软引用：基于垃圾回收器状态和软引用规则移除对象。 * `WEAK` – 弱引用：更积极地基于垃圾收集器状态和弱引用规则移除对象。 `flushInterval`用于控制缓存刷新时间，当到达指定时间时会自动清理所有缓存，默认情况下如果不配置此项则不会进行定时清理。`readOnly`（只读）属性可以被设置为 true 或 false，只读的缓存会给所有调用者返回相同的缓存对象，且对象不能被修改。这就提供了可观的性能提升。而可读写的缓存会（通过序列化）返回缓存对象的拷贝。速度上会慢一些，但是更安全，因此默认值是 false。 **注意：** 二级缓存是事务性的，这意味着，当 SqlSession 结束并提交时，或是结束并回滚，而且没有执行 flushCache=true 的 insert/delete/update 语句时，缓存才会被更新。开启二级缓存后，再次执行我们之前的操作，就可以直接在二级缓存中命中了： ![QQ_1724169383598](https://s2.loli.net/2024/08/20/iIZPElyrYN2RdKf.png) 实际上，添加了二级缓存之后，Mybatis会先从二级缓存中查找数据，当二级缓存中没有时，才会从一级缓存中获取，当一级缓存中都还没有数据时，才会请求数据库。当我们开启二级缓存后，默认情况下一个Mapper中所有的操作都会使用二级缓存，我们也可以单独配置其不使用二级缓存，只需要修改useCache属性即可： ```xml ``` 有些操作可能比较特殊，比如我们希望某个操作执行完成后，直接清除所有缓存，无论是一级缓存还是二级缓存，那么此时就可以开启`flushCache`属性： ```xml ``` 开启此选项后，调用此操作将直接导致一级和二级缓存被清除。虽然缓存机制给我们提供了很大的性能提升，但是缓存存在一个问题，我们之前在`计算机组成原理`中可能学习过缓存一致性问题，也就是说当多个CPU在操作自己的缓存时，可能会出现各自的缓存内容不同步的问题。 ![image-20230306163717033](https://s2.loli.net/2024/08/20/f4hm7o8jcrXbul6.png) 而Mybatis也会这样，我们来看看这个例子： ```java TestMapper mapper = session.getMapper(TestMapper.class); while (true){ Thread.sleep(3000); System.out.println(mapper.selectUserById(1)); } ``` 我们现在循环地每三秒读取一次，而在这个过程中，我们使用其他软件手动修改数据库中的数据，将1号用户的ID改成100，那么理想情况下，下一次读取将直接无法获取到这行数据，因为ID已经发生变化了。但是结果却是依然能够读取，并且sid并没有发生改变，这也证明了Mybatis的缓存在生效，因为我们是从外部进行修改，Mybatis不知道我们修改了数据，所以依然在使用缓存中的数据，但是这样很明显是不正确的，因此，如果存在多台服务器或者是多个程序都在使用Mybatis操作同一个数据库，并且都开启了缓存，需要解决这个问题，我们只能关闭所有二级缓存，并且在Mybatis每个操作都配置`flushCache`为true来保证刷新。只不过这种操作实际上是治标不治本的，实现多服务器缓存共用才是最终解决方案，也就是让所有的Mybatis都使用同一个缓存进行数据存取，在后面，我们会继续学习Redis、Ehcache、Memcache等缓存框架，通过使用这些工具，就能够很好地解决缓存一致性问题。 ### 使用注解开发在之前的学习中，我们已经体验到Mybatis为我们带来的便捷了，我们只需要编写对应的映射器，并将其绑定到一个接口上，即可直接通过该接口执行我们的SQL语句，极大的简化了我们之前JDBC那样的代码编写模式。那么，能否实现无需XML映射器配置，而是直接使用注解在接口上进行配置呢？从这节课开始，我们可以直接删除掉所有的`Mapper.xml`文件了，只保留Mapper相关的接口。现在，我们来尝试以全注解的形式重现编写咱们的SQL语句映射，还是以查询所有的用户为例，既然现在不需要配置`Mapper.xml`文件了，那么我们现在需要重写在Mybatis的配置文件中进行mapper的配置，因为现在只需要使用接口来进行配置，所以使用package标签来指定一个包，包下所有的接口都将直接作为Mapper配置接口： ```xml ``` 现在我们还是在Mapper中添加一个对应的方法用于执行： ```java public interface TestMapper { List selectAllUser(); } ``` 之前我们需要像这样编写： ```xml ``` 现在只需要一个注解即可，Mybatis为我们提供了丰富的注解用于表示不同SQL语句类型，这里的`@Select`代表的就是select标签，我们只需要直接在其中编写SQL语句即可，而返回类型Mybatis会自动根据方法的返回值进行判断： ```java public interface TestMapper { @Select("select * from user") List selectAllUser(); } ``` 现在我们来试试看吧： ![QQ_1724143033753](https://s2.loli.net/2024/08/20/ALdMlG5evncp4kH.png) 包括一些SQL语句参数的使用也是和之前完全一样，比如插入一个用户： ```java @Insert("insert into user (name, age) values (#{name}, #{age})") int insertUser(User user); ``` 虽然Mybatis为我们提供了之前XML配置中各种操作的对应注解，但是我们发现，这些注解并不能像之前XML那样直接修改一些属性，比如这里我们希望配置`useGeneratedKeys`来得到自动生成的主键，需要配置这些额外的参数，我们可以使用`@Options`注解： ```java @Options(useGeneratedKeys = true, keyColumn = "id", keyProperty = "id") @Insert("insert into user (name, age) values (#{name}, #{age})") int insertUser(User user); ``` ```xml insert into user (name, age) values (#{name}, #{age}) ``` 这两种写法效果是完全一样的，所以我们通过Mybatis为我们设计的这一系列注解就可以很轻松地取代掉之前的配置。假如现在我们的实体类字段名称与数据库不同，此时该如何像之前一样配置`resultMap`呢？ ```java public class User { int uid; String username; int age; } ``` ```xml ``` 我们可以使用`@Results`注解来实现这种操作，它的使用方式与resultMap几乎没什么区别： ```java @Results({ @Result(id = true, column = "id", property = "uid"), @Result(column = "name", property = "username") }) @Select("select * from user") List selectAllUser(); ``` 是不是感觉很简单？当然，如果你还是觉得这种方式配置起来不如之前方便，那么你也可以单独在XML中配置一个resultMap然后直接通过注解的形式引用： ```java @ResultMap("test") @Select("select * from user") List selectAllUser(); ``` 那么现在如果我们需要指定使用的构造方法怎么办呢？就像我们之前在使用constrator标签一样，Mybatis为我们提供了`@ConstructorArgs`注解，配置方式和之前几乎一致： ```java public class User { int id; String name; int age; public User(int id, String name, int age) { this.id = id; this.name = name; this.age = age + 20; } } ``` ```java @ConstructorArgs({ @Arg(id = true, column = "id", javaType = int.class), @Arg(column = "name", javaType = String.class), @Arg(column = "age", javaType = int.class) }) @Select("select * from user") List selectAllUser(); ``` 这与我们之前的XML配置完全一致： ```xml ``` 我们再来看看之前在resultMap中配置的关联查询该如何编写，Mybatis也为我们提供了丰富的注解用于处理这类问题，我们首先来看看一对一查询： ```java @Results({ @Result(id = true, column = "id", property = "id"), @Result(column = "id", property = "detail", one = @One(select = "selectDetailById")) }) @Select("select * from user where id = #{id};") User selectUserById(int id); @Select("select * from user_detail where id = #{id}") UserDetail selectDetailById(int id); ``` 我们在配置`@Result`注解时，只需要将one或是many参数进行填写即可，它们分别代表一对一关联和一对多关联，使用`@One`和`@Many`注解来指定其他查询语句进行嵌套查询，就像是我们之前使用`association`和`collection`那样。不过很遗憾的是，我们无法完全通过注解来实现之前的联合查询解析（这是因为 Java 注解不允许循环引用）只能使用这种嵌套查询来完成复杂查询操作，因此，如果对这种复杂查询有着一定需求的话，建议使用之前的XML方式进行配置。我们还可以使用注解进行动态SQL的配置，比如现在我们想要实现之前的这个奇葩需求： ```xml ``` Mybatis针对于所有的SQL操作都提供了对应的Provider注解，用于配置动态SQL，我们需要先创建一个类编写我们的动态SQL操作： ```java public class TestSqlBuilder { public static String buildGetUserById(int id) { return new SQL(){{ //SQL类中提供了常见的SELECT、FORM、WHERE等操作 SELECT("*"); FROM("user"); WHERE("id = #{id}"); if (id > 3) { WHERE("age > 18"); } }}.toString(); } } ``` 详细的SQL语句构建器语法文档：https://mybatis.org/mybatis-3/zh_CN/statement-builders.html 构建完成后，接着我们就可以使用`@SelectProvider`来引用这边编写好的动态SQL操作： ```java @SelectProvider(type = TestSqlBuilder.class, method = "buildGetUserById") User selectUserById(int id); ``` 效果和之前我们编写XML形式的动态SQL一致，当然，如果遇到了多个参数的情况，我们同样需要使用`@Param`来指定参数名称，包括TestSqlBuilder中编写的方法也需要添加，否则必须保证形参列表与这边接口一致。虽然这样可以实现和之前差不多的效果，但是这实在是太过复杂了，我们还需要单独编写一个类来做这种事情，实际上我们也可以直接在`@Select`中编写一个XML配置动态SQL，Mybatis同样可以正常解析： ```java @Select(""" """) User selectUserById(int id); ``` 这里只需要包括一个script标签我们就能像之前XML那样编写动态SQL了，只不过由于IDEA不支持这种语法的识别，可能会出现一些莫名其妙的红标，但是是可以正常运行的。最后我们来看一下二级缓存相关的配置，使用`@CacheNamespace`注解直接定义在接口上即可，然后我们可以通过使用`@Options`来控制单个操作的缓存启用： ```java @CacheNamespace(size = 512, readWrite = false) public interface TestMapper { ``` 我们如果需要控制单个方法的缓存，同样可以使用`@Option`来进行配置： ```java @Options(flushCache = Options.FlushCachePolicy.TRUE, useCache = false) @Select("select * from user where id = #{id}") User selectUserById(int id); ``` 这里我们不如再做的更加极致一点，咱们把配置文件也给变成代码配置，彻底抛弃XML配置，实际上我们的XML配置中所有配置项都可以以Configuration对象的形式进行配置，最后在构造SqlSessionFactory时也可以通过此对象进行创建： ```java private static Configuration initConfiguration() { Configuration configuration = new Configuration(); PooledDataSource dataSource = new PooledDataSource( "com.mysql.cj.jdbc.Driver", "jdbc:mysql://localhost:3306/web_study", "test", "123456"); Environment environment = new Environment("development", new JdbcTransactionFactory(), dataSource); configuration.setEnvironment(environment); configuration.getTypeAliasRegistry().registerAliases("com.test.entity"); configuration.setLogImpl(StdOutImpl.class); configuration.addMappers("com.test.mapper"); return configuration; } ``` 有关Mybatis的基本使用，我们就暂时介绍到这里。 ## 高级用法与原理探究我们这一部分来研究Mybatis的高级用法和原理探究。 ### 类型处理器（选学）在我们前面的学习中，相信各位小伙伴应该有留意到一个叫做`typeHandler`的属性，在正常情况下，我们使用Mybatis得到结果都能够自动完成属性类型的的推断，比如： ```java public class User { int id; String name; int age; } ``` 这里类中的所有字段类型实际上在查询时都可以被正确进行解析，这是因为Mybatis默认情况下对这些JDK提供的类型做了支持，因此他们可以直接正确进行解析，详细列表：https://mybatis.org/mybatis-3/zh_CN/configuration.html#typeHandlers 但是有些时候可能我们的对象字段并不是JDK提供的类型，尤其是后面各位小伙伴在后续Spring阶段的学习中接触到JSON这种数据时，数据的转换就会变得很重要，这里我们通过一个简单例子来进行讲解： ```java @Data public class MyString { //现在我们自己写了一个对String包装类型 private final String text; } ``` 接着我们将实体类的对应的字段进行修改： ```java public class User { int id; MyString name; //使用我们自己定义的String包装类 int age; } ``` 此时，我们希望的是Mybatis可以正确将数据库中的name字段读取出来，并自动转化为一个MyString对象，里面的text值为查询name得到的结果，但这毕竟是理想情况，实际上Mybatis压根不知道这种类型该怎么进行数据的映射，就直接报错了： ``` ### Error building SqlSession. ### The error may exist in com/test/mapper/TestMapper.java (best guess) ### Cause: org.apache.ibatis.builder.BuilderException: Error parsing SQL Mapper Configuration. Cause: java.lang.IllegalStateException: Type handler was null on parameter mapping for property 'name'. It was either not specified and/or could not be found for the javaType (com.test.handler.MyString) : jdbcType (null) combination. at org.apache.ibatis.exceptions.ExceptionFactory.wrapException(ExceptionFactory.java:30) ``` 这里Mybatis提示我们找不到这个类型的Type handler，也就是Mybatis并不知道这种类型的数据该怎么进行映射，映射规则是什么。此时我们就可以手动提供一个TypeHandler实现，要编写自定义的类型处理器，我们需要： ```java public class MyTypeHandler extends BaseTypeHandler { @Override public void setNonNullParameter(PreparedStatement ps, int i, MyString parameter, JdbcType jdbcType) throws SQLException { } @Override public MyString getNullableResult(ResultSet rs, String columnName) throws SQLException { return null; } @Override public MyString getNullableResult(ResultSet rs, int columnIndex) throws SQLException { return null; } @Override public MyString getNullableResult(CallableStatement cs, int columnIndex) throws SQLException { return null; } } ``` 可以看到这里我们需要实现很多种不同的方法，我们一个一个来介绍。首先我们需要在类的最上方添加一个`@MappedJdbcTypes`注解，用于指定当前类型处理器是用于处理对应的数据库什么类型的数据的： ```java @MappedJdbcTypes(JdbcType.VARCHAR) //这里我们映射的是数据库里面的varchar public class MyTypeHandler extends BaseTypeHandler { ... } ``` 接着是四个方法的实现，它们涉及到两种操作，一个是如何将我们的Java类型转换为对应的JDBC类型，还有一个就是如何将JDBC类型转换为对应的Java类型。首先是如何将Java转JDBC类型，这里的PreparedStatement我们在JDBC阶段已经讲过，不再赘述： ```java @Override public void setNonNullParameter(PreparedStatement ps, int i, MyString parameter, JdbcType jdbcType) throws SQLException { //这里的i就是PreparedStatement的第几个参数，直接使用setString设置即可 ps.setString(i, parameter.getText()); //按照我们自己的方式把需要插入的值设置进去 } ``` 剩下三个都是JDBC类型和Java类型的转换，只是参数不同而已，我们就简单编写一下： ```java //用于配置如何从ResultSet中读取并转换为我们需要的类型 @Override public MyString getNullableResult(ResultSet rs, String columnName) throws SQLException { String value = rs.getString(columnName); //这里提供的是columnName进行查询 return new MyString(value); } @Override public MyString getNullableResult(ResultSet rs, int columnIndex) throws SQLException { String value = rs.getString(columnIndex); //同上，这里提供的是columnIndex进行查询 return new MyString(value); } @Override public MyString getNullableResult(CallableStatement cs, int columnIndex) throws SQLException { String value = cs.getString(columnIndex); //一般用于存储过程之类的操作，同上 return new MyString(value); } ``` 这样，我们自定义的类型处理器就编写好了，首先我们需要在Mybatis配置文件中注册这个类型处理器： ```xml ``` 接着我们需要在Mapper中配置这里编写好的类型处理器： ```java @Results({ @Result(column = "name", property = "name", typeHandler = MyTypeHandler.class) }) @Select("select * from user where id = #{id}") User selectUserById(int id); ``` ```xml ``` 这样，我们的数据就可以正确进行解析了： ![QQ_1724172380846](https://s2.loli.net/2024/08/21/mhQ7GHsqXwSpD3x.png) 并不是所有情况下类型处理器都需要我们自己来编写，一些框架可能会内置对应的Mybatis类型处理器，比如FastJson、Jackson之类的，我们后续再进行探讨。 ### 动态代理探究（选学）在探究动态代理机制之前，我们要先聊聊什么是代理，代理实际上在我们的设计模式中有介绍。 ![QQ_1724170166302](https://s2.loli.net/2024/08/21/VcSB9vxy2PQIjUA.png) 顾名思义，假如我们种了一大片的西瓜，正值夏天西瓜全部成熟了，现在我们需要将这批西瓜出售掉，但是靠我们自己去出售非常困难，此时我们就需要寻找一些代理商来帮助我们进行出售，它们有自己的销售方式有自己的顾客群体，这样就会简单许多，这便是一种代理的思想。当然，对于顾客来说，无论是找我们的代理商还是我们自己都可以买到西瓜，我们都可以提供一样的服务，只不过代理商肯定会自己抽成，除了进行基本的卖瓜操作外，还有自己的一些操作。那么现在我们来尝试实现一下这样的类结构，首先定义一个接口用于规范行为： ```java public interface Shopper { //卖瓜行为 void saleWatermelon(); } ``` 然后需要实现一下卖瓜行为，也就是我们最基本的西瓜销售行为： ```java public class ShopperImpl implements Shopper{ //卖瓜行为的实现 @Override public void saleWatermelon() { System.out.println("销售一个西瓜给客户，获得摩拉10￥"); } } ``` 最后老板代理后肯定要用自己的方式去出售这些西瓜，成交之后再按照我们告诉老板的价格进行出售： ```java public class ShopperProxy implements Shopper{ //被代理商代理的供应商 private final Shopper impl; public ShopperProxy(Shopper impl) { this.impl = impl; } //代理卖瓜行为 @Override public void saleWatermelon() { impl.saleWatermelon(); System.out.println("代理抽成摩拉8￥"); } } ``` 现在我们就来模拟一下顾客从代理商那买瓜： ```java public class Main { public static void main(String[] args) { Shopper shopper = new ShopperProxy(new ShopperImpl()); shopper.saleWatermelon(); //此时不仅有我们原本的卖瓜行为，代理商还进行了额外的抽成 } } ``` 这样的操作我们称为静态代理，也就是说我们提前知道接口的定义，然后在子类直接进行实现完成的代理，而Mybatis这样的框架在处理我们的这些Mapper接口时，是无法预知内部的具体定义的，这个时候我们就需要用到动态代理。 JDK提供的反射框架就为我们很好地解决了动态代理的问题，它支持在程序运行时动态对某个类或是接口进行代理，提供了一个叫做`InvocationHandler`的接口用于实现，这里我们就对它进行一下介绍，相当于对JavaSE阶段反射的内容的补充： ```java class ShopperProxy implements InvocationHandler { //被代理商代理的对象 Object target; public ShopperProxy(Object target){ this.target = target; } //动态生成对应的代理对象时，当代理对象的方法被调用，就会执行这里的invoke方法 @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Object invoke = method.invoke(target, args); //使用method.invoke()调用被代理对象的方法 System.out.println("销售一个西瓜给客户，代理抽成摩拉8￥"); //添加我们代理商的自定义操作 return invoke; //最后返回原方法得到的返回值 } } ``` 通过实现InvocationHandler来成为一个动态代理，我们发现它提供了一个invoke方法，用于调用被代理对象的方法并完成我们的代理工作，其中提供了一些参数，第一个proxy就是当前的代理实例对象，method就是代理对象被调用的方法名称，args就是方法传入的实际参数。现在就可以通过` Proxy.newProxyInstance`方法来生成一个动态代理类： ```java ShopperImpl target = new ShopperImpl(); Shopper shopper = (Shopper) Proxy.newProxyInstance( target.getClass().getClassLoader(), //直接使用被代理对象的类加载器 target.getClass().getInterfaces(), //这里还需要提供被代理类的接口列表，生成的代理类也会实现这些接口 new ShopperProxy(target) //最后传入我们写好的代理对象 ); shopper.saleWatermelon(); System.out.println(shopper.getClass()); ``` 通过打印类型我们发现，这里通过JDK动态代理生成的类，就是我们之前看到的那种奇怪的类：`class com.sun.proxy.$Proxy0`，因此Mybatis其实也是这样的来实现的。只不过，Mybatis是直接对我们提供的接口进行动态代理，使用方式其实是差不多的，我们可以来试试看，这里我们直接来尝试生成一个我们TestMapper接口的代理类，首先创建一个代理类用于扩展代理操作： ```java public class MapperProxy implements InvocationHandler { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { System.out.println("调用了接口方法: " + method); //一会我们观察一下是不是确实能够检测到 return null; } } ``` 接着我们就可以直接创建一个对Mapper的代理类： ```java TestMapper mapper = (TestMapper) Proxy.newProxyInstance( TestMapper.class.getClassLoader(), new Class[]{ TestMapper.class }, new MapperProxy() ); mapper.selectAllUser(); ``` 最后我们可以去看看Mybatis的源码，实际上它内部就是通过这种方式进行实现的： ```java public class MapperProxy implements InvocationHandler, Serializable { ... @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try { if (Object.class.equals(method.getDeclaringClass())) { return method.invoke(this, args); } //调用内部实现的代理操作实现SQL的执行和结果处理 return cachedInvoker(method).invoke(proxy, method, args, sqlSession); } catch (Throwable t) { throw ExceptionUtil.unwrapThrowable(t); } } } ``` 关于动态代理相关的实现，除了Mybatis用到之外，包括我们后面学习的Spring也会在AOP中使用到，有关更多的内容希望各位小伙伴可以在后续的学习中发现。 ### 自定义拦截器（选学） Mybatis除了面向咱们使用者提供了丰富的API之外，也向一些插件开发者提供了丰富的API，便于他们快速开发针对于Mybatis的插件，比如Mybatis并不支持SQL级别的数据分页操作，但是我们可以通过开发插件的形式实现。 Mybatis为所有的插件提供了一个Interceptor接口，它表示拦截器类，拦截器可以对Mybatis中一些类的任意方法进行动态代理，然后添加我们的自定义操作，支持的类包括： * Executor及其子类，如CacheExecutor等 - 整个Mybatis的执行器，通过调用StatementHandler来操作数据库 * StatementHandler - 操作数据库执行SQL * ParameterHandler - 用于设置SQL的参数 * ResultSetHandler - 用于结果集映射为对象其他的类型虽然也使用Interceptor接口进行动态代理只不过官方没有支持，并不能正常使用。这里我们来进行一下简单的尝试，首先所有的拦截器必须实现自Interceptor接口： ```java public class MyInterceptor implements Interceptor { @Override public Object intercept(Invocation invocation) throws Throwable { System.out.println("测试"); return invocation.proceed(); } } ``` 接着我们需要在类上添加注解用于指示此拦截器可以对哪些类的哪些方法进行动态代理： ```java @Intercepts({}) ``` 假如现在我们要对Executor的query方法进行动态代理，这个方法是Mybatis执行SQL的核心，一般用于查询操作，下一节中我们会进行详细介绍： ```java public interface Executor { ... List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey cacheKey, BoundSql boundSql) throws SQLException; List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException; ``` 我们只需要添加对应的`@Signature`注解即可，在注解中指明需要代理的类型、方法名称、参数列表即可： ```java @Intercepts({ @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}), @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class}), }) ``` 最后我们只需要在配置文件中将这个拦截器以插件的形式注册即可： ```xml ``` 接着就可以看到确实在进行查询的时候执行了我们编写的测试代码： ![QQ_1724393522296](https://s2.loli.net/2024/08/23/dKxCEe39FBYw7Lt.png) 利用这种机制，我们就可以很方便地修改这次查询操作，比如我希望随意篡改我们要查询的用户ID，而这个用户ID实际上是这里被代理方法的第二个参数`parameter`，我们直接修改它的值即可： ```java @Override public Object intercept(Invocation invocation) throws Throwable { Object[] args = invocation.getArgs(); args[1] = 2; //把参数列表的第二个实际参数修改为2 return invocation.proceed(); //再执行原本的操作 } ``` 此时可以看到，虽然我们这里给的是1，但是由于被我们的拦截器进行了修改，导致其变成了2： ![QQ_1724393741215](https://s2.loli.net/2024/08/23/4cTb2klJPQLYwxs.png) 当然，这只是拦截器使用的冰山一角，利用动态代理实际上可以做很多事情，比如对SQL进行分页处理、对查询的数据进行脱敏等，这里我们就不去一一实现了，在后面Spring阶段我们会学习更高级的框架，它们一般都自带这些拦截器。我们再来研究下这玩意怎么实现的吧，首先是从Configuration类开始对所有的拦截器进行注册，内部维护了一个`interceptorChain`对象，用于以链式存放所有的拦截器，因此拦截器的执行也是按照链式有序执行的，然后为支持拦截的类型进行动态代理，这里以`Executor`为例： ```java public Executor newExecutor(Transaction transaction, ExecutorType executorType) { ... return (Executor) interceptorChain.pluginAll(executor); //使用集成所有拦截操作到动态代理中 } ``` 这里`pluginAll`就是将所有拦截器的操作全部添加到动态代理需要执行的操作中： ```java public Object pluginAll(Object target) { for (Interceptor interceptor : interceptors) { target = interceptor.plugin(target); //按顺序依次调用拦截器的plugin方法，并且这里是一个一直将代理嵌套下去的操作，形成链式 } return target; } ``` ```java default Object plugin(Object target) { return Plugin.wrap(target, this); //这里的Plugin就是专门用于拦截器的动态代理实现 } ``` 最后以Plugin为动态代理实现，生成`target`的动态代理对象： ```java public static Object wrap(Object target, Interceptor interceptor) { Map, Set> signatureMap = getSignatureMap(interceptor); Class type = target.getClass(); Class[] interfaces = getAllInterfaces(type, signatureMap); if (interfaces.length > 0) { return Proxy.newProxyInstance(type.getClassLoader(), interfaces, new Plugin(target, interceptor, signatureMap)); } return target; } ``` 最后可以看到在Plugin类中，动态代理的方法会执行拦截器里面的操作： ```java @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { try { Set methods = signatureMap.get(method.getDeclaringClass()); if (methods != null && methods.contains(method)) { //如果拦截操作匹配当前的方法，则直接调用拦截器进行处理 return interceptor.intercept(new Invocation(target, method, args)); } return method.invoke(target, args); //如果不匹配，调用原方法 } catch (Exception e) { throw ExceptionUtil.unwrapThrowable(e); } } ``` 支持，有关拦截器相关的使用和原理讲解就到这里。 ### 自定义缓存（选学）前面我们讲解了Mybatis的缓存机制，每一个会话都有一个本地缓存（一级缓存），我们也可以开启针对于整个Mapper的二级缓存，但是我们提到它可能会存在多个程序同时进行修改的问题，这时要解决问题只能由我们自己来处理二级缓存的操作了。这一节我们就来看看如何自定义缓存。在开始之前，我们需要先了解Mybatis内部的缓存机制是如何实现的，在Mybatis中存在一个Cache接口，它定义了缓存相关的操作： ```java public interface Cache { String getId(); //给一个key和目标对象，将对象缓存 void putObject(Object key, Object value); //从缓存中根据key取出对象 Object getObject(Object key); //根据key移除缓存中的对象 Object removeObject(Object key); //清空缓存 void clear(); //获取大小 int getSize(); ... } ``` 缓存接口的实现类非常多，但是简单的实现类只有一个，叫做`PerpetualCache`，它是纯粹的Cache实现类，内部通过一个Map来实现各种缓存功能，其他所有的Cache实现类全部是基于装饰模式编写的扩展操作，均存放在`decorators`中： ![QQ_1724321629027](https://s2.loli.net/2024/08/22/vxU65KXoqtFROgz.png) 在我们不启用二级缓存的情况下，默认一级缓存使用一个`PerpetualCache`来进行缓存操作。我们可以为PerpetualCache打上断点，接着就可以看到在Mybatis内部执行`query`的时候对一级缓存进行了判断： ```java //这里的MappedStatement参数包含了我们Mapper中定义的信息，包括方法、SQL、还有各种配置等，CacheKey是由Mybatis生成的一个用于作为缓存Key的对象，由SQL操作的基本信息组成 public List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId()); if (closed) { //首先判断当前执行器是否被关闭，都关闭了那还说个毛，执行器每个SqlSession都有一个 throw new ExecutorException("Executor was closed."); } if (queryStack == 0 && ms.isFlushCacheRequired()) { clearLocalCache(); //判断如果配置了flushCache则会直接清除一级缓存 } List list; //查询的结果 try { queryStack++; //queryStack是为了防止使用Interceptor的情况下，防止递归操作，因此进行的计数，实际上这个方法里面很多地方都进行了判断，来确保递归状态下只有最外层正常 //这里首先从缓存中进行了一次查询，localCache默认是PerpetualCache list = resultHandler == null ? (List) localCache.getObject(key) : null; if (list != null) { //如果缓存中存在，则直接结束 //这里是针对存储过程进行的参数缓存，可以无视掉 handleLocallyCachedOutputParameters(ms, key, parameter, boundSql); } else { //缓存没有的话就从数据库里面进行查询了，注意这里就有可能出现我们上面说的Interceptor拦截，因为要从数据库查询 list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql); } } finally { queryStack--; //执行完成后queryStack自减 } if (queryStack == 0) { for (DeferredLoad deferredLoad : deferredLoads) { deferredLoad.load(); } deferredLoads.clear(); //这里很关键，如果localCacheScope配置项的值为STATEMENT，那么这里会直接清除一级缓存 if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) { clearLocalCache(); } } return list; } ``` 这里的流程非常清晰，首先进行最基本的判断，保证可以正常使用，然后进行`flushCache`选项判断，如果是则直接清除缓存，接着就是从缓存中查询是否存在对应的结果，如果没有就去查数据库，最后直接返回得到的结果。只不过在最后有一个非常有意思的操作，如果如果localCacheScope配置项的值为STATEMENT，那么会直接清除一级缓存，我们可以直接在配置文件中试试看： ```xml ``` 接着执行两次相同的查询： ![QQ_1724346245081](https://s2.loli.net/2024/08/23/Fl1ERuDUgoKr8dP.png) 可以看到，此时缓存竟然真的失效了，也就是说虽然Mybatis不允许我们关闭一级缓存，但是只要我们将`localCacheScope`属性的值设置为`STATEMENT`，那么一级缓存的作用域将被严格限制在一次Statement内，也就是一次query内，在正常情况下，其最终效果约等于关闭一级缓存，其已经不具备在多个操作间共享的能力了。但是这里并不能完全认为是一级缓存关闭了，如果出现我们前面说的Interceptor嵌套查询的情况或是执行某个存储过程的情况下，由于还没来得及清理，实际上这里的一级缓存还是有机会使用的，因此，一级缓存依然是无法彻底关闭的。我们可以进一步研究一下`queryFromDatabase`数据库查询操作： ```java private List queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { List list; localCache.putObject(key, EXECUTION_PLACEHOLDER); //添加占位符，用于处理延迟加载相关问题 try { //执行真正的查询 list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql); } finally { localCache.removeObject(key); } localCache.putObject(key, list); //最后会将查询结果放到缓存中 if (ms.getStatementType() == StatementType.CALLABLE) { //单独处理存储过程，跟上面一样的 localOutputParameterCache.putObject(key, parameter); } return list; //最后返回 } ``` 这样，整个一级缓存就形成了一个完整的闭环。但是注意，就一级缓存的设计上来说，这里使用的是普通的Map类型进行存储，那必然是存在一定的并发问题的，因此，同一个SqlSession并不适用于多线程环境下使用，最好是一个线程配一个单独的SqlSession对象。我们接着来看二级缓存，二级缓存相比一级缓存就复杂很多了，它在我们上面的一级缓存代码的外层，我们可以在Mapper上开启二级缓存之后，直接断点看源码： ```java public List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException { Cache cache = ms.getCache(); //如果开启了二级缓存，MappedStatement会存在一个Cache对象 if (cache != null) { flushCacheIfRequired(ms); //首先和一级缓存一样，依然是先判断一次flushCache配置 if (ms.isUseCache() && resultHandler == null) { //单独判断一次当前的Statement是否配置了useCache选择，如果为false则依然不走二级缓存 ensureNoOutParams(ms, boundSql); //处理存储过程部分操作，无视掉 @SuppressWarnings("unchecked") //从tcm中读取缓存数据，这里的tcm就是TransactionalCacheManager，由于二级缓存是事务性质的，有一个专门的缓存管理器来进行操作，对二级缓存相关操作进行封装 List list = (List) tcm.getObject(cache, key); if (list == null) { //当二级缓存没有查询到数据时，直接走一级缓存，和最后一行代码一样 list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); tcm.putObject(cache, key, list); //从一级缓存或是数据库查询到数据之后，放入二级缓存 } return list; //返回最终结果 } } //这里的delegate实际上是装饰模式的被装饰对象，同样为Executor，也就是我们之前的一级缓存SimpleExecutor return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql); } ``` 可以看到，二级缓存相比一级缓存来说，最大的区别就是使用了TransactionalCacheManager来进行缓存管理，那么我们又来研究一下它与我们直接使用PerpetualCache有什么区别，直接上源码： ```java //事务缓存管理器用于管理所有Mapper的二级缓存 public class TransactionalCacheManager { //存储所有Mapper的二级缓存对象 private final Map transactionalCaches = new HashMap<>(); ... public Object getObject(Cache cache, CacheKey key) { //直接获取map里面的缓存对象，然后进行操作 return getTransactionalCache(cache).getObject(key); } public void putObject(Cache cache, CacheKey key, Object value) { getTransactionalCache(cache).putObject(key, value); //同上 } ... private TransactionalCache getTransactionalCache(Cache cache) { //这里用于判断是否存在对应的缓存，如果是第一次则直接创建一个新的TransactionalCache放入map的并返回 //注意这里构造TransactionalCache时候使用的是一个Lamdba，实际调用的是TransactionalCache(Cache delegate)构造方法，把外面传入的cache对象存入到内部 return MapUtil.computeIfAbsent(transactionalCaches, cache, TransactionalCache::new); } } ``` 这里用于存储缓存对象的map比较奇怪，它的键是Cache类型，也就是我们在XML里面配置的二级缓存类型，接着是一个TransactionalCache对象，实际上这个对象是对我们传入Cache的一个修饰，我们来看看它的内部构造： ```java public class TransactionalCache implements Cache { private final Cache delegate; //被修饰的内部Cache对象 private final Map entriesToAddOnCommit; //暂存列表，因为二级缓存需要提交才能真正进入缓存，所以说没提交之前需要找个地方暂存 private final Set

Mybatis快速上手