1.多对一的处理

1.1、数据库设计

实体类:

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

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

1.2按查询嵌套处理

studentmappe和studentmapper.xml :

public interface StudentMapper {
    //查询所有的学生信息以及对应的老师的信息
    List<Student> findAllStudent();
}

<?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">
<mapper namespace="com.rk.dao.StudentMapper">
    <!--
        需求：获取所有学生及对应老师的信息
            1. 获取所有学生的信息
            2. 根据获取的学生信息的老师ID->获取该老师的信息
            3. 思考问题，这样学生的结果集中应该包含老师，该如何处理呢，数据库中我们一般
        使用关联查询？
            1. 做一个结果集映射：StudentTeacher
            2. StudentTeacher结果集的类型为 Student
            3. 学生中老师的属性为teacher，对应数据库中为tid。多个 [1,...）学生关联一个老师=> 一对一，一对多
            4. 查看官网找到：association – 一个复杂类型的关联；使用它来处理关联查询
-->
        <select id="findAllStudent" resultMap="StudentTeacher">
            select * from student
        </select>

        <resultMap id="StudentTeacher" type="student">
            <!--association关联属性 property属性名 javaType属性类型 column在多
    的一方的表中的列名-->
            <association property="teacher" column="tid" javaType="teacher" select="getTeacher"></association>
        </resultMap>
       <!--
        这里传递过来的id，只有一个属性的时候，下面可以写任何值
        association中column多参数配置：
        column="{key=value,key=value}"
        其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的字段名-->
        <select id="getTeacher" resultType="teacher">
            select * from teacher where id=#{id}  //这个#{id}可以是任意名称
        </select>
</mapper>

测试:

    @Test
    public void testStudent(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> allStudent = mapper.findAllStudent();
        for (Student student : allStudent) {
            System.out.println(student);
        }
    }

测试结果:

1.3按结果嵌套处理

studentmapper和stedentmapper.xml

public interface StudentMapper {
    //查询所有的学生信息以及对应的老师的信息
    List<Student> findAllStudent2();
}

<?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">
<mapper namespace="com.rk.dao.StudentMapper">

    <select id="findAllStudent2"  resultMap="StudentTeacherd2">
        select s.id sid,s.name sname,t.name tname
        from student s,teacher t
        where s.tid=t.id;
    </select>

    <resultMap id="StudentTeacherd2" type="student">
        <id property="id" column="sid"></id>
        <result property="name" column="sname"></result>
        <association property="teacher" javaType="teacher">
            <result property="name" column="tname"></result>
        </association>
    </resultMap>
</mapper>

注意:resultMap中的映射的column是sql语句查询出来起的别名，如果没有别名，column就是s.id、s.name、t.name

嵌套的对象那写的是javaType="teacher"

测试结果:

2、一对多的处理

实体类:

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

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

2.1、按结果嵌套处理

TeacherMapper和TeacherMapper.xml:

public interface TeacherMapper {
    //获取指定老师下的所有学生
    Teacher getTeacherBytid(@Param("tid") int id);
}

<mapper namespace="com.rk.dao.TeacherMapper">

    <!--按结果嵌套查询-->
    <select id="getTeacherBytid" 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="id" column="tid"></result>
        <result property="name" column="tname"></result>
        <!--对象:association    集合:collection
            javaType:指定属性的类型
            集合中的泛型信息，我们使用ofType
        -->
        <collection property="students" ofType="student">
            <result property="id" column="sid"></result>
            <result property="name" column="sname"></result>
            <result property="tid" column="tid"></result>
        </collection>
    </resultMap>
</mapper>

        集合的话，使用collection
        JavaType和ofType都是用来指定对象类型的
        JavaType是用来指定pojo中属性的类型
        ofType指定的是映射到list集合属性中pojo的类型

测试:

    @Test
    public void testTeacher(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacherBytid = mapper.getTeacherBytid(2);
        System.out.println(teacherBytid);
    }

结果:

3、小结

        1. 关联-association
        2. 集合-collection
        3. 所以association是用于一对一和多对一，而collection是用于一对多的关系
        4. JavaType和ofType都是用来指定对象类型的
        JavaType是用来指定pojo中属性的类型
        ofType指定的是映射到list集合属性中pojo的类型。
注意说明：
        1. 保证SQL的可读性，尽量通俗易懂
        2. 根据实际要求，尽量编写性能更高的SQL语句
        3. 注意属性名和字段不一致的问题
        4. 注意一对多和多对一中：字段和属性对应的问题
        5. 尽量使用Log4j，通过日志来查看自己的错误

原文地址：https://blog.csdn.net/m0_46979453/article/details/122042163

Mybatis多对一，一对多的处理