勤能补拙 !

步骤 :

1. 明需求 --> 2.表设计 --> 3.类设计 -->4. 编写Mapper接口和Mapper.xml -->5.编写测试类

   注意事项 :

   保存
   除了往各自表存入数据以外，还要往中间表插入关系数据
   查询
   使用额外SQL collection select column property
   删除
   硬删除，所以除了删除本表的数据以外，还要从中间表中删除与被删除的数据相关的关系数据

   
   
   image-20200530190818108.png

单向多对多之保存

1.需求 :

保存两个学生和两个老师，且这两个老师都教了两个学生。

思路 : 2 学生 2老师 这 2 个老师 都是 教过这 2 个学生的老师

2. 表设计 :
   image-20200530153433128.png
   
   

   类设计 :

定义好 : 学生类 和 老师类

@Setter
@Getter
@ToString
public class Student {
    private Long id;
    private String name;
    // 关联属性
    private List<Teacher> teachers = new ArrayList<>();
}

@Setter
@Getter
@ToString
public class Teacher {
    private Long id;
    private String name;
}

4.编写 Mapper 接口 和 Mapper.xml

StudentMapper 接口 和 StudentMapper.xml

//需求 :  1.保存两个学生和两个老师，且这两个老师都教了这个两个学生。
public interface StudentMapper {
    //保存在 student 表

    void save(Student student);

    //保存到 中间表
    //多个参数 , 必须贴注解
    void insertRelation(@Param("teacherId") Long teacherId, @Param("studentId") Long studentId);

}

<mapper namespace="cn.wolfcode.mapper.StudentMapper">
    
    <!--保存 学生表的数据-->
    <insert id="save" useGeneratedKeys="true" keyProperty="id">
        INSERT INTO student (name) VALUES (#{name})
    </insert>

    <!--保存 中间表的数据-->
    <insert id="insertRelation">
      INSERT INTO teacher_student (teacher_id,student_id) VALUES (#{teacherId},#{studentId})
    </insert>

</mapper>

TeacherMapper 接口 和 TeacherMapper.xml

public interface TeacherMapper {
    //保存 老师表 操作
    void save(Teacher teacher);
}

<mapper namespace="cn.wolfcode.mapper.TeacherMapper">
    <!--保存 老师表的数据-->
   <insert id="save" useGeneratedKeys="true" keyProperty="id">
       INSERT INTO teacher (name) VALUES (#{name})
   </insert>
</mapper>

5.编写测试 方法

public class Many2ManyTest {
    @Test
    public void testSave(){
        //保存两个学生和两个老师，且这两个老师都教了这个两个学生。
        //创建两个学生
        //获取Mapper接口

        Student s1 = new Student();
        Student s2 = new Student();
        //给这两个学生起名字
        s1.setName("小勋");
        s2.setName("小欣");

        //创建两个老师
        Teacher t1=new Teacher();
        Teacher t2=new Teacher();
        //给这两个老师起名字
        t1.setName("吴老师");
        t2.setName("罗老师");
        //s1 被 两个老师教
        s1.getTeachers().add(t1);
        s1.getTeachers().add(t2);

        //s2 也是被这两个老师教
        s2.getTeachers().add(t1);
        s2.getTeachers().add(t2);

        SqlSession session = MyBatisUtil.getSession();
        StudentMapper studentMapper = session.getMapper(StudentMapper.class);
        TeacherMapper teacherMapper = session.getMapper(TeacherMapper.class);

        //学生的保存操作
        studentMapper.save(s1);
        studentMapper.save(s2);

        //老师的保存操作
        teacherMapper.save(t1);
        teacherMapper.save(t2);

        //中间表保存操作
        //关系  s1 俩个老师  s2 两个老师
        //保存 中间表 数据 这是 学生s1 的对应老师数据
        for (Teacher t:s1.getTeachers()) {
            studentMapper.insertRelation(t.getId(),s1.getId());
        }
        //保存 中间表 数据 这是 学生s2 的对应老师数据
        for(Teacher t:s2.getTeachers()){
            studentMapper.insertRelation(t.getId(),s2.getId());
        }
        //开启事务
        session.commit();
        //关闭资源
        session.close();
        /**
         * 注意  : 需要先保存 学生和老师 , 在保存中间表 , 否则 中间表没有数据 . 你懂得!
         */

    }
}

单向多对多之额外 SQL 查询

步骤 :

1. 明需求 --> 2.Mapper 接口 和 Mapper.xml 文件编写 -->3.测试
   1. 需求 : 根据 id 查询学生，并查询其老师。
   2. Mapper 接口 和 Mapper.xml 文件编写

public interface StudentMapper {
    //需求 : 根据 id 查询学生，并查询其老师。
    Student get(Long id);
}

  <resultMap id="baseResultMap" type="student">
        <result column="id" property="id"></result>
        <result column="name" property="name"></result>
        <collection column="id" property="teachers" select="cn.wolfcode.mapper.TeacherMapper.queryByStudentId">
        </collection>
    </resultMap>
    <select id="get" resultMap="baseResultMap">
        SELECT id,name FROM student where id=#{id}
    </select>

public interface TeacherMapper {
}

<select id="queryByStudentId" resultType="Teacher">
    SELECT t.id, t.name FROM teacher_student ts
    JOIN teacher t
    ON ts.teacher_id=t.id
    WHERE ts.student_id=#{studentId}
    <!--这里的 #{studentId} 可以随便-->
</select>

3.测试

 //根据 id 查询学生，并查询其老师。
        @Test
        public void testGet() throws Exception {
            SqlSession session = MyBatisUtil.getSession();
            StudentMapper studentMapper = session.getMapper(StudentMapper.class);
            Student student = studentMapper.get(2L);
            System.out.println(student);
            session.close();
    }

3. 单向多对多之删除

   1.明需求 --> 2.Mapper 接口 和 Mapper.xml 文件编写 -->3.测试

1.需求 :

根据 id 删除学生。

2.Mapper 接口 和 Mapper.xml 文件编写

void delete(Long id); //不能只写这个 , 否则 删不干净!

void deleteRelation(Long studentId);

<!--删除 student表 对应id的数据-->
<delete id="delete"> DELETE FROM student WHERE id = #{id} </delete>

<!--删除中间表对应的数据-->
<delete id="deleteRelation"> DELETE FROM teacher_student WHERE student_id = #{studentId} </delete>

3.测试

 @Test
    public void testDelete() throws Exception {
        SqlSession session = MyBatisUtil.getSession();
        StudentMapper studentMapper = session.getMapper(StudentMapper.class);
        studentMapper.delete(1L);
        studentMapper.delRelation(1L);
        session.commit();
        session.close();
    }