Mybatis系列第9篇：延迟加载、鉴别器、继承怎么玩？

Mybatis系列目标：从入门开始开始掌握一个高级开发所需要的Mybatis技能。

这是mybatis系列第9篇，源码位于文章尾部！

建库建表

创建一个db:javacode2018

4张表:

t_user(用户表)

t_goods(商品表)

t_order(订单表)

t_order_detail(订单明细表)

表之间的关系：

t_order和t_user是一对一的关系，一条订单关联一个用户记录

t_order和t_order_detail是一对多关系，每个订单中可能包含多个子订单，每个子订单对应一个商品

  1. DROP DATABASE IF EXISTS `javacode2018`;
  2. CREATE DATABASE `javacode2018`;
  3.  
  4. USE `javacode2018`;
  5.  
  6. DROP TABLE IF EXISTS t_user;
  7. CREATE TABLE t_user(
  8.   id int AUTO_INCREMENT PRIMARY KEY COMMENT '用户id',
  9.   name VARCHAR(32) NOT NULL DEFAULT '' COMMENT '用户名'
  10. ) COMMENT '用户表';
  11. INSERT INTO t_user VALUES (1,'张学友'),(2,'路人甲Java');
  12.  
  13. DROP TABLE IF EXISTS t_goods;
  14. CREATE TABLE t_goods(
  15.   id int AUTO_INCREMENT PRIMARY KEY COMMENT '商品id',
  16.   name VARCHAR(32) NOT NULL DEFAULT '' COMMENT '商品名称',
  17.   price DECIMAL(10,2) NOT NULL DEFAULT 0 COMMENT '商品价格'
  18. ) COMMENT '商品信息表';
  19. INSERT INTO t_goods VALUES (1,'Mybatis系列',8.88),(2,'maven高手系列',16.66);
  20.  
  21. DROP TABLE IF EXISTS t_order;
  22. CREATE TABLE t_order(
  23.   id int AUTO_INCREMENT PRIMARY KEY COMMENT '订单id',
  24.   user_id INT NOT NULL DEFAULT 0 COMMENT '用户id，来源于t_user.id',
  25.   create_time BIGINT NOT NULL DEFAULT 0 COMMENT '订单创建时间(时间戳，秒)',
  26.   up_time BIGINT NOT NULL DEFAULT 0 COMMENT '订单最后修改时间(时间戳，秒)'
  27. ) COMMENT '订单表';
  28. INSERT INTO t_order VALUES (1,2,unix_timestamp(now()),unix_timestamp(now())),(2,1,unix_timestamp(now()),unix_timestamp(now())),(3,1,unix_timestamp(now()),unix_timestamp(now()));
  29.  
  30. DROP TABLE IF EXISTS t_order_detail;
  31. CREATE TABLE t_order_detail(
  32.   id int AUTO_INCREMENT PRIMARY KEY COMMENT '订单明细id',
  33.   order_id INT NOT NULL DEFAULT 0 COMMENT '订单id，来源于t_order.id',
  34.   goods_id INT NOT NULL DEFAULT 0 COMMENT '商品id，来源于t_goods.id',
  35.   num INT NOT NULL DEFAULT 0 COMMENT '商品数量',
  36.   total_price DECIMAL(12,2) NOT NULL DEFAULT 0 COMMENT '商品总金额'
  37. ) COMMENT '订单表';
  38. INSERT INTO t_order_detail VALUES (1,1,1,2,17.76),(2,1,1,1,16.66),(3,2,1,1,8.88),(4,3,1,1,8.88);
  39.  
  40. select * from t_user;
  41. select * from t_goods;
  42. select * from t_order;
  43. select * from t_order_detail;

延迟加载

延迟加载其实就是将数据加载时机推迟，比如推迟嵌套查询的执行时机，在mybatis中经常用到关联查询，但是并不是任何时候都需要立即返回关联查询结果。比如查询订单信息，并不一定需要及时返回订单对应的用户信息或者订单详情信息等，这种情况需要一种机制，当需要查看关联的数据时，再去执行对应的查询，返回需要的结果，这种需求在mybatis中可以使用延迟加载机制来实现。

延迟加载2种设置方式

  1. 全局配置的方式

  2. sqlmap中配置的方式

方式1中会对所有关联查询起效，而方式2只会对相关设置的查询起效。

全局配置延迟加载

mybatis配置文件中通过下面两个属性来控制延迟加载：

  1. <settings>
  2.     <!--打开延迟加载的开关  -->
  3.     <setting name="lazyLoadingEnabled" value="true"/>
  4.     <!-- 当为true的时候，调用任意延迟属性，会去加载所有延迟属性，如果为false，则调用某个属性的时候，只会加载指定的属性 -->
  5.     <setting name="aggressiveLazyLoading" value="false"/>
  6. </settings>

lazyLoadingEnabled：这个属性比较好理解，是否开启延迟加载，默认为false，如果需要开启延迟加载，将其设置为true

aggressiveLazyLoading：当为true的时候，调用任意延迟属性，会去加载所有延迟属性，如果为false，则调用某个属性的时候，只会加载指定的属性

下面我们来个案例感受一下效果。

需求

通过订单id查询订单信息、订单用户信息、订单明细列表，而订单用户信息、订单明细列表采用延迟加载的方式获取。

mybatis配置

  1. <settings>
  2.     <!--打开延迟加载的开关  -->
  3.     <setting name="lazyLoadingEnabled" value="true"/>
  4.     <!-- 当为true的时候，调用任意延迟属性，会去加载所有延迟属性，如果为false，则调用某个属性的时候，只会加载指定的属性 -->
  5.     <setting name="aggressiveLazyLoading" value="true"/>
  6. </settings>

OrderMapper.xml

  1. <resultMap id="orderModelMap1" type="com.javacode2018.chat05.demo5.model.OrderModel">
  2.     <id column="id" property="id"/>
  3.     <result column="user_id" property="userId"/>
  4.     <result column="create_time" property="createTime"/>
  5.     <result column="up_time" property="upTime"/>
  6.     <!--  通过订单中user_id作为条件，查询下单人信息 -->
  7.     <association property="userModel" select="com.javacode2018.chat05.demo5.mapper.UserMapper.getById1" column="user_Id"/>
  8.     <!--  通过订单id作为条件，查询详情列表 -->
  9.     <collection property="orderDetailModelList" select="com.javacode2018.chat05.demo5.mapper.OrderDetailMapper.getListByOrderId1" column="id"/>
  10. </resultMap>
  11.  
  12. <select id="getById1" resultMap="orderModelMap1">
  13.     <![CDATA[
  14.     SELECT
  15.         a.id ,
  16.         a.user_id,
  17.         a.create_time,
  18.         a.up_time
  19.     FROM
  20.         t_order a
  21.     WHERE
  22.         a.id = #{value}
  23.     ]]>
  24. </select>

上面的orderModelMap1元素下面有两个关联查询，我们也写一下。

UserMapper.xml

  1. <!-- 根据用户id查询用户信息 -->
  2. <select id="getById1" resultType="com.javacode2018.chat05.demo5.model.UserModel">
  3.     <![CDATA[
  4.     SELECT id,name FROM t_user where id = #{user_id}
  5.     ]]>
  6. </select>

OrderDetailMapper.xml

  1. <!-- 根据订单di查询订单明细列表 -->
  2. <select id="getListByOrderId1" resultType="com.javacode2018.chat05.demo5.model.OrderDetailModel">
  3.     <![CDATA[
  4.     SELECT
  5.         a.id,
  6.         a.order_id AS orderId,
  7.         a.goods_id AS goodsId,
  8.         a.num,
  9.         a.total_price AS totalPrice
  10.     FROM
  11.         t_order_detail a
  12.     WHERE
  13.         a.order_id = #{order_id}
  14.     ]]>
  15. </select>

对应的3个Model

  1. @Getter
  2. @Setter
  3. @Builder
  4. @ToString
  5. @NoArgsConstructor
  6. @AllArgsConstructor
  7. public class OrderModel {
  8.     private Integer id;
  9.     private Integer userId;
  10.     private Long createTime;
  11.     private Long upTime;
  12.     private UserModel userModel;
  13.     //订单详情列表
  14.     private List<OrderDetailModel> orderDetailModelList;
  15. }
  16.  
  17. @Getter
  18. @Setter
  19. @Builder
  20. @ToString
  21. @NoArgsConstructor
  22. @AllArgsConstructor
  23. public class UserModel {
  24.     private Integer id;
  25.     private String name;
  26. }
  27.  
  28. @Getter
  29. @Setter
  30. @Builder
  31. @ToString
  32. @NoArgsConstructor
  33. @AllArgsConstructor
  34. public class OrderDetailModel {
  35.     private Integer id;
  36.     private Integer orderId;
  37.     private Integer goodsId;
  38.     private Integer num;
  39.     private Double totalPrice;
  40. }

测试用例

  1. com.javacode2018.chat05.demo5.Demo5Test#getById1
  2.  
  3. @Test
  4. public void getById1() throws IOException {
  5.     //指定mybatis全局配置文件
  6.     mybatisConfig = "demo5/mybatis-config.xml";
  7.     this.before();
  8.     OrderModel orderModel = null;
  9.     try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  10.         OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);
  11.         orderModel = mapper.getById1(1);
  12.     }
  13.     log.info("-------分割线--------");
  14.     log.info("{}", orderModel.getUserModel());
  15. }

运行输出

  1. 01:55.343 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById1 - ==>  Preparing: SELECT a.id , a.user_id, a.create_time, a.up_time FROM t_order a WHERE a.id = ? 
  2. 01:55.372 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById1 - ==> Parameters: 1(Integer)
  3. 01:55.431 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById1 - <==      Total: 1
  4. 01:55.431 [main] INFO  c.j.chat05.demo5.Demo5Test - -------分割线--------
  5. 01:55.432 [main] DEBUG c.j.c.d.m.O.getListByOrderId1 - ==>  Preparing: SELECT a.id, a.order_id AS orderId, a.goods_id AS goodsId, a.num, a.total_price AS totalPrice FROM t_order_detail a WHERE a.order_id = ? 
  6. 01:55.432 [main] DEBUG c.j.c.d.m.O.getListByOrderId1 - ==> Parameters: 1(Integer)
  7. 01:55.435 [main] DEBUG c.j.c.d.m.O.getListByOrderId1 - <==      Total: 2
  8. 01:55.439 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - ==>  Preparing: SELECT id,name FROM t_user where id = ? 
  9. 01:55.439 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - ==> Parameters: 2(Integer)
  10. 01:55.441 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - <==      Total: 1
  11. 01:55.441 [main] INFO  c.j.chat05.demo5.Demo5Test - UserModel(id=2, name=路人甲Java)

从日志中可以看出，总共有3次查询，后面2次查询在分割线之后出现的，说明是调用了orderModel.getUserModel()触发后面2次查询动作。

代码中我们调用的是获取用户信息，而订单列表信息也被加载了，这个主要是由于aggressiveLazyLoading被设置为true了，当使用到一个延迟加载的属性时，其他的延迟加载的属性也会被一起加载，所以触发了2个关联的查询。

下面我们看看将aggressiveLazyLoading设置为false的效果

  1. <settings>
  2.     <!--打开延迟加载的开关  -->
  3.     <setting name="lazyLoadingEnabled" value="true"/>
  4.     <!-- 当为true的时候，调用任意延迟属性，会去加载所有延迟属性，如果为false，则调用某个属性的时候，只会加载指定的属性 -->
  5.     <setting name="aggressiveLazyLoading" value="false"/>
  6. </settings>

再次运行测试用例输出

  1. 12:19.236 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById1 - ==>  Preparing: SELECT a.id , a.user_id, a.create_time, a.up_time FROM t_order a WHERE a.id = ? 
  2. 12:19.268 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById1 - ==> Parameters: 1(Integer)
  3. 12:19.336 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById1 - <==      Total: 1
  4. 12:19.337 [main] INFO  c.j.chat05.demo5.Demo5Test - -------分割线--------
  5. 12:19.338 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - ==>  Preparing: SELECT id,name FROM t_user where id = ? 
  6. 12:19.338 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - ==> Parameters: 2(Integer)
  7. 12:19.340 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - <==      Total: 1
  8. 12:19.341 [main] INFO  c.j.chat05.demo5.Demo5Test - UserModel(id=2, name=路人甲Java)

sqlmap中设置延迟加载

全局的方式会对所有的关联查询起效，影响范围比较大，mybatis也提供了在关联查询中进行设置的方式，只会对当前设置的关联查询起效。

关联查询，一般我们使用association、collection，这两个元素都有个属性fetchType，通过这个属性可以指定关联查询的加载方式。

fetchType值有2种，eager：立即加载；lazy：延迟加载。

下面我们来实现一个需求：还是通过订单id查询订单信息，并获取关联的用户信息、订单详细列表，用户信息我们要求立即加载，而订单详情我们要求延迟加载。

mapper xml如下

  1. <resultMap id="orderModelMap2" type="com.javacode2018.chat05.demo5.model.OrderModel">
  2.     <id column="id" property="id"/>
  3.     <result column="user_id" property="userId"/>
  4.     <result column="create_time" property="createTime"/>
  5.     <result column="up_time" property="upTime"/>
  6.     <!--  通过订单中user_id作为条件，查询下单人信息 -->
  7.     <association property="userModel" fetchType="eager" select="com.javacode2018.chat05.demo5.mapper.UserMapper.getById1" column="user_Id"/>
  8.     <!--  通过订单id作为条件，查询详情列表 -->
  9.     <collection property="orderDetailModelList" fetchType="lazy" select="com.javacode2018.chat05.demo5.mapper.OrderDetailMapper.getListByOrderId1" column="id"/>
  10. </resultMap>
  11.  
  12. <select id="getById2" resultMap="orderModelMap2">
  13.     <![CDATA[
  14.     SELECT
  15.         a.id ,
  16.         a.user_id,
  17.         a.create_time,
  18.         a.up_time
  19.     FROM
  20.         t_order a
  21.     WHERE
  22.         a.id = #{value}
  23.     ]]>
  24. </select>

重点注意上面配置中association、collection这2个元素的fetchType属性，eager表示立即加载，lazy表示延迟加载。

测试用例

  1. com.javacode2018.chat05.demo5.Demo5Test#getById2
  2.  
  3. @Test
  4. public void getById2() throws IOException {
  5.     //指定mybatis全局配置文件
  6.     mybatisConfig = "demo5/mybatis-config2.xml";
  7.     this.before();
  8.     OrderModel orderModel = null;
  9.     try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  10.         OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);
  11.         orderModel = mapper.getById2(1);
  12.     }
  13.     log.info("-------分割线--------");
  14.     log.info("{}", orderModel.getOrderDetailModelList());
  15. }

运行输出

  1. 36:54.284 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById2 - ==>  Preparing: SELECT a.id , a.user_id, a.create_time, a.up_time FROM t_order a WHERE a.id = ? 
  2. 36:54.321 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById2 - ==> Parameters: 1(Integer)
  3. 36:54.385 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - ====>  Preparing: SELECT id,name FROM t_user where id = ? 
  4. 36:54.385 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - ====> Parameters: 2(Integer)
  5. 36:54.387 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - <====      Total: 1
  6. 36:54.389 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById2 - <==      Total: 1
  7. 36:54.390 [main] INFO  c.j.chat05.demo5.Demo5Test - -------分割线--------
  8. 36:54.392 [main] DEBUG c.j.c.d.m.O.getListByOrderId1 - ==>  Preparing: SELECT a.id, a.order_id AS orderId, a.goods_id AS goodsId, a.num, a.total_price AS totalPrice FROM t_order_detail a WHERE a.order_id = ? 
  9. 36:54.392 [main] DEBUG c.j.c.d.m.O.getListByOrderId1 - ==> Parameters: 1(Integer)
  10. 36:54.397 [main] DEBUG c.j.c.d.m.O.getListByOrderId1 - <==      Total: 2
  11. 36:54.398 [main] INFO  c.j.chat05.demo5.Demo5Test - [OrderDetailModel(id=1, orderId=1, goodsId=1, num=2, totalPrice=17.76), OrderDetailModel(id=2, orderId=1, goodsId=1, num=1, totalPrice=16.66)]

注意输出中的分割线，可以分析得出，用户信息是和订单信息一起立即查出来的，而订单详情，是在我们调用orderModel.getOrderDetailModelList()获取订单列表的时候，采取懒加载的。

鉴别器(discriminator)

有时候，一个数据库查询可能会返回多个不同的结果集（但总体上还是有一定的联系的）， 鉴别器（discriminator）元素就是被设计来应对这种情况的，鉴别器的概念很好理解——它很像 Java 语言中的 switch 语句。

discriminator标签常用的两个属性如下：

  • column：该属性用于设置要进行鉴别比较值的列。

  • javaType：该属性用于指定列的类型，保证使用相同的java类型来比较值。

discriminator标签可以有1个或多个case标签，case标签有一个比较重要的属性：

  • value：该值为discriminator指定column用来匹配的值，当匹配的时候，结果会走这个case关联的映射。

我们使用鉴别器实现一个功能：通过订单id查询订单信息，当传入的订单id为1的时候，获取订单信息及下单人信息；当传入的订单id为2的时候，获取订单信息、下单人信息、订单明细信息；其他情况默认只查询订单信息。

OrderMapper.xml

  1. <resultMap id="orderModelMap1" type="com.javacode2018.chat05.demo6.model.OrderModel">
  2.     <id column="id" property="id"/>
  3.     <result column="user_id" property="userId"/>
  4.     <result column="create_time" property="createTime"/>
  5.     <result column="up_time" property="upTime"/>
  6.     <!-- 鉴别器 -->
  7.     <discriminator javaType="int" column="id">
  8.         <case value="1">
  9.             <!--通过用户id查询用户信息-->
  10.             <association property="userModel" select="com.javacode2018.chat05.demo6.mapper.UserMapper.getById1" column="user_Id"/>
  11.         </case>
  12.         <case value="2">
  13.             <!--通过用户id查询用户信息-->
  14.             <association property="userModel" select="com.javacode2018.chat05.demo6.mapper.UserMapper.getById1" column="user_Id"/>
  15.             <!--通过订单id查询订单列表-->
  16.             <collection property="orderDetailModelList" select="com.javacode2018.chat05.demo6.mapper.OrderDetailMapper.getListByOrderId1" column="id"/>
  17.         </case>
  18.     </discriminator>
  19. </resultMap>
  20.  
  21. <select id="getById1" resultMap="orderModelMap1">
  22.     <![CDATA[
  23.     SELECT
  24.         a.id ,
  25.         a.user_id,
  26.         a.create_time,
  27.         a.up_time
  28.     FROM
  29.         t_order a
  30.     WHERE
  31.         a.id = #{value}
  32.     ]]>
  33. </select>

注意上面的discriminator，这部分是关键，discriminator内部的case会和每行查询结果中的id字段进行匹配，匹配成功了case内部的关联查询会被执行，未匹配上的，只会走discriminator外部默认配置的映射映射规则。

UserMapper.xml

  1. <!-- 通过用户id查询用户信息 -->
  2. <select id="getById1" resultType="com.javacode2018.chat05.demo6.model.UserModel">
  3.     <![CDATA[
  4.     SELECT id,name FROM t_user where id = #{user_id}
  5.     ]]>
  6. </select>

OrderDetailMapper.xml

  1. <!-- 通过订单id查询订单明细列表 -->
  2. <select id="getListByOrderId1" resultType="com.javacode2018.chat05.demo6.model.OrderDetailModel">
  3.     <![CDATA[
  4.     SELECT
  5.         a.id,
  6.         a.order_id AS orderId,
  7.         a.goods_id AS goodsId,
  8.         a.num,
  9.         a.total_price AS totalPrice
  10.     FROM
  11.         t_order_detail a
  12.     WHERE
  13.         a.order_id = #{order_id}
  14.     ]]>
  15. </select>

对应的3个Model类

  1. @Getter
  2. @Setter
  3. @Builder
  4. @ToString
  5. @NoArgsConstructor
  6. @AllArgsConstructor
  7. public class OrderModel {
  8.     private Integer id;
  9.     private Integer userId;
  10.     private Long createTime;
  11.     private Long upTime;
  12.     //用户信息
  13.     private UserModel userModel;
  14.     //订单详情列表
  15.     private List<OrderDetailModel> orderDetailModelList;
  16. }
  17.  
  18.  
  19. @Getter
  20. @Setter
  21. @Builder
  22. @ToString
  23. @NoArgsConstructor
  24. @AllArgsConstructor
  25. public class UserModel {
  26.     private Integer id;
  27.     private String name;
  28. }
  29.  
  30. @Getter
  31. @Setter
  32. @Builder
  33. @ToString
  34. @NoArgsConstructor
  35. @AllArgsConstructor
  36. public class OrderDetailModel {
  37.     private Integer id;
  38.     private Integer orderId;
  39.     private Integer goodsId;
  40.     private Integer num;
  41.     private Double totalPrice;
  42. }

测试用例

  1. com.javacode2018.chat05.demo6.Demo6Test#getById1
  2.  
  3. @Test
  4. public void getById1() throws IOException {
  5.     try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  6.         OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);
  7.         //查询订单为1的
  8.         OrderModel orderModel = mapper.getById1(1);
  9.         log.info("{}", orderModel);
  10.         log.info("------------------------------------------------------------");
  11.         //查询订单为2的
  12.         orderModel = mapper.getById1(2);
  13.         log.info("{}", orderModel);
  14.         log.info("------------------------------------------------------------");
  15.         //查询订单为3的
  16.         orderModel = mapper.getById1(3);
  17.         log.info("{}", orderModel);
  18.     }
  19. }

运行输出

  1. 58:16.413 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById1 - ==>  Preparing: SELECT a.id , a.user_id, a.create_time, a.up_time FROM t_order a WHERE a.id = ? 
  2. 58:16.457 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById1 - ==> Parameters: 1(Integer)
  3. 58:16.481 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - ====>  Preparing: SELECT id,name FROM t_user where id = ? 
  4. 58:16.481 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - ====> Parameters: 2(Integer)
  5. 58:16.488 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - <====      Total: 1
  6. 58:16.489 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById1 - <==      Total: 1
  7. 58:16.489 [main] INFO  c.j.chat05.demo6.Demo6Test - OrderModel(id=1, userId=2, createTime=1578368161, upTime=1578368161, userModel=UserModel(id=2, name=路人甲Java), orderDetailModelList=null)
  8. 58:16.491 [main] INFO  c.j.chat05.demo6.Demo6Test - ------------------------------------------------------------
  9. 58:16.491 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById1 - ==>  Preparing: SELECT a.id , a.user_id, a.create_time, a.up_time FROM t_order a WHERE a.id = ? 
  10. 58:16.492 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById1 - ==> Parameters: 2(Integer)
  11. 58:16.493 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - ====>  Preparing: SELECT id,name FROM t_user where id = ? 
  12. 58:16.493 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - ====> Parameters: 1(Integer)
  13. 58:16.494 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - <====      Total: 1
  14. 58:16.495 [main] DEBUG c.j.c.d.m.O.getListByOrderId1 - ====>  Preparing: SELECT a.id, a.order_id AS orderId, a.goods_id AS goodsId, a.num, a.total_price AS totalPrice FROM t_order_detail a WHERE a.order_id = ? 
  15. 58:16.495 [main] DEBUG c.j.c.d.m.O.getListByOrderId1 - ====> Parameters: 2(Integer)
  16. 58:16.505 [main] DEBUG c.j.c.d.m.O.getListByOrderId1 - <====      Total: 1
  17. 58:16.505 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById1 - <==      Total: 1
  18. 58:16.506 [main] INFO  c.j.chat05.demo6.Demo6Test - OrderModel(id=2, userId=1, createTime=1578368161, upTime=1578368161, userModel=UserModel(id=1, name=张学友), orderDetailModelList=[OrderDetailModel(id=3, orderId=2, goodsId=1, num=1, totalPrice=8.88)])
  19. 58:16.506 [main] INFO  c.j.chat05.demo6.Demo6Test - ------------------------------------------------------------
  20. 58:16.506 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById1 - ==>  Preparing: SELECT a.id , a.user_id, a.create_time, a.up_time FROM t_order a WHERE a.id = ? 
  21. 58:16.506 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById1 - ==> Parameters: 3(Integer)
  22. 58:16.508 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById1 - <==      Total: 1
  23. 58:16.509 [main] INFO  c.j.chat05.demo6.Demo6Test - OrderModel(id=3, userId=1, createTime=1578368161, upTime=1578368161, userModel=null, orderDetailModelList=null)

输出中可以看出，订单1查询了2次，订单2查询了3次，订单3查询了1次；鉴别器算是一个不错的功能。

继承(extends)

继承在java是三大特性之一，可以起到重用代码的作用，而mybatis也有继承的功能，和java中的继承的作用类似，主要在resultMap中使用，可以重用其他resultMap中配置的映射关系。

用法

<resultMap extends="被继承的resultMap的id"></resultMap>

案例

下面我们使用继承来对上面的鉴别器的案例改造一下，优化一下代码

OrderMapper.xml
  1. <resultMap id="orderModelMap2" type="com.javacode2018.chat05.demo6.model.OrderModel">
  2.     <id column="id" property="id"/>
  3.     <result column="user_id" property="userId"/>
  4.     <result column="create_time" property="createTime"/>
  5.     <result column="up_time" property="upTime"/>
  6.     <!-- 鉴别器 -->
  7.     <discriminator javaType="int" column="id">
  8.         <case value="1" resultMap="orderModelMap3" />
  9.         <case value="2" resultMap="orderModelMap4" />
  10.     </discriminator>
  11. </resultMap>
  12.  
  13. <resultMap id="orderModelMap3" type="com.javacode2018.chat05.demo6.model.OrderModel" extends="orderModelMap2">
  14.     <!--通过用户id查询用户信息-->
  15.     <association property="userModel" select="com.javacode2018.chat05.demo6.mapper.UserMapper.getById1" column="user_Id"/>
  16. </resultMap>
  17.  
  18. <resultMap id="orderModelMap4" type="com.javacode2018.chat05.demo6.model.OrderModel" extends="orderModelMap3">
  19.     <!--通过订单id查询订单列表-->
  20.     <collection property="orderDetailModelList" select="com.javacode2018.chat05.demo6.mapper.OrderDetailMapper.getListByOrderId1" column="id"/>
  21. </resultMap>
  22.  
  23. <select id="getById2" resultMap="orderModelMap2">
  24.     <![CDATA[
  25.     SELECT
  26.         a.id ,
  27.         a.user_id,
  28.         a.create_time,
  29.         a.up_time
  30.     FROM
  31.         t_order a
  32.     WHERE
  33.         a.id = #{value}
  34.     ]]>
  35. </select>

重点在于上面两个extends属性，上面orderModelMap3继承了orderModelMap2中配置的映射关系（除鉴别器之外），自己又加入了一个association去查询用户信息；orderModelMap4继承了orderModelMap3，自己又加入了一个查询订单列表的collection元素。上面使用extends做到了代码重用，其实和下面这块代码写法效果一样：

  1. <resultMap id="orderModelMap2" type="com.javacode2018.chat05.demo6.model.OrderModel">
  2.     <id column="id" property="id"/>
  3.     <result column="user_id" property="userId"/>
  4.     <result column="create_time" property="createTime"/>
  5.     <result column="up_time" property="upTime"/>
  6.     <!-- 鉴别器 -->
  7.     <discriminator javaType="int" column="id">
  8.         <case value="1" resultMap="orderModelMap3" />
  9.         <case value="2" resultMap="orderModelMap4" />
  10.     </discriminator>
  11. </resultMap>
  12.  
  13. <resultMap id="orderModelMap3" type="com.javacode2018.chat05.demo6.model.OrderModel">
  14.     <id column="id" property="id"/>
  15.     <result column="user_id" property="userId"/>
  16.     <result column="create_time" property="createTime"/>
  17.     <result column="up_time" property="upTime"/>
  18.     <!--通过用户id查询用户信息-->
  19.     <association property="userModel" select="com.javacode2018.chat05.demo6.mapper.UserMapper.getById1" column="user_Id"/>
  20. </resultMap>
  21.  
  22. <resultMap id="orderModelMap4" type="com.javacode2018.chat05.demo6.model.OrderModel">
  23.     <id column="id" property="id"/>
  24.     <result column="user_id" property="userId"/>
  25.     <result column="create_time" property="createTime"/>
  26.     <result column="up_time" property="upTime"/>
  27.     <!--通过用户id查询用户信息-->
  28.     <association property="userModel" select="com.javacode2018.chat05.demo6.mapper.UserMapper.getById1" column="user_Id"/>
  29.     <!--通过订单id查询订单列表-->
  30.     <collection property="orderDetailModelList" select="com.javacode2018.chat05.demo6.mapper.OrderDetailMapper.getListByOrderId1" column="id"/>
  31. </resultMap>
  32.  
  33. <select id="getById2" resultMap="orderModelMap2">
  34.     <![CDATA[
  35.     SELECT
  36.         a.id ,
  37.         a.user_id,
  38.         a.create_time,
  39.         a.up_time
  40.     FROM
  41.         t_order a
  42.     WHERE
  43.         a.id = #{value}
  44.     ]]>
  45. </select>
测试用例
  1. com.javacode2018.chat05.demo6.Demo6Test#getById2
  2.  
  3. @Test
  4. public void getById2() throws IOException {
  5.     try (SqlSession sqlSession = this.sqlSessionFactory.openSession(true);) {
  6.         OrderMapper mapper = sqlSession.getMapper(OrderMapper.class);
  7.         //查询订单为1的
  8.         OrderModel orderModel = mapper.getById2(1);
  9.         log.info("{}", orderModel);
  10.         log.info("------------------------------------------------------------");
  11.         //查询订单为2的
  12.         orderModel = mapper.getById2(2);
  13.         log.info("{}", orderModel);
  14.         log.info("------------------------------------------------------------");
  15.         //查询订单为3的
  16.         orderModel = mapper.getById2(3);
  17.         log.info("{}", orderModel);
  18.     }
  19. }
运行输出
  1. 39:55.936 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById2 - ==>  Preparing: SELECT a.id , a.user_id, a.create_time, a.up_time FROM t_order a WHERE a.id = ? 
  2. 39:55.969 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById2 - ==> Parameters: 1(Integer)
  3. 39:55.986 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - ====>  Preparing: SELECT id,name FROM t_user where id = ? 
  4. 39:55.987 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - ====> Parameters: 2(Integer)
  5. 39:55.992 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - <====      Total: 1
  6. 39:55.993 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById2 - <==      Total: 1
  7. 39:55.993 [main] INFO  c.j.chat05.demo6.Demo6Test - OrderModel(id=1, userId=2, createTime=1578368161, upTime=1578368161, userModel=UserModel(id=2, name=路人甲Java), orderDetailModelList=null)
  8. 39:55.994 [main] INFO  c.j.chat05.demo6.Demo6Test - ------------------------------------------------------------
  9. 39:55.994 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById2 - ==>  Preparing: SELECT a.id , a.user_id, a.create_time, a.up_time FROM t_order a WHERE a.id = ? 
  10. 39:55.995 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById2 - ==> Parameters: 2(Integer)
  11. 39:55.995 [main] DEBUG c.j.c.d.m.O.getListByOrderId1 - ====>  Preparing: SELECT a.id, a.order_id AS orderId, a.goods_id AS goodsId, a.num, a.total_price AS totalPrice FROM t_order_detail a WHERE a.order_id = ? 
  12. 39:55.996 [main] DEBUG c.j.c.d.m.O.getListByOrderId1 - ====> Parameters: 2(Integer)
  13. 39:56.000 [main] DEBUG c.j.c.d.m.O.getListByOrderId1 - <====      Total: 1
  14. 39:56.001 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - ====>  Preparing: SELECT id,name FROM t_user where id = ? 
  15. 39:56.004 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - ====> Parameters: 1(Integer)
  16. 39:56.005 [main] DEBUG c.j.c.d.mapper.UserMapper.getById1 - <====      Total: 1
  17. 39:56.005 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById2 - <==      Total: 1
  18. 39:56.005 [main] INFO  c.j.chat05.demo6.Demo6Test - OrderModel(id=2, userId=1, createTime=1578368161, upTime=1578368161, userModel=UserModel(id=1, name=张学友), orderDetailModelList=[OrderDetailModel(id=3, orderId=2, goodsId=1, num=1, totalPrice=8.88)])
  19. 39:56.005 [main] INFO  c.j.chat05.demo6.Demo6Test - ------------------------------------------------------------
  20. 39:56.005 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById2 - ==>  Preparing: SELECT a.id , a.user_id, a.create_time, a.up_time FROM t_order a WHERE a.id = ? 
  21. 39:56.006 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById2 - ==> Parameters: 3(Integer)
  22. 39:56.007 [main] DEBUG c.j.c.d.mapper.OrderMapper.getById2 - <==      Total: 1
  23. 39:56.007 [main] INFO  c.j.chat05.demo6.Demo6Test - OrderModel(id=3, userId=1, createTime=1578368161, upTime=1578368161, userModel=null, orderDetailModelList=null)

案例代码 

  1. 链接：https://pan.baidu.com/s/1vt-MAX3oJOu9gyxZAhKkbg 
  2. 提取码：i8op

MyBatis系列

  1. MyBatis系列第1篇：MyBatis未出世之前我们那些痛苦的经历

  2. MyBatis系列第2篇：入门篇，带你感受一下mybatis独特的魅力！

  3. MyBatis系列第3篇：Mybatis使用详解（1）

  4. MyBatis系列第4篇：Mybatis使用详解（2）

  5. Mybatis系列第5篇：Mapper接口多种方式传参详解、原理、源码解析

  6. Mybatis系列第6篇：恕我直言，mybatis增删改你未必玩得转!

  7. Mybatis系列第7篇：各种查询详解

  8. Mybatis系列第8篇：自动映射，使用需谨慎！

更多好文章

  1. Java高并发系列（共34篇）

  2. MySql高手系列（共27篇）

  3. Maven高手系列（共10篇）

  4. 聊聊db和缓存一致性常见的实现方式

  5. 接口幂等性这么重要，它是什么？怎么实现？

感谢大家的阅读，也欢迎您把这篇文章分享给更多的朋友一起阅读！谢谢！

路人甲java

▲长按图片识别二维码关注

路人甲Java：工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！坚信用技术改变命运，让家人过上更体面的生活！ 来源：https://itsoku.blog.csdn.net/article/details/103884203

posted @ 2022-04-23 03:14  程序员小明1024  阅读(55)  评论(0)  编辑  收藏  举报