MyBatis复杂结果映射----多对一、一对多查询【难点】

MyBatis 多对一、一对多查询

---

---

1. 多对一处理（联合）

多对一图示：

• 多个学生，对应一个老师
• 对于学生这边而言， 关联 … 多个学生，关联一个老师 【多对一】
• 对于老师而言， 集合 ， 一个老师，有很多学生 【一对多】

SQL：

CREATE TABLE `teacher` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8

INSERT INTO teacher(`id`, `name`) VALUES (1, '秦老师'); 

CREATE TABLE `student` (
  `id` INT(10) NOT NULL,
  `name` VARCHAR(30) DEFAULT NULL,
  `tid` INT(10) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `fktid` (`tid`),
  CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8


INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('1', '小明', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('2', '小红', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('3', '小张', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('4', '小李', '1'); 
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('5', '小王', '1');

环境搭建

1. 导入lombok
2. 新建实体类 Teacher，Student
3. 建立Mapper接口
4. 建立Mapper.XML文件
5. 在核心配置文件中绑定注册我们的Mapper接口或者文件！【方式很多，随心选】
6. 测试查询是否能够成功！

实体类

@Data
public class Student {
    private Integer id;
    private String name;
    //学生需要关联一个老师
    private Teacher teacher;
}

@Data
public class Teacher {
    private Integer id;
    private String name;
}

关联的嵌套 Select 查询（子查询）

	<!--执行一个单独的 SQL 语句来获取结果的一个列表-->
	<!--用来加载学生（Student）-->
    <select id="getStudents" resultMap="StudentTeacher">
        select *
        from student;
    </select>


	<!--类似于获取结果集后，每一条记录记录都做映射，执行其中的语句-->
    <resultMap id="StudentTeacher" type="Student">
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <association property="teacher" javaType="Teacher" 
                     select="getTeacher" column="tid" />
    </resultMap>


	<!--对列表返回的每条记录，你执行一个 select 查询语句来为每条记录加载详细信息-->
	<!--用来加载作者（Author）-->
    <select id="getTeacher" resultType="Teacher">
        select *
        from teacher
        where id = #{tid};
    </select>

就是这么简单。我们有两个 select 查询语句：一个用来加载学生（Studnet），另外一个用来加载老师（Teacher），

而且博客的结果映射描述了应该使用 getTeacher语句加载它的 teacher 属性。其它所有的属性将会被自动加

载，只要它们的列名和属性名相匹配。

这种方式虽然很简单，但在大型数据集或大型数据表上表现不佳。这个问题被称为“N+1 查询问题”。

概括地讲，N+1 查询问题是这样子的：

• 你执行了一个单独的 SQL 语句来获取结果的一个列表（就是“+1”）。
• 对列表返回的每条记录，你执行一个 select 查询语句来为每条记录加载详细信息（就是“N”）。

这个问题会导致成百上千的 SQL 语句被执行。有时候，我们不希望产生这样的后果。

所以还有另外一种方法。

关联的嵌套结果映射（联表查询）

	<!--执行一个单独的 SQL 语句来获取结果的一个列表-->
    <select id="getStudents" resultMap="StudentTeacher">
        select s.id sid, s.name sname, t.name tname, t.id tid
        from teacher t,
             student s
        where t.id = s.tid;
    </select>

	<!---将表中查出来的数据通过结果映射的方式加载生成实例对象-->
    <resultMap id="StudentTeacher" type="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="Teacher">
            <result property="id" column="tid"/>
            <result property="name" column="tname"/>
        </association>
    </resultMap>

在上面的例子中，你可以看到，老师（Teacher）和学生（student）的关联元素委托名为 “StudentTeacher” 的结果映射来加载学生对象的实例。

回顾Mysql 多对一查询方式：

• 子查询

select *
from teacher
where id = (
    select s.id
    from student s
);

• 联表查询

select s.id sid, s.name sname, t.name tname, t.id tid
from teacher t,
     student s
where t.id = s.tid;

2. 一对多处理（集合）

比如：一个老师拥有多个学生！

对于老师而言，就是一对多的关系!

环境搭建

实体类

@Data
public class Student {
    private int id;
    private String name;
    private int tid;
}

@Data
public class Teacher {
    private int id;
    private String name;
    //一个老师拥有多个学生
    private List<Student> students;
}

需求：查询一个老师对应这所有学生的信息！

集合的嵌套 Select 查询（子查询）

首先，让我们看看如何使用嵌套 Select 查询来为博客加载文章。

    <select id="getTeacherById" resultMap="TeacherStudent">
        select *
        from teacher
        where id = #{tid};
    </select>

    <resultMap id="TeacherStudent" type="Teacher">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        <collection property="students" javaType="ArrayList" ofType="Student"
                    select="getStudentInfo" column="id"/>
    </resultMap>

    <select id="getStudentInfo" resultType="Student">
        select * from student where tid=#{id};
    </select>

使用集合和上面的关联元素非常相似。 首先，你会注意到我们使用的是集合元素。 接下来你会注意到有一个新的

“ofType” 属性。这个属性非常重要，它用来将 JavaBean（或字段）属性的类型和集合存储的类型区分开来。 所以你

可以按照下面这样来阅读映射：

 <collection property="students" javaType="ArrayList" ofType="Student"
                    select="getStudentInfo" column="id"/>

读作： " students 是一个存储 Student 的 ArrayList 集合 "

在一般情况下，MyBatis 可以推断 javaType 属性，因此并不需要填写。所以很多时候你可以简略成：

<collection property="students" ofType="Student" select="getStudentInfo" column="id" />

集合的嵌套结果映射（联表查询）

现在你可能已经猜到了集合的嵌套结果映射是怎样工作的——除了新增的
“ofType” 属性，它和关联的完全相同。

首先, 让我们看看对应的 SQL 语句：

    <select id="getTeacherById" resultMap="TeacherStudent">
        select t.id tid, t.name tname, s.id sid, s.name sname
        from teacher t,
             student s
    </select>

    <resultMap id="TeacherStudent" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <collection property="students" javaType="ArrayList" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

如果你喜欢更详略的、可重用的结果映射，你可以使用下面的等价形式：

 <resultMap id="TeacherStudent" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <collection property="students" javaType="ArrayList" ofType="Student" 
                    resultMap="getStudentInfo">
        </collection>
    </resultMap>

<resultMap id="getStudentInfo" type="Student">
    <result property="id" column="sid"/>
    <result property="name" column="sname"/>
    <result property="tid" column="tid"/>
</resultMap>

补充：3. 鉴别器

初识discriminator

<discriminator javaType="int" column="draft">
  <case value="1" resultType="DraftPost"/>
</discriminator>

有时候，一个数据库查询可能会返回多个不同的结果集（但总体上还是有一定的联系的）。 鉴别（discriminator）

元素就是被设计来应对这种情况的，另外也能处理其它情况，例如类的继承层次结构。 鉴别器的概念很好理解——

它很像 Java 语言中的 switch 语句。

一个鉴别器的定义需要指定 column 和 javaType 属性。column 指定了 MyBatis 查询被比较值的地方。 而 javaType 用

来确保使用正确的相等测试（虽然很多情况下字符串的相等测试都可以工作）。例如：

<resultMap id="vehicleResult" type="Vehicle">
  <id property="id" column="id" />
  <result property="vin" column="vin"/>
  <result property="year" column="year"/>
</resultMap>

<resultMap id="carResult" type="Car">
  <result property="doorCount" column="door_count" />
</resultMap>

<discriminator javaType="int" column="vehicle_type">
    <case value="1" resultMap="vehicleResult"/>
    <case value="2" resultMap="carResult"/>
</discriminator>

复杂查询小结

1. 关联 - association 【多对一】
2. 集合 - collection 【一对多】
3. javaType & ofType
   1. JavaType 用来指定实体类中属性的类型
   2. ofType 用来指定映射到List或者集合中的 pojo类型，泛型中的约束类型！

注意点：

• 保证SQL的可读性，尽量保证通俗易懂
• 注意一对多和多对一中，属性名和字段的问题！
• 如果问题不好排查错误，可以使用日志 ， 建议使用 Log4j

注：内容转自狂神说 MyBatis 课堂笔记 + 理解总结
建议：关注 b站 狂神说JAVA              查看官方文档