Mybatis高级查询之关联查询

一时失言乱红尘 2022-07-16 07:42 368阅读 0赞

learn from:http://www.mybatis.org/mybatis-3/zh/sqlmap-xml.html\#Result\_Maps

关联查询

  1. 准备
  2. 关联结果查询（一对一）
  3. resultMap复用
  4. 集合（一对多）

3 关联查询

做查询之前，先修改几个配置。mapper.xml是在mybatis-config.xml中指定，那么我们每增加一个mapper都要增加一个配置，很麻烦。为了简化配置。需要将mapper接口和mapper.xml放到同一个文件下，并且接口和xml文件命名一致。使用mybatis的自动扫描：686418-20160720224306685-1994426277.png.这样，当我们新增接口的时候，直接创建接口和对应xml文件就可以了：

  1. <mappers>
  2.         <!--<mapper resource="com.test.mapper.dao/AuthorMapper.xml"/>-->
  3.         <package name="com.test.mapper.dao"/>
  4. </mappers>

　　

3.1 prepare

增加一个表blog :

  1. CREATE TABLE `blog` (
  2.   `id` int(11) NOT NULL AUTO_INCREMENT,
  3.   `name` varchar(255) DEFAULT NULL,
  4.   `author_id` int(11) DEFAULT NULL,
  5.   PRIMARY KEY (`id`)
  6. ) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;　

创建实体类com.test.mapper.model.Blog:

  1. package com.test.mapper.model;
  3. /**
  4.  * Created by miaorf on 2016/7/20.
  5.  */
  6. public class Blog {
  7.     private Integer id;
  8.     private String name;
  9.     private Author author;
  11.     public Integer getId() {
  12.         return id;
  13.     }
  15.     public void setId(Integer id) {
  16.         this.id = id;
  17.     }
  19.     public String getName() {
  20.         return name;
  21.     }
  23.     public void setName(String name) {
  24.         this.name = name;
  25.     }
  27.     public Author getAuthor() {
  28.         return author;
  29.     }
  31.     public void setAuthor(Author author) {
  32.         this.author = author;
  33.     }
  35.     @Override
  36.     public String toString() {
  37.         return "Blog{" +
  38.                 "id=" + id +
  39.                 ", name='" + name + '\'' +
  40.                 ", author=" + author +
  41.                 '}';
  42.     }
  43. }

创建接口：com/test/mapper/dao/BlogMapper.xml

  1. package com.test.mapper.dao;
  3. import com.test.mapper.model.Blog;
  5. import java.util.List;
  7. /**
  8.  * Created by miaorf on 2016/7/20.
  9.  */
  10. public interface BlogMapper {
  12.     List<Blog> selectBlog(Integer id);
  13. }

创建xml：com/test/mapper/dao/BlogMapper.xml

`<?xml version=”1.0” encoding=”UTF-8” ?>
<!DOCTYPE mapper
PUBLIC “-//mybatis.org//DTD Mapper 3.0//EN”
“http://mybatis.org/dtd/mybatis-3-mapper.dtd">





`

　

3.2含义

首先，修改了mybatis配置文件中mapper扫描配置，因此可以直接在扫描包下添加接口和xml文件。

其次，关于mybatis的命名空间namespace的用法，这个是唯一的，可以代表这个xml文件本身。因此，当我想要引用Author的查询的时候，我可以直接使用AuthorMapper.xml的命名空间点select的id来唯一确定select片段。即：

  1. select="com.test.mapper.dao.AuthorMapper.selectAuthorById"

然后，关联查询，blog的author_id字段和author的id字段关联。因此，将Author作为Blog的一个属性，先查询blog，然后根据author_id字段去查询author。也就是说，查询了两次。这里也是我困惑的地方，为什么mybatis要这样处理，命名可以一次查询取得数据非要两次查询。

注意：association节点中

  • column字段是author_id，是当做参数传递给查询Author的查询语句的，如果查询语句的参数有多个则：column= ” {prop1=col1,prop2=col2} ” 这种语法来传递给嵌套查询语 句。这会引起 prop1 和 prop2 以参数对象形式来设置给目标嵌套查询语句。
  • property则表示在Blog类中对应的属性。

我们有两个查询语句:一个来加载博客,另外一个来加载作者,而且博客的结果映射描 述了“selectAuthor”语句应该被用来加载它的 author 属性。

其他所有的属性将会被自动加载,假设它们的列和属性名相匹配。

这种方式很简单, 但是对于大型数据集合和列表将不会表现很好。 问题就是我们熟知的 “N+1 查询问题”。概括地讲,N+1 查询问题可以是这样引起的:

  • 你执行了一个单独的 SQL 语句来获取结果列表(就是“+1”)。
  • 对返回的每条记录,你执行了一个查询语句来为每个加载细节(就是“N”)。

这个问题会导致成百上千的 SQL 语句被执行。这通常不是期望的。

MyBatis 能延迟加载这样的查询就是一个好处,因此你可以分散这些语句同时运行的消 耗。然而,如果你加载一个列表,之后迅速迭代来访问嵌套的数据,你会调用所有的延迟加 载,这样的行为可能是很糟糕的。

所以还有另外一种方法

3.3 关联查询结果

上述关联查询主要是为了延迟加载，做缓存用的，如果你不调用blog.getAuthor()来获取author,那么mybatis就不会去查询Author。也就是说，mybatis把博客和作者的查询当做两步来执行。实现信息分段加载，在某些场合是有用的。然而在博客这里，显然不太合适，因为我们看到博客的同时都会看到作者，那么必然会导致查询数据库两次。下面，来测试另一种方式，像sql关联查询一样，一次查出结果。

  1. <select id="selectBlogWithAuthor" resultMap="blogResultWithAuthor">
  2.         SELECT
  3.           b.id        as blog_id,
  4.           b.name      as blog_title,
  5.           b.author_id as blog_author_id,
  6.           a.id        as author_id,
  7.           a.username  as author_username,
  8.           a.password  as author_password,
  9.           a.email     as author_email,
  10.           a.bio       as author_bio
  11.         FROM blog b LEFT OUTER JOIN author a ON b.author_id=a.id
  12.         WHERE b.id = #{id}
  13.     </select>
  14.     <resultMap id="blogResultWithAuthor" type="blog">
  15.         <id property="id" column="blog_id"/>
  16.         <result property="name" column="blog_title"/>
  17.         <association property="author" column="blog_author_id" javaType="author" resultMap="authorResult"/>
  18.     </resultMap>
  19.     <resultMap id="authorResult" type="author">
  20.         <id property="id" column="author_id"/>
  21.         <result property="username" column="author_username"/>
  22.         <result property="password" column="author_password"/>
  23.         <result property="email" column="author_email"/>
  24.         <result property="bio" column="author_bio"/>
  25.     </resultMap>

和3.1里的查询一样，都是查询出blog和Author。但这个只查询数据库一次，也就是说实现了我们的关联查询。这几行代码乍一看有点复杂，仔细分析一下就很明了了。

1> 首先看到的是select标签，这个表示查询。其中id表示对应的接口的方法名；resultMap的值是一个resultMap节点的id，这个表示select查询结果的映射方式。

2> select中间就是我熟悉的关联查询语句，这里不做赘述

3> 然后就是resultMap所指向的节点blogResultWithAuthor。

  • resultMap节点的id就是唯一标识这个节点的，type表示这个resultMap最终映射成的实体类Blog。
  • id是主键映射，这个和mybatis缓存有关。
  • 686418-20160722232206060-1211044993.png
  • 686418-20160722234709544-1295511091.png
  • result:
  • 686418-20160722233120107-374014612.png
  • association:
  • 686418-20160722234407138-615204477.png
  • authorResult同理。

可以看到控制台打印的日志：

  1. 2016-07-22 23:01:00,148 DEBUG [org.apache.ibatis.transaction.jdbc.JdbcTransaction] - Opening JDBC Connection
  2. 2016-07-22 23:01:11,017 DEBUG [org.apache.ibatis.datasource.pooled.PooledDataSource] - Created connection 1893960929.
  3. 2016-07-22 23:01:19,281 DEBUG [org.apache.ibatis.transaction.jdbc.JdbcTransaction] - Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@70e38ce1]
  4. 2016-07-22 23:01:27,018 DEBUG [com.test.mapper.dao.BlogMapper.selectBlogWithAuthor] - ==>  Preparing: SELECT b.id as blog_id, b.name as blog_title, b.author_id as blog_author_id, a.id as author_id, a.username as author_username, a.password as author_password, a.email as author_email, a.bio as author_bio FROM blog b LEFT OUTER JOIN author a ON b.author_id=a.id WHERE b.id = ? 
  5. 2016-07-22 23:01:29,697 DEBUG [com.test.mapper.dao.BlogMapper.selectBlogWithAuthor] - ==> Parameters: 1(Integer)
  6. 2016-07-22 23:01:30,091 DEBUG [com.test.mapper.dao.BlogMapper.selectBlogWithAuthor] - <==      Total: 1

3.4 resultMap复用

只要引用resultMap的id就可以引用这个resultMap。然而，有时候resultMap的结构相同，但字段不同。比如，Blog有两个作者Author、co-Athour。这时候的查询语句是这样的：

  1. SELECT
  2.         b.id        as blog_id,
  3.         b.name      as blog_title,
  4.         b.author_id as blog_author_id,
  5.         a.id        as author_id,
  6.         a.username  as author_username,
  7.         a.password  as author_password,
  8.         a.email     as author_email,
  9.         a.bio       as author_bio,
  10.         ca.id        as co_author_id,
  11.         ca.username  as co_author_username,
  12.         ca.password  as co_author_password,
  13.         ca.email     as co_author_email,
  14.         ca.bio       as co_author_bio
  15.         FROM blog b
  16.         LEFT OUTER JOIN author a ON b.author_id=a.id
  17.         LEFT OUTER JOIN author ca ON b.co_author_id=ca.id
  18.         WHERE b.id = #{id}

显然合作者和作者的结构式相同的，但是我们给了不同的别名（alias）。这时候可以使用resultMap的columnPrefix属性：

ContractedBlock.gif ExpandedBlockStart.gif

  1. <!-- association 2 -->
  2.     <select id="selectBlogWithAuthor2" resultMap="blogResultWithAuthor2">
  3.         SELECT
  4.         b.id        as blog_id,
  5.         b.name      as blog_title,
  6.         b.author_id as blog_author_id,
  7.         a.id        as author_id,
  8.         a.username  as author_username,
  9.         a.password  as author_password,
  10.         a.email     as author_email,
  11.         a.bio       as author_bio,
  12.         ca.id        as co_author_id,
  13.         ca.username  as co_author_username,
  14.         ca.password  as co_author_password,
  15.         ca.email     as co_author_email,
  16.         ca.bio       as co_author_bio
  17.         FROM blog b
  18.         LEFT OUTER JOIN author a ON b.author_id=a.id
  19.         LEFT OUTER JOIN author ca ON b.co_author_id=ca.id
  20.         WHERE b.id = #{id}
  21.     </select>
  22.     <resultMap id="blogResultWithAuthor2" type="Blog">
  23.         <id property="id" column="blog_id"/>
  24.         <result property="name" column="blog_title"/>
  25.         <association property="author" resultMap="authorResult"/>
  26.         <association property="coAuthor" resultMap="authorResult"
  27.                      columnPrefix="co_"/>
  28.     </resultMap>
  29. <resultMap id="authorResult" type="author">
  30.         <id property="id" column="author_id"/>
  31.         <result property="username" column="author_username"/>
  32.         <result property="password" column="author_password"/>
  33.         <result property="email" column="author_email"/>
  34.         <result property="bio" column="author_bio"/>
  35.     </resultMap>

3.4集合

上述关联查询是has a关系，一对一的。一对多的，需要使用collection。

比如，一个博客有一个作者，但有很多博文。

创建博文表post:

ContractedBlock.gif ExpandedBlockStart.gif

  1. /*
  2. Navicat MySQL Data Transfer
  4. Source Server         : localhost
  5. Source Server Version : 50605
  6. Source Host           : localhost:3306
  7. Source Database       : mybatis
  9. Target Server Type    : MYSQL
  10. Target Server Version : 50605
  11. File Encoding         : 65001
  13. Date: 2016-07-24 22:39:35
  14. */
  16. SET FOREIGN_KEY_CHECKS=0;
  18. -- ----------------------------
  19. -- Table structure for post
  20. -- ----------------------------
  21. DROP TABLE IF EXISTS `post`;
  22. CREATE TABLE `post` (
  23.   `id` int(11) NOT NULL AUTO_INCREMENT,
  24.   `subject` varchar(255) DEFAULT NULL,
  25.   `body` varchar(255) DEFAULT NULL,
  26.   `blog_id` int(11) DEFAULT NULL,
  27.   PRIMARY KEY (`id`)
  28. ) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
  30. -- ----------------------------
  31. -- Records of post
  32. -- ----------------------------
  33. INSERT INTO `post` VALUES ('1', 'test', 'test-body', '1');

创建博文实体类com.test.mapper.model.Post:

ContractedBlock.gif ExpandedBlockStart.gif

  1. package com.test.mapper.model;
  3. /**
  4.  * Created by miaorf on 2016/7/24.
  5.  */
  6. public class Post {
  7.     private Integer id;
  8.     private String subject;
  9.     private String body;
  11.     public Integer getId() {
  12.         return id;
  13.     }
  15.     public void setId(Integer id) {
  16.         this.id = id;
  17.     }
  19.     public String getSubject() {
  20.         return subject;
  21.     }
  23.     public void setSubject(String subject) {
  24.         this.subject = subject;
  25.     }
  27.     public String getBody() {
  28.         return body;
  29.     }
  31.     public void setBody(String body) {
  32.         this.body = body;
  33.     }
  34. }

在Blog里添加属性字段

private List posts;

编写查询如下：

  1. <!-- collection -->
  2.     <select id="selectBlogWithPost" resultMap="blogResultWithPost">
  3.         SELECT
  4.         b.id    AS   blog_id,
  5.         b.name  AS   blog_name,
  6.         b.author_id AS blog_author_id,
  7.         p.id        AS post_id,
  8.         p.subject   AS post_subject,
  9.         p.body      AS post_body
  10.         FROM blog b
  11.         LEFT OUTER JOIN post p ON b.id=p.blog_id
  12.         WHERE b.id=#{id}
  13.     </select>
  14.     <resultMap id="blogResultWithPost" type="Blog">
  15.         <id property="id" column="blog_id"/>
  16.         <result property="name" column="blog_name"/>
  17.         <collection property="posts" ofType="Post">
  18.             <id property="id" column="post_id"/>
  19.             <result property="subject" column="post_subject"/>
  20.             <result property="body" column="post_body"/>
  21.         </collection>
  22.     </resultMap>

很容易看出来，集合和关联几乎完全一样，只不过一个是association一个是collection，一个是一对一，一个是一对多。到这里基本就可以满足所有的sql关联查询了。关于collection的参数，还是要注释一下：

686418-20160725220956716-1746656217.png

同样的，集合collection和关联association一样，都属于resultMap类型，即结果集映射规则。那么，collection也可以抽出来复用：

  1. <resultMap id="blogResultWithPost" type="Blog">
  2.         <id property="id" column="blog_id"/>
  3.         <result property="name" column="blog_name"/>
  4.         <collection property="posts" ofType="Post" resultMap="postResult" columnPrefix="post_"/>
  5. </resultMap>
  6. <resultMap id="postResult" type="Post">
  7.     <id property="id" column="id"/>
  8.     <result property="subject" column="subject"/>
  9.     <result property="body" column="body"/>
  10. </resultMap>

注意

这个对你所映射的内容没有深度,广度或关联和集合相联合的限制。当映射它们 时你应该在大脑中保留它们的表现。 你的应用在找到最佳方法前要一直进行的单元测试和性 能测试。好在 myBatis 让你后来可以改变想法,而不对你的代码造成很小(或任何)影响。

高级关联和集合映射是一个深度的主题。文档只能给你介绍到这了。加上一点联系,你 会很快清楚它们的用法

发表评论

表情：
评论列表 （有 0 条评论，368人围观）

还没有评论，来说两句吧...

相关阅读

    相关 MyBatis之关联查询

      前言 我们进行数据库查询时往往需要的不止一张表的数据，需要将多张表的数据一起查询出来，大家学习过数据库的连接查询，那么在MyBatis中如何将有关系的多张表数据进行关联

    野性酷女野性酷女/ 0 赞/ 266 阅读

    相关 Mybatis关联查询

    Mybatis关联查询 演示的数据表为： ![Center][] 部门和员工属于一对多关系。接下来演示的是根据员工编号查询员工信息并关联查询所在部门信息，查询所有部

    喜欢ヅ旅行喜欢ヅ旅行/ 0 赞/ 405 阅读