MyBatis【五】多对一及一对多的处理

十、多对一处理

多对一的理解：

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

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),
	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，引入 Maven 依赖
2. 新建实体类 Teacher、Student，添加 Lombok 注解

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

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

3. 建立 Mapper 接口（两个）

4. 建立 Mapper.xml 文件（两个）【无论有没有需求，都应该写上，以备后来之需！】

5. 在核心配置文件中绑定注册 Mapper 接口或者文件【方式多种，根据 xml 文件配置或注解配置来选择】

6. 测试查询是否能够成功

需求：查询所有学生信息，以及对应的老师的信息

SQL 语句：

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

在 StudentMapper.xml 文件中进行配置，有如下两种方法：

方法一：按照查询嵌套处理（类似于 SQL 中的子查询）

<!--思路：
    1.查询所有学生信息
    2.根据查询出来的学生的 tid ，寻找对应的老师     子查询
	3.学生的结果集中应该包含老师
		1. 做一个结果集映射：StudentTeacher
        2. StudentTeacher结果集的类型为 Student
        3. 学生中老师的属性为teacher，对应数据库中为tid。
              多个 [1,...）学生关联一个老师=> 一对一，一对多
        4. 查看官网找到：association – 一个复杂类型的关联；使用它来处理关联查询
-->
<select id="getStudent" resultMap="StudentTeacher">
    select * from student
</select>

<resultMap id="StudentTeacher" type="Student">
    <result property="id" column="id"/>
    <result property="name" column="name"/>
    <!--复杂的属性需要单独处理   property属性名 javaType属性类型 column在多的一方的表中的列名
		对象：association  集合：collection -->
    <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
    <!--<collection property=""/>-->
</resultMap>
<!--
   这里传递过来的 tid，只有一个属性的时候，下面可以写任何值
   association中column多参数配置：column="{key=value,key=value}"
       其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的字段名。
-->
<select id="getTeacher" resultType="Teacher">
    select * from teacher where id = #{tid}
</select>

测试结果：

方法二：按照结果嵌套处理（类似于 SQL 中的联表查询）

<!--按照结果嵌套处理-->
<select id="getStudent2" resultMap="StudentTeacher2">
  select s.id sid, s.name sname, t.name tname
  from student s, teacher t
  where s.tid = t.id;
</select>

<resultMap id="StudentTeacher2" type="Student">
    <result property="id" column="sid"/>
    <result property="name" column="sname"/>
    <!--关联对象 property 关联对象在 Student 实体类中的属性-->
    <association property="teacher" javaType="Teacher">
        <result property="name" column="tname"/>
    </association>
</resultMap>

测试结果：

十一、一对多处理

一对多的理解：

• 一个老师拥有多个学生
• 对于老师而言，就是一对多的关系

实体类

@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;
}

需求：获取指定老师下的所有学生及老师的信息

方法一：按照结果嵌套处理（类似于 SQL 中的联表查询）【推荐使用】

<!--按结果嵌套查询-->
<select id="getTeacher" resultMap="TeacherStudent">
    SELECT s.id sid, s.name sname, t.name tname, t.id tid
    FROM student s, teacher t
    WHERE s.tid = t.id and t.id = #{tid}
</select>

<resultMap id="TeacherStudent" type="Teacher">
    <result property="name" column="tname"/>
    <result property="id" column="tid"/>
    <!--复杂的属性需要单独处理 对象：association  集合：collection
			JavaType和ofType都是用来指定对象类型的
            javaType 指定 pojo 中属性的类型
            ofType指定的是映射到list集合属性中pojo的类型，即集合中的泛型信息
        -->
    <collection property="students" ofType="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <result property="tid" column="tid"/>
    </collection>
</resultMap>

测试结果：

Teacher(
    id=1, 
    name=秦老师, 
    students=[Student(id=1, name=小明, tid=1), Student(id=2, name=小红, tid=1), Student(id=3, name=小张, tid=1), Student(id=4, name=小李, tid=1), Student(id=5, name=小王, tid=1)])

方法二：按照查询嵌套处理（类似于 SQL 中的子查询）

<!--按查询嵌套处理-->
<select id="getTeacher2" resultMap="TeacherStudent2">
    select * from mybatis.teacher where id = #{tid}
</select>

<resultMap id="TeacherStudent2" type="Teacher">
    <!--column是一对多的外键 , 写的是一的主键的列名-->
    <collection property="students" javaType="ArrayList" ofType="Student" select="getStudentByTeacherId" column="id"/>
</resultMap>

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

测试结果：

Teacher(
    id=0, 
    name=秦老师, 
    students=[Student(id=1, name=小明, tid=1), Student(id=2, name=小红, tid=1), Student(id=3, name=小张, tid=1), Student(id=4, name=小李, tid=1), Student(id=5, name=小王, tid=1)])

小结：

1. 关联 - association 【多对一】

2. 集合 - collection 【一对多】

3. JavaType & ofType

   • JavaType 用来指定实体类中属性的类型
   • ofType 用来指定映射到 List 或者集合中的 pojo 类型，泛型中的约束类型

注意点：

• 保证 SQL 的可读性，尽量通俗易懂
• 根据实际要求，尽量编写性能更高的SQL语句
• 注意属性名和字段不一致的问题
• 注意一对多和多对一中，属性名和字段的问题
• 如果问题不好排查错误，可以使用日志，建议 Log4j

MyBatis【五】多对一及一对多的处理

原文：https://www.cnblogs.com/Songzw/p/13159503.html