MyBatis: many, many-to-handle

Many-to-handle

Many-to-understand:

Corresponding to a plurality of student teacher
If a student here for, is a many-to-phenomenon that is associated with a teacher from a student here!

Database Design

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');

Set up a test environment

[Use] in Lombok

IDEA plug-in installation Lombok

Maven relies introduced

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

Notes increase in code

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

Mapper prepared entity class corresponding to two interfaces []
- Whether there is no demand, should be written on, need to prepare for it later!
```
public interface StudentMapper {
}
```
```
public interface TeacherMapper {
}
```

Write Mapper interface corresponds to the profile of mapper.xml [two]

Whether there is no demand, should be written on, need to prepare for it later!

<?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.kuang.mapper.StudentMapper"> </mapper>

<?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.kuang.mapper.TeacherMapper"> </mapper>

Press nested query processing

To increase the interface method StudentMapper

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

Mapper to prepare corresponding documents

<?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.kuang.mapper.StudentMapper"> <!-- 需求：获取所有学生及对应老师的信息 思路： 1. 获取所有学生的信息 2. 根据获取的学生信息的老师ID->获取该老师的信息 3. 思考问题，这样学生的结果集中应该包含老师，该如何处理呢，数据库中我们一般使用关联查询？ 1. 做一个结果集映射：StudentTeacher 2. StudentTeacher结果集的类型为 Student 3. 学生中老师的属性为teacher，对应数据库中为tid。 多个 [1,...）学生关联一个老师=> 一对一，一对多 4. 查看官网找到：association – 一个复杂类型的关联；使用它来处理关联查询 --> <select id="getStudents" resultMap="StudentTeacher"> select * from student </select> <resultMap id="StudentTeacher" type="Student"> <!--association关联属性 property属性名 javaType属性类型 column在多的一方的表中的列名--> <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/> </resultMap> <!-- 这里传递过来的id，只有一个属性的时候，下面可以写任何值 association中column多参数配置： column="{key=value,key=value}" 其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的字段名。 --> <select id="getTeacher" resultType="teacher"> select * from teacher where id = #{id} </select> </mapper>

Mybatis write to the configuration file is completed, the registered Mapper!

Note Point Description:

<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="{key=value,key=value}" 其实就是键值对的形式，key是传给下个sql的取值名称，value是片段一中sql查询的字段名。 --> <select id="getTeacher" resultType="teacher"> select * from teacher where id = #{id} and name = #{name} </select>

test

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

According to the results of a nested processing

In addition to the above in this way, there are other ideas do?

We can also be nested process in accordance with the results;

Write interface method
```
public List<Student> getStudents2();
```

Write the corresponding mapper file

<!--
按查询结果嵌套处理
思路：
    1. 直接查询出结果，进行结果集的映射
-->
<select id="getStudents2" 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"> <id property="id" column="sid"/> <result property="name" column="sname"/> <!--关联对象property 关联对象在Student实体类中的属性--> <association property="teacher" javaType="Teacher"> <result property="name" column="tname"/> </association> </resultMap>

Mybatis-config file to inject [the] here should be treated

test

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

summary

Like nested query processing in accordance with sub-query in SQL
Nested process in accordance with the results of SQL queries as inline table in

Many processing

Many understand:

A teacher with more students
If a teacher here for, is to many a phenomenon that has a group of students from a teacher below (collection)!

Entity class writing

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

..... As before, set up a test environment!

According to the results of a nested processing

Write a method TeacherMapper Interface

//获取指定老师，及老师下的所有学生
public Teacher getTeacher(int id);

Interface Mapper to prepare the corresponding configuration file

<mapper namespace="com.kuang.mapper.TeacherMapper">

    <!-- 思路: 1. 从学生表和老师表中查出学生id，学生姓名，老师姓名 2. 对查询出来的操作做结果集映射 1. 集合的话，使用collection！ JavaType和ofType都是用来指定对象类型的 JavaType是用来指定pojo中属性的类型 ofType指定的是映射到list集合属性中pojo的类型。 --> <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=#{id} </select> <resultMap id="TeacherStudent" type="Teacher"> <result property="name" column="tname"/> <collection property="students" ofType="Student"> <result property="id" column="sid" /> <result property="name" column="sname" /> <result property="tid" column="tid" /> </collection> </resultMap> </mapper>

The registration Mapper file to MyBatis-config file

<mappers>
    <mapper resource="mapper/TeacherMapper.xml"/> </mappers>

test

@Test
public void testGetTeacher(){ SqlSession session = MybatisUtils.getSession(); TeacherMapper mapper = session.getMapper(TeacherMapper.class); Teacher teacher = mapper.getTeacher(1); System.out.println(teacher.getName()); System.out.println(teacher.getStudents()); }

Press nested query processing

Write a method TeacherMapper Interface
```
public Teacher getTeacher2(int id);
```

Interface Mapper to prepare the corresponding configuration file

<select id="getTeacher2" resultMap="TeacherStudent2"> select * from teacher where id = #{id} </select> <resultMap id="TeacherStudent2" type="Teacher"> <!--column是一对多的外键 , 写的是一的主键的列名--> <collection property="students" javaType="ArrayList" ofType="Student" column="id" select="getStudentByTeacherId"/> </resultMap> <select id="getStudentByTeacherId" resultType="Student"> select * from student where tid = #{id} </select>

The registration Mapper file to MyBatis-config file

test

@Test
public void testGetTeacher2(){ SqlSession session = MybatisUtils.getSession(); TeacherMapper mapper = session.getMapper(TeacherMapper.class); Teacher teacher = mapper.getTeacher2(1); System.out.println(teacher.getName()); System.out.println(teacher.getStudents()); }

summary

Associated -association
-Collection collection
So the association is many-to-one and, while the collection is for one to many relationship
JavaType ofType and are used to specify the type of the object
- JavaType attribute is used to specify the type of pojo
- ofType specified list is mapped to a set of attribute types of pojo.

Note Note:

Ensure the readability of SQL, as accessibly
According to the actual requirements, try to write higher performance of SQL statements
Note that the property name field problems and inconsistencies
Note that in many and many-: question field corresponding to the attribute and
Try to use Log4j, to see their own mistakes by log