MybatisPlus多表连接查询

admin

<h3 id="一序言">一、序言</h3>
<h4 id="一背景内容">（一）背景内容</h4>
# s" B& k$ c% g  p1 U0 k<p>软件应用技术架构中DAO层最常见的选型组件为MyBatis，熟悉MyBatis的朋友都清楚，曾几何时MyBatis是多么的风光，使用XML文件解决了复杂的数据库访问的难题。时至今日，曾经的屠龙者终成恶龙，以XML文件为基础的数据库访问技术变得臃肿、复杂，维护难度直线上升。</p>
6 g( T3 |  y2 D2 G, L<p>MybatisPlus对常见的数据库访问进行了封装，访问数据库大大减少了XML文件的依赖，开发者从臃肿的XML文件中获得了较大限度的解脱。</p>
<p>MybatisPlus官方并没有提供多表<code>连接查询</code>的通用解决方案，然而连接查询是相当普遍的需求。解决连接查询有两种需求，一种是继续使用MyBatis提供XML文件解决方式；另一种本文提供的解决方案。</p>
<p>事实上笔者强烈推荐彻底告别通过XML访问数据库，并不断探索新式更加友好、更加自然的解决方式，现分享最新的MybatisPlus技术的研究成果。</p>
<img src="https://www.altitude.xin/typora/image-20211021114957682.png" >
<h4 id="二场景说明">（二）场景说明</h4>
<p>为了说明连接查询的关系，这里以学生、课程及其关系为示例。</p>
+ y" s$ E- X" d" y+ |) {% s<img src="https://www.altitude.xin/typora/image-20211020194255298.png" >
<h4 id="三前期准备">（三）前期准备</h4>
8 o- k$ u0 I5 u<p>此部分需要读者掌握以下内容：Lambda 表达式、特别是方法引用；函数式接口；流式运算等等，否则理解起来会有些吃力。</p>
+ O) ]% e9 w! y: Z( P" Z! H; n5 J<img src="https://www.altitude.xin/typora/image-20211021135113431.png" >
<p>实体类与 Vo 的映射关系，作者创造性的引入特别构造器，合理利用继承关系，极大的方便了开发者完成实体类向 Vo 的转换。</p>
6 W3 b; R. Z8 c2 B% i8 A<p>空指针异常忽略不处理，借助[Optional]类实现，详情移步[Java8 新特性]查看。</p>
) c7 C- C; `, V; R9 k6 f<h3 id="二一对一查询">二、一对一查询</h3>
<p>一对一查询最典型的应用场景是将<code>id</code>替换成<code>name</code>，比如将<code>userId</code>替换成<code>userName</code>。</p>
<h4 id="一查询单条记录">（一）查询单条记录</h4>
3 F. W; L1 k; m4 E( H$ y<p>查询单条记录是指返回值仅有一条记录，通常是以唯一索引作为条件的返回查询结果。</p>
<h5 id="1示例代码">1、示例代码</h5>
<pre><code class="language-java">/**
* 查询单个学生信息（一个学生对应一个部门）
, |& a7 A& V+ S7 T% `2 k4 y */
public UserVo getOneUser(Integer userId) {
" O* I' f/ f, ?4 G    LambdaQueryWrapper&lt;User&gt; wrapper = Wrappers.lambdaQuery(User.class)
  U; @0 d9 N7 _' ?: \        .eq(User::getUserId, userId);
    // 先查询用户信息
    User user = userMapper.selectOne(wrapper);
    // 转化为Vo
. p$ g$ b' N- t0 [; q    UserVo userVo = Optional.ofNullable(user).map(UserVo::new).orElse(null);
    // 从其它表查询信息再封装到Vo
    Optional.ofNullable(userVo).ifPresent(this::addDetpNameInfo);
    return userVo;
+ h! ^) ~$ D! b: a3 Z3 G8 [) g( i}
) S; v9 d4 x4 D" R' U</code></pre>
' v- z1 E6 J7 @, \  d# i<p>附属表信息补充</p>
<pre><code class="language-java">/**
* 补充部门名称信息
& {. j* J7 w. B/ j3 O/ m) m- F( G */
! y& a% V% Z2 ]; D8 Mprivate void addDetpNameInfo(UserVo userVo) {
- \4 C, W4 H8 x/ f/ _    LambdaQueryWrapper&lt;Dept&gt; wrapper = Wrappers.lambdaQuery(Dept.class)
1 ^2 C5 g, l4 a4 ^: r  ?% E        .eq(Dept::getDeptId, userVo.getDeptId());
! L8 D4 ]- d1 t8 K; P& E# }. r    Dept dept = deptMapper.selectOne(wrapper);
/ z5 R- q% Z" ?7 a7 s8 N, f' c4 N    Optional.ofNullable(dept).ifPresent(e -&gt; userVo.setDeptName(e.getDeptName()));
+ [8 j+ o; q( u. e: @+ C1 ?. {4 n% c. {}
9 C0 m6 \2 f0 p  y</code></pre>
2 Q, `  e4 a5 q: @( i+ S/ q<h5 id="2理论分析">2、理论分析</h5>
<p>查询单个实体共分为两个步骤：根据条件查询主表数据（需处理空指针异常）；封装 Vo 并查询附属表数据。</p>
<p>查询结果（VO）只有一条记录，需要查询两次数据库，时间复杂度为<code>O(1)</code>。</p>
; Q" ~1 K8 M+ Z) Y* L<h4 id="二查询多条记录">（二）查询多条记录</h4>
<p>查询多条记录是指查询结果为列表，通常是指以普通索引为条件的查询结果。</p>
<h5 id="1示例代码-1">1、示例代码</h5>
<pre><code class="language-java">/**
+ M* k. H$ ], p+ S; w * 批量查询学生信息（一个学生对应一个部门）
*/
public List&lt;UserVo&gt; getUserByList() {
    // 先查询用户信息（表现形式为列表）
    List&lt;User&gt; user = userMapper.selectList(Wrappers.emptyWrapper());
3 X5 O& D' P, d' V7 r* f- }    List&lt;UserVo&gt; userVos = user.stream().map(UserVo::new).collect(toList());
1 T- H: \6 {3 }6 T& H3 C    // 此步骤可以有多个
    addDeptNameInfo(userVos);
    return userVos;
) O9 Q# f. P2 U# J}
</code></pre>
<p>附属信息补充</p>
<pre><code class="language-java">private void addDeptNameInfo(List&lt;UserVo&gt; userVos) {
+ S  `/ V  H5 i/ [" H6 u7 D    // 提取用户userId，方便批量查询
+ G2 q0 V0 r4 M; E. f    Set&lt;Integer&gt; deptIds = userVos.stream().map(User::getDeptId).collect(toSet());
3 V, \" \- d: H; S5 ^3 j# m' L    // 根据deptId查询deptName（查询前，先做非空判断）
    List&lt;Dept&gt; dept = deptMapper.selectList(Wrappers.lambdaQuery(Dept.class).in(Dept::getDeptId, deptIds));
    // 构造映射关系，方便匹配deptId与deptName
# d7 X% P& W1 I, a/ Q    Map&lt;Integer, String&gt; hashMap = dept.stream().collect(toMap(Dept::getDeptId, Dept::getDeptName));
! d, V& O' ^& ?% a5 o: C    // 封装Vo，并添加到集合中(关键内容)
    userVos.forEach(e -&gt; e.setDeptName(hashMap.get(e.getDeptId())));
& B& Z5 u5 z; a! F}
4 j, D$ J/ F2 A5 R# l</code></pre>
2 b. U3 H$ U  j% k<h5 id="2理论分析-1">2、理论分析</h5>
<p>先查询包含<code>id</code>的列表记录，从结果集中析出<code>id</code>并转化成批查询语句再访问数据库，从第二次调用结果集中解析出<code>name</code>。</p>
<p>查询结果（VO）有多条记录，但仅调用两次数据库，时间复杂度为<code>O(1)</code>。</p>
<h4 id="三查询多条记录分页">（三）查询多条记录（分页）</h4>
: |: y8 F+ `1 _$ G* ^, {<p>分页查询实体的思路与查询列表的思路相似，额外多处一步分页泛型转换。</p>
<h5 id="1示例代码-2">1、示例代码</h5>
! M8 w, \0 k: G$ ~( X<pre><code class="language-java">/**
* 分页查询学生信息（一个学生对应一个部门）
*/
+ o( C  b+ n/ q. Q  f, Opublic IPage&lt;UserVo&gt; getUserByPage(Page&lt;User&gt; page) {
    // 先查询用户信息
4 F$ g% I- o( g    IPage&lt;User&gt; xUserPage = userMapper.selectPage(page, Wrappers.emptyWrapper());
    // 初始化Vo
    IPage&lt;UserVo&gt; userVoPage = xUserPage.convert(UserVo::new);
' f; h" A% Y4 N6 C$ g, m    if (userVoPage.getRecords().size() &gt; 0) {
0 _  n3 q* o% I        addDeptNameInfo(userVoPage);
7 G$ D: \& m" p  e2 A    }
8 @1 r9 }5 u/ B! y* `  P1 |    return userVoPage;
+ e2 |. m; X2 K! ~; J2 B}
</code></pre>
9 |: o8 }- b7 N- F' u% e0 \+ h<p>查询补充信息</p>
<pre><code class="language-java">private void addDeptNameInfo(IPage&lt;UserVo&gt; userVoPage) {
3 q5 R& w; l' N# n  j    // 提取用户userId，方便批量查询
    Set&lt;Integer&gt; deptIds = userVoPage.getRecords().stream().map(User::getDeptId).collect(toSet());
    // 根据deptId查询deptName
! v4 D, F9 F  _+ S" K    List&lt;Dept&gt; dept = deptMapper.selectList(Wrappers.lambdaQuery(Dept.class).in(Dept::getDeptId, deptIds));
    // 构造映射关系，方便匹配deptId与deptName
    Map&lt;Integer, String&gt; hashMap = dept.stream().collect(toMap(Dept::getDeptId, Dept::getDeptName));
    // 将查询补充的信息添加到Vo中
    userVoPage.convert(e -&gt; e.setDeptName(hashMap.get(e.getDeptId())));
}
</code></pre>
; C" {% B; F) N% w4 G6 S<p><code>IPage</code>接口中<code>convert</code>方法，能够实现在原实例上修改。</p>
<h5 id="2理论分析-2">2、理论分析</h5>
# p3 O6 z: D& i& _7 Q<p>先查询包含<code>id</code>的列表记录，从结果集中析出<code>id</code>并转化成批查询语句再访问数据库，从第二次调用结果集中解析出<code>name</code>。</p>
<p>查询结果（VO）有多条记录，但仅调用两次数据库，时间复杂度为<code>O(1)</code>。</p>
% |% `7 z; M7 a* r4 K- F  i<h3 id="三一对多查询">三、一对多查询</h3>
<p>一对多查询最常见的场景是查询部门所包含的学生信息，由于一个部门对应多个学生，每个学生对应一个部门，因此称为一对多查询。</p>
<h4 id="一查询单条记录-1">（一）查询单条记录</h4>
<h5 id="1示例代码-3">1、示例代码</h5>
7 F$ @+ ~& T6 G, @9 [<pre><code class="language-java">/**
+ ?/ y2 |+ E! v* K2 ~7 k- ] * 查询单个部门（其中一个部门有多个用户）
*/
3 r* O$ ]; r6 q) g- {& m: s5 cpublic DeptVo getOneDept(Integer deptId) {
) R; k. G3 b( D3 w4 X    // 查询部门基础信息
    LambdaQueryWrapper&lt;Dept&gt; wrapper = Wrappers.lambdaQuery(Dept.class).eq(Dept::getDeptId, deptId);
    DeptVo deptVo = Optional.ofNullable(deptMapper.selectOne(wrapper)).map(DeptVo::new).orElse(null);
    Optional.ofNullable(deptVo).ifPresent(this::addUserInfo);
    return deptVo;
}
0 Y. Q. m! l8 d: n# {- k! b/ b</code></pre>
( t9 Z% P6 r: l" |% D<p>补充附加信息</p>
6 {( q2 y# O6 E1 G  z# q6 N; o$ L<pre><code class="language-java">private void addUserInfo(DeptVo deptVo) {
- ^* U2 M* i* O$ I5 V: V- @1 d    // 根据部门deptId查询学生列表
    LambdaQueryWrapper&lt;User&gt; wrapper = Wrappers.lambdaQuery(User.class).eq(User::getDeptId, deptVo.getDeptId());
    List&lt;User&gt; users = userMapper.selectList(wrapper);
    deptVo.setUsers(users);
1 a# f7 j) J, L5 t7 f4 x2 @* l( z}
9 @& {) z' X3 r/ \+ O# P</code></pre>
- `* q( l/ Z. w9 s2 r- v<h5 id="2理论分析-3">2、理论分析</h5>
/ U! f( H2 @( m<p>整个过程共分为两个阶段：通过部门表中主键查询指定部门信息，通过学生表中部门ID外键查询学生信息，将结果合并，形成返回值（Vo）。</p>
<p>一对多查询单条记录整个过程至多需要调用2次数据库查询，查询次数为常数，查询时间复杂度为<code>O(1)</code>。</p>
<h4 id="二查询多条记录-1">（二）查询多条记录</h4>
0 R# j# e  m3 U# ^<h5 id="1示例代码-4">1、示例代码</h5>
( Z$ K& f) ?7 U0 \<pre><code class="language-java">/**
* 查询多个部门（其中一个部门有多个用户）
1 Q' i' f2 i  O3 S0 k0 t0 v  }' Q */
, I/ `2 @' G) B8 b& w2 j; ]7 g/ bpublic List&lt;DeptVo&gt; getDeptByList() {
    // 按条件查询部门信息
    List&lt;Dept&gt; deptList = deptMapper.selectList(Wrappers.emptyWrapper());
  `' ~7 G2 i" k5 {$ D" _1 R    List&lt;DeptVo&gt; deptVos = deptList.stream().map(DeptVo::new).collect(toList());
# ]2 u; m; l0 _! c    if (deptVos.size() &gt; 0) {
        addUserInfo(deptVos);
    }
) q, `5 A6 \' ^    return deptVos;
}
</code></pre>
<p>补充附加信息</p>
<pre><code class="language-java">private void addUserInfo(List&lt;DeptVo&gt; deptVos) {
& h9 T% B: u$ n9 p$ L9 S    // 准备deptId方便批量查询用户信息
    Set&lt;Integer&gt; deptIds = deptVos.stream().map(Dept::getDeptId).collect(toSet());
! o5 |5 c2 C( ~6 Z" j/ C0 L    // 用批量deptId查询用户信息
: k9 h. g2 Y( Z! }7 I" M2 O    List&lt;User&gt; users = userMapper.selectList(Wrappers.lambdaQuery(User.class).in(User::getDeptId, deptIds));
; T% D1 f, |; H, \8 ^6 w    // 重点：将用户按照deptId分组
    Map&lt;Integer, List&lt;User&gt;&gt; hashMap = users.stream().collect(groupingBy(User::getDeptId));
. L6 t+ q8 q& g    // 合并结果，构造Vo，添加集合列表
    deptVos.forEach(e -&gt; e.setUsers(hashMap.get(e.getDeptId())));
8 v! I! P2 `% \; H* D6 w}
. m. J+ E4 r$ o9 X</code></pre>
) {) G! P: C/ W: l<h5 id="2理论分析-4">2、理论分析</h5>
4 Y2 p) N0 x8 H5 N# v$ F/ x<p>整个过程共分为三个阶段：通过普通索引从部门表中查询若干条记录；将部门ID转化为批查询从学生表中查询学生记录；将学生记录以部门ID为单位进行分组，合并结果，转化为Vo。</p>
<p>一对多查询多条记录需要调用2次数据库查询，查询次数为常数，查询时间复杂度为<code>O(1)</code>。</p>
<h4 id="三查询多条记录分页-1">（三）查询多条记录（分页）</h4>
8 j" U7 S" ], I. E<h5 id="1示例代码-5">1、示例代码</h5>
<pre><code class="language-java">/**
6 Y- D  G' W  {# z4 J$ X4 p * 分页查询部门信息（其中一个部门有多个用户）
*/
9 c' ~/ D" w! a( Jpublic IPage&lt;DeptVo&gt; getDeptByPage(Page&lt;Dept&gt; page) {
    // 按条件查询部门信息
    IPage&lt;Dept&gt; xDeptPage = deptMapper.selectPage(page, Wrappers.emptyWrapper());
    IPage&lt;DeptVo&gt; deptVoPage = xDeptPage.convert(DeptVo::new);
( P+ g. w! x: L0 i# b. c; Z7 ~    if (deptVoPage.getRecords().size() &gt; 0) {
. L& t* C5 |# I+ y' N        addUserInfo(deptVoPage);
    }
9 I1 o% L9 h; I, m: t& g5 e  t4 Z4 V    return deptVoPage;
( H" X) U4 C6 F" V}
# T# o/ B% T/ ]8 q</code></pre>
9 O2 M+ T2 |8 E, i$ ?: ]7 }; |: W, K<p>查询补充信息</p>
& A7 @1 z- Q5 Z<pre><code class="language-java">private void addUserInfo(IPage&lt;DeptVo&gt; deptVoPage) {
    // 准备deptId方便批量查询用户信息
    Set&lt;Integer&gt; deptIds = deptVoPage.getRecords().stream().map(Dept::getDeptId).collect(toSet());
    LambdaQueryWrapper&lt;User&gt; wrapper = Wrappers.lambdaQuery(User.class).in(User::getDeptId, deptIds);
    // 用批量deptId查询用户信息
    List&lt;User&gt; users = userMapper.selectList(wrapper);
0 c. q1 ]) v0 t: w    // 重点：将用户按照deptId分组
" z7 O) [2 W% P5 F* z    Map&lt;Integer, List&lt;User&gt;&gt; hashMap = users.stream().collect(groupingBy(User::getDeptId));
0 y; \, j8 t+ `1 w: D2 _2 T; f; v+ I    // 合并结果，构造Vo，添加集合列表
    deptVoPage.convert(e -&gt; e.setUsers(hashMap.get(e.getDeptId())));
6 Z- H, F. V# {, d7 V}
; n9 |  S2 \! w  H0 ~/ q) ]/ L7 ~</code></pre>
" l  d/ B3 z/ j4 `6 F<h5 id="2理论分析-5">2、理论分析</h5>
<p>整个过程共分为三个阶段：通过普通索引从部门表中查询若干条记录；将部门ID转化为批查询从学生表中查询学生记录；将学生记录以部门ID为单位进行分组，合并结果，转化为Vo。</p>
0 I9 C& e  ^. A2 t( D) ~& J/ p<p>一对多查询多条记录需要调用2次数据库查询，查询次数为常数，查询时间复杂度为<code>O(1)</code>。</p>
<h3 id="四多对多查询">四、多对多查询</h3>
! G! x' |5 B0 Z$ Y; b7 H2 F<p>MybatisPlus 实现多对多查询是一件极富挑战性的任务，也是连接查询中最困难的部分。</p>
/ b6 a: m2 N( u1 P<p>以空间置换时间，借助于流式运算，解决多对多查询难题。</p>
<p>多对多查询相对于一对多查询，增加了流式分组运算、批量 HashMap 取值等内容。</p>
<img src="https://www.altitude.xin/typora/image-20211024115903848.png" >
<h4 id="一查询单条记录-2">（一）查询单条记录</h4>
<p>查询单条记录一般是指通过两个查询条件查询出一条匹配表中的记录。</p>
! }7 o9 K+ q, I. r<h5 id="1示例代码-6">1、示例代码</h5>
<pre><code class="language-java">public StudentVo getStudent(Integer stuId) {
/ y# {3 f0 T5 h    // 通过主键查询学生信息
* W  Z5 Z. v3 C    StudentVo studentVo = ConvertUtils.convertObj(getById(stuId), StudentVo::new);
0 H! K; h5 q- J' J  _, w/ ^% O; K    LambdaQueryWrapper&lt;StuSubRelation&gt; wrapper = Wrappers.lambdaQuery(StuSubRelation.class).eq(StuSubRelation::getStuId, stuId);
    // 查询匹配关系
    List&lt;StuSubRelation&gt; stuSubRelations = stuSubRelationMapper.selectList(wrapper);
    Set&lt;Integer&gt; subIds = stuSubRelations.stream().map(StuSubRelation::getSubId).collect(toSet());
5 E' H* |, T1 y  ]" l# O    if (studentVo != null &amp;&amp; subIds.size() &gt; 0) {
$ ~  ~' b( A" u; n- G8 q  W; s        List&lt;Subject&gt; subList = subjectMapper.selectList(Wrappers.lambdaQuery(Subject.class).in(Subject::getId, subIds));
7 |- b# ?5 H$ S3 d& j: E, u        List&lt;SubjectBo&gt; subBoList = ConvertUtils.convertList(subList, SubjectBo::new);
9 I+ r5 _  @8 t2 B/ |0 f        HashBasedTable&lt;Integer, Integer, Integer&gt; table = getHashBasedTable(stuSubRelations);
( \3 L* n6 T3 c* y* ~        subBoList.forEach(e -&gt; e.setScore(table.get(stuId, e.getId())));
        studentVo.setSubList(subBoList);
    }
    return studentVo;
  d: H) \5 `2 m" D0 V}
# q$ {5 @7 b! M% W+ ]</code></pre>
5 l+ N" V% ^. y2 u% k3 ]; a$ v<h5 id="2理论分析-6">2、理论分析</h5>
<p>多对多单条记录查询最多访问数据库3次，先查询学生信息，然后查询学生与课程匹配信息，最后查询课程分数信息，查询时间复杂度为<code>O(1)</code>。</p>
<h4 id="二查询多条记录-2">（二）查询多条记录</h4>
% a" K: j! N: x: w/ E% ^( P<h5 id="1示例代码-7">1、示例代码</h5>
<pre><code class="language-java">public List&lt;StudentVo&gt; getStudentList() {
    // 通过主键查询学生信息
    List&lt;StudentVo&gt; studentVoList = ConvertUtils.convertList(list(), StudentVo::new);
    // 批量查询学生ID
6 [% Z; r' I: ^    Set&lt;Integer&gt; stuIds = studentVoList.stream().map(Student::getId).collect(toSet());
- s/ ]' v$ E* J% ^1 n) W    LambdaQueryWrapper&lt;StuSubRelation&gt; wrapper = Wrappers.lambdaQuery(StuSubRelation.class).in(StuSubRelation::getStuId, stuIds);
: h; z" m$ `9 X- ]: _    List&lt;StuSubRelation&gt; stuSubRelations = stuSubRelationMapper.selectList(wrapper);
    // 批量查询课程ID
" k) k& e$ c  B7 h- h+ ~    Set&lt;Integer&gt; subIds = stuSubRelations.stream().map(StuSubRelation::getSubId).collect(toSet());
    if (stuIds.size() &gt; 0 &amp;&amp; subIds.size() &gt; 0) {
        HashBasedTable&lt;Integer, Integer, Integer&gt; table = getHashBasedTable(stuSubRelations);
        List&lt;Subject&gt; subList = subjectMapper.selectList(Wrappers.lambdaQuery(Subject.class).in(Subject::getId, subIds));
' \9 L! C( l% U8 X        List&lt;SubjectBo&gt; subjectBoList = ConvertUtils.convertList(subList, SubjectBo::new);
0 e- a& ^2 b5 }! |8 _7 ]        Map&lt;Integer, List&lt;Integer&gt;&gt; map = stuSubRelations.stream().collect(groupingBy(StuSubRelation::getStuId, mapping(StuSubRelation::getSubId, toList())));
: G  F! I0 ^1 s+ C5 J! a* W* S- {        for (StudentVo studentVo : studentVoList) {
            // 获取课程列表
            List&lt;SubjectBo&gt; list = ListUtils.select(subjectBoList, e -&gt; emptyIfNull(map.get(studentVo.getId())).contains(e.getId()));
: V7 k5 ^- K- G! W$ D* P            // 填充分数
$ b6 u1 I: D! E4 `' Z" l            list.forEach(e -&gt; e.setScore(table.get(studentVo.getId(), e.getId())));
            studentVo.setSubList(list);
        }
. |2 _5 {+ r4 x7 \) F    }
/ ]1 n+ I, g# ]6 V2 n1 N: x# M    return studentVoList;
}
2 j5 G* m* J* O4 |- d" ]; i' z</code></pre>
- ]$ j; `+ t$ Y+ A" g5 \2 r<h5 id="2理论分析-7">2、理论分析</h5>
" d5 b5 N/ f& M2 A$ @$ t6 z<p>多对多N条记录查询由于使用了批查询，因此最多访问数据库也是3次，先查询学生信息，然后查询学生与课程匹配信息，最后查询课程分数信息，查询时间复杂度为<code>O(1)</code>。</p>
<h4 id="三查询多条记录分页-2">（三）查询多条记录（分页）</h4>
' _% S' f9 c2 {9 K% s# o# p$ T& @7 q<h5 id="1示例代码-8">1、示例代码</h5>
<pre><code class="language-java">public IPage&lt;StudentVo&gt; getStudentPage(IPage&lt;Student&gt; page) {
    // 通过主键查询学生信息
7 t4 ~# Q$ o7 y7 Z3 z* ~* z    IPage&lt;StudentVo&gt; studentVoPage = ConvertUtils.convertPage(page(page), StudentVo::new);
. {# S- o6 v2 i$ e! n% }    // 批量查询学生ID
0 R* q9 G3 z0 [6 z) _7 B    Set&lt;Integer&gt; stuIds = studentVoPage.getRecords().stream().map(Student::getId).collect(toSet());
! N" j$ m  e9 H' m* p, a7 M    LambdaQueryWrapper&lt;StuSubRelation&gt; wrapper = Wrappers.lambdaQuery(StuSubRelation.class).in(StuSubRelation::getStuId, stuIds);
    // 通过学生ID查询课程分数
& `% U- L2 X' b: X' F0 v9 B3 C    List&lt;StuSubRelation&gt; stuSubRelations = stuSubRelationMapper.selectList(wrapper);
2 {5 w3 B! M+ Z4 ^; T6 G    // 批量查询课程ID
. v1 s$ h; Q2 c3 V    Set&lt;Integer&gt; subIds = stuSubRelations.stream().map(StuSubRelation::getSubId).collect(toSet());
    if (stuIds.size() &gt; 0 &amp;&amp; subIds.size() &gt; 0) {
/ Z6 `: u0 @3 |+ X  h- G        HashBasedTable&lt;Integer, Integer, Integer&gt; table = getHashBasedTable(stuSubRelations);
" c) y' ]6 B, v, G% U        // 学生ID查询课程ID组
        Map&lt;Integer, List&lt;Integer&gt;&gt; map = stuSubRelations.stream().collect(groupingBy(StuSubRelation::getStuId, mapping(StuSubRelation::getSubId, toList())));
0 L4 x! Q, H) n0 a8 b0 i
5 w5 o( l& X8 L% x% s( b3 p, F/ w4 S        List&lt;Subject&gt; subList = subjectMapper.selectList(Wrappers.lambdaQuery(Subject.class).in(Subject::getId, subIds));
        List&lt;SubjectBo&gt; subBoList = ConvertUtils.convertList(subList, SubjectBo::new);
        for (StudentVo studentVo : studentVoPage.getRecords()) {
            List&lt;SubjectBo&gt; list = ListUtils.select(subBoList, e -&gt; emptyIfNull(map.get(studentVo.getId())).contains(e.getId()));
            list.forEach(e -&gt; e.setScore(table.get(studentVo.getId(), e.getId())));
            studentVo.setSubList(list);
        }
    }
7 i+ k' @6 u' A& Z' w    return studentVoPage;
; m0 }! l/ G! ?( F8 K4 J& @}
</code></pre>
: W1 }( [6 G' o  K8 b5 u$ G9 _4 P. d<h5 id="2理论分析-8">2、理论分析</h5>
<p>多对多N条记录分页查询由于使用了批查询，因此最多访问数据库也是3次，先查询学生信息，然后查询学生与课程匹配信息，最后查询课程分数信息，查询时间复杂度为<code>O(1)</code>。</p>
7 e# G( P( W& B- x4 |<h3 id="五总结与拓展">五、总结与拓展</h3>
<h4 id="一总结">（一）总结</h4>
5 h+ c+ S: W$ H0 {8 i- I6 C. d<p>通过上述分析，能够用 MybatisPlus 解决多表连接查询中的<code>一对一</code>、<code>一对多</code>、<code>多对多</code>查询。</p>
<ul>
<li>上述代码行文紧凑，充分利用 IDE 对 Lambda 表达式的支持，在编译期间完成对代码的检查。</li>
<li>业务逻辑清晰，可维护性、可修改性优势明显。</li>
4 R/ t2 s- g) C0 P' Y, E) X<li>一次查询需要访问至多两次数据库，时间复杂度为<code>o(1)</code>，主键查询或者索引查询，查询效率高。</li>
# o: Z' r/ ^! B</ul>
<h4 id="二拓展">（二）拓展</h4>
<p>MybatisPlus能很好的解决单表查询问题，同时借助在单表查询的封装能很好地解决连接查询问题。</p>
# G  @; |6 R& K8 g6 R<p>本方案不仅解决了连接查询问题，同时具备如下内容拓展：</p>
- w# t7 s' f6 J$ o/ h* Y<ul>
<li>当数据量较大时，仍然具有稳定的查询效率</li>
</ul>
0 ]# \3 G3 Y; c. P( q% m; H<p>当数据量达到百万级别时，传统的单表通过索引查询已经面临挑战，普通的多表连接查询性能随着数据量的递增呈现指数级下降。</p>
4 O" \' g" |0 j6 c<p>本方案通过将连接查询转化为主键（索引）查询，查询性能等效于单表查询。</p>
<ul>
( N9 S. ]& ~" E" l8 s( ]2 b3 f<li>与二级缓存配合使用进一步提高查询效率</li>
</ul>
3 z* _, R6 b1 N/ D  @# i& k<p>当所有的查询均转化为以单表为基础的查询后，方能安全的引入二级缓存。二级缓存的单表增删改查操作自适应联动，解决了二级缓存的脏数据问题。</p>
0 E: l1 W- y! m<p><img src="https://img2022.cnblogs.com/blog/2731108/202202/2731108-20220212103110902-776916010.jpg" ></p>
- J& q% ^3 N, w  ~5 M, N
  E: {) z( J( {* @: {