一对多和多对一处理

1 多对一的处理

多对一的理解

在学校，班主任与学生之间的管理关系：

• 一个班主任管理多外学生 。即从班主任的角度来看：一个班主任关联多个学生(1:N)
• 一个学生只能有一个班对他进行管理。即从学生的角度来看：一个学生关联一个老师！(1:1)

1.1 数据库准备

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, '张老师');
INSERT INTO teacher(`id`, `name`) VALUES (2, '王老师');


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');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('6', '小强', '2');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('7', '小刘', '2');
INSERT INTO `student` (`id`, `name`, `tid`) VALUES ('8', '小明', '2');

1.2 搭建测试环境

1.2.1 IDEA安装Lombok插件

1.2.2 引入Maven依赖

<!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
<dependency>
 <groupId>org.projectlombok</groupId>
 <artifactId>lombok</artifactId>
 <version>1.16.10</version>
</dependency>

1.2.3 在代码中增加注解

@Data //GET,SET,ToString，有参，无参构造
public class Teacher {
   private int id;
   private String name;
}
@Data
public class Student {
   private int id;
   private String name;
   //多个学生可以是同一个老师，即多对一
   private Teacher teacher;
}

1.2.4 编写实体类对应的Mapper接口 【两个】

• 无论有没有需求，都应该写上，以备后来之需！

public interface StudentMapper {
}
public interface TeacherMapper {
}

1.2.5 编写Mapper接口对应的 mapper.xml配置文件 【两个】

• 无论有没有需求，都应该写上，以备后来之需！

<?xml versinotallow="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.kuang.mapper.StudentMapper">

</mapper>

<?xml versinotallow="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.kuang.mapper.TeacherMapper">
       
  <!--<select id="getTeacher" resultType="com.dzxx.jsj.pojo.Teacher">-->
     <!--select * from teacher where id = #{id}  -->
  <!--</select>  -->
</mapper>

1.3 按查询嵌套处理

1.3.1 给StudentMapper接口增加方法

//获取所有学生及对应老师的信息
public List<Student> getStudents();

1.3.2 编写对应的Mapper文件

<?xml versinotallow="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.kuang.mapper.StudentMapper">

   <!--
   需求：获取所有学生及对应老师的信息
   思路：
       1. 获取所有学生的信息
       2. 根据获取的学生信息的老师ID->获取该老师的信息
       3. 思考问题，这样学生的结果集中应该包含老师，该如何处理呢，数据库中我们一般使用关联查询？
           (1). 做一个结果集映射：StudentTeacher
           (2). StudentTeacher结果集的类型为 Student
           (3). 学生中老师的属性为teacher，对应Student数据库中为tid。
              多个学生关联一个老师=> 多对一 ， 一对一
           (4). 查看官网找到：association 一个复杂类型的关联；使用它来处理关联查询
   -->
    <!--方式1： 无需在TeacherMapper.xml写映射 -->
<!--<resultMap id="StudentTeacher" type="Student">-->
<!-- <id property="id" column="id"/>-->
<!-- <result property="name" column="name"/>-->
<!-- <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>-->
<!-- <association property="teacher" column="{id=tid,name=tid}" javaType="Teacher" select="getTeacher"/>-->

<!--</resultMap>-->

<!--    <select id="getTeacher" resultType="teacher">-->
<!--      select * from teacher where id = #{id}-->
<!--   </select>-->

<!--    <select id="getStudents" resultMap="StudentTeacher">-->
<!--        select * from student-->
<!--    </select>-->
<!--===================================-->
    <!--方式2：需在TeacherMapper.xml 中编写SQL映射 -->
    <resultMap id="StudentTeacher" type="Student">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <association property="teacher" column="tid" javaType="Teacher"
                     select="com.dzxx.jsj.mapper.TeacherMapper.getTeacher"/>
    </resultMap>

    <select id="getStudents" resultMap="StudentTeacher">
        select * from student
    </select>
</mapper>

1.3.3 编写完毕去Mybatis配置文件中，注册Mapper！

1.3.4 注意点说明

column="{prop1=col1,prop2=col2}"

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

1.3.5 测试

@Test
public void testGetStudents(){
   SqlSession session = MybatisUtils.getSession();
   StudentMapper mapper = session.getMapper(StudentMapper.class);

   List<Student> students = mapper.getStudents();

   for (Student student : students){
       System.out.println(
               "学生名:"+ student.getName()
                       +"\t老师:"+student.getTeacher().getName());
  }
}

1.4 按结果嵌套处理

除了上面方式，还有其他思路吗？

我们还可以按照结果进行嵌套处理；方式3

1.4.1 接口方法编写

public List<Student> getStudents2();

1.4.2 编写对应的mapper文件

<!--
按查询结果嵌套处理
思路：
   1. 直接查询出结果，进行结果集的映射
-->
<!--===========方式3：============-->
    <resultMap id="StudentTeacher2" type="Student">
        <id property="id" column="id"/>
        <result property="name" column="name"/>
        <association property="teacher" javaType="Teacher">
            <id property="tid" column="id"/>
            <result property="name" column="name"/>
        </association>
    </resultMap>

    <select id="getStudents" resultMap="StudentTeacher2">
        select student.*,t.name from student,teacher as t where student.tid = t.id
    </select>

1.4.3 去mybatis-config文件中注入mapper

1.4.4 测试

@Test
public void testGetStudents2(){
   SqlSession session = MybatisUtils.getSession();
   StudentMapper mapper = session.getMapper(StudentMapper.class);

   List<Student> students = mapper.getStudents2();

   for (Student student : students){
       System.out.println(
               "学生名:"+ student.getName()
                       +"\t老师:"+student.getTeacher().getName());
  }
}

小结

按照查询进行嵌套处理就像SQL中的子查询

按照结果进行嵌套处理就像SQL中的联表查询

一对多处理

2 一对多的处理

2.1 一对多的理解：

• 在学校，班主任与学生之间的管理关系：

• 一个班主任管理多外学生 。即从班主任的角度来看：一个班主任关联多个学生(1:N)
• 一个学生只能有一个班对他进行管理。即从学生的角度来看：一个学生关联一个老师！(1:1)
• 
  
• 如果对于老师这边，就是一个一对多的现象，即从一个老师下面拥有一群学生（集合）！
• 
  

2.2 实体类编写

@Data
@ToString
public class Student {
   private Integer sno;
   private String sname;
   private Integer age;
   private Integer tid;  //一个学生对应一个老师
}

@Data //GET,SET,ToString，有参，无参构造
public class Teacher {
   private int tid;
   private String name;
   private List<Student> studentList;    //一个老师对应  多个学生
}

2.3 按结果嵌套处理

1、TeacherMapper接口编写方法

public interface TeacherMapper {
    public Teacher getTeacherById(int tid);
}

2、编写接口对应的Mapper配置文件

<?xml versinotallow="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.dzxx.jsj.mapper.TeacherMapper">


    <resultMap id="teacherResultMap" type="com.dzxx.jsj.pojo.Teacher">
        <collection property="studentList"
                    ofType="com.dzxx.jsj.pojo.Student"
                    column="tid"
                    select="findStudentByTid">
        </collection>
    </resultMap>

    <!--根据老师号查询-->
    <select id="getTeacherById" parameterType="int" resultMap="teacherResultMap">
         select tid,name  from teacher where tid = #{tid}
    </select>

    <!--根据学号查询-->
    <select id="findStudentByTid" parameterType="int" resultType="student">
         select sno,sname,age,tid  from student where tid = #{tid} 
    </select>

</mapper>

3、将Mapper文件注册到MyBatis-config文件中

<!-- mapping文件路径配置 -->
    <mappers>
        <package name="com.dzxx.jsj.mapper"/>
    </mappers>

4、测试

@Test
    public void testGetTeacherById(){
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);

        Teacher teacher = mapper.getTeacherById(2);
        System.out.println(teacher.toString());
    }

3 多对多的处理

3.1 一对多的理解：

• 在学校，学生与课程之间的选课关系：

• 一个班学生可以选修多门课程。
• 一门课程可以有多个学生选修。
• 
  
• 这样就形成了多对多的关系！这个多对多的关系在数据库中需要一个中门表来表示
• 
  

3.2 多对多关系数据库表

3.2.1 学生表

3.2.2 课程表

3.2.3 中间表

又称之为选课表或成绩单。

3.3 实体类编写

@Data
@ToString
public class Student {
   private Integer sno;
   private String sname;
   private Integer age;
   private Integer tid;
   private List<Course> courseList;  //一个学生会选修多门课程
}

@Data
@ToString
public class Course {
    private Integer cno;
    private String  cname;
}

@Data
@ToString
public class Sc {
    private Integer id;
    private Integer sno;
    private Integer cno;
    private Double score;
}

3.4 按结果嵌套处理

1、StudentMapper接口编写方法

public interface StudentMapper {
    //获取所有学生及对应老师的信息
    public List<Student> findStudentBySno(int sno);
    public List<Student> findAllStudents();
}

2、编写接口对应的Mapper配置文件

<?xml versinotallow="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.dzxx.jsj.mapper.StudentMapper">
    <resultMap id="courseResultMap" type="com.dzxx.jsj.pojo.Course">
        <id column="cno" property="cno"/>
        <result column="cname" property="cname"/>
    </resultMap>

    <resultMap id="studentResultMap" type="com.dzxx.jsj.pojo.Student" extends="courseResultMap">
<!--        <id property="sno" column="sno"></id>-->
<!--        <result property="sname" column="sname"/>-->
<!--        <result property="age" column="age"/>-->
<!--        <result property="tid" column="tid"/>-->
        <collection property="courseList"
                    ofType="com.dzxx.jsj.pojo.Course"
                    column="sno"
                    select="findCourseByCno">
        </collection>
    </resultMap>

    <!--根据学号查询-->
    <select id="findStudentBySno" parameterType="int" resultMap="studentResultMap">
         select sno,sname,age,tid  from student where sno = #{sno}
    </select>

    <select id="findCourseByCno" parameterType="int" resultType="com.dzxx.jsj.pojo.Course">
        select cno,cname from course
        where cno
        in(select cno from sc where sno = #{sno})
    </select>

    <!--根据学号查询-->
    <select id="findAllStudents" parameterType="int" resultMap="studentResultMap">
         select sno,sname,age,tid  from student
    </select>

</mapper>

3、将Mapper文件注册到MyBatis-config文件中

<!-- mapping文件路径配置 -->
    <mappers>
        <package name="com.dzxx.jsj.mapper"/>
    </mappers>

4、测试

@Test
    public void testFindStudentBySno(){
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        List<Student> students = mapper.findStudentBySno(2);

        for (Student student : students){
            System.out.println( "学生:"+ student.toString());                         ;
        }
    }
    @Test
    public void testFindAllStudents(){
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);

        List<Student> students = mapper.findAllStudents();

        for (Student student : students){
            System.out.println( "学生:"+ student.toString());                         ;
        }
    }

4 小结

1、关联-association

2、集合-collection

3、所以association是用于一对一和多对一，而collection是用于一对多的关系

4、JavaType和ofType都是用来指定对象类型的

• JavaType是用来指定pojo中属性的类型
• ofType指定的是映射到list集合属性中pojo的类型。

注意说明：

1、保证SQL的可读性，尽量通俗易懂

2、根据实际要求，尽量编写性能更高的SQL语句

3、注意属性名和字段不一致的问题

4、注意一对多和多对一 中：字段和属性对应的问题

5、尽量使用Log4j，通过日志来查看自己的错误