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

star2017 1年前 ⋅ 238 阅读

建库建表

创建一个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`;
  4. USE `javacode2018`;
  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');
  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);
  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()));
  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);
  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>
  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. }
  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. }
  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
  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，通过这个属性可以指定关联查询的加载方式。

  1. 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>
  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
  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>
  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. }
  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. }
  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
  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中配置的映射关系。

用法

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

最新资料

更多内容请访问：IT源点

注意：本文归作者所有，未经作者允许，不得转载

#MyBatis教程
阅读全部
相关文章推荐
  • 1

全部评论: 0 条

    我有话说: