多对一的处理
多对一的理解:
-
多个学生对应一个老师
-
如果对于学生这边,就是一个多对一的现象,即从学生这边关联一个老师!
先编写数据库
pojo Student.class
import lombok.Data;
@Data
public class Student {
private int id;
private String name;
//多个学生可以是同一个老师,即多对一
private Teacher teacher;
}
pojo Teacher.class
import lombok.Data;
@Data //GET,SET,ToString,有参,无参构造
public class Teacher {
private int id;
private String name;
}
StudentMapper.class
public interface StudentMapper {
//嵌套查询 查询所有的学生信息和对应的老师信息
List<Student> getStudent();
//嵌套结果
List<Student> getStudent2();
}
StudentMapper.xml
嵌套结果
<select id="getStudent2" resultMap="StudentTeacher2">
select student.id sid,student.name sname,teacher.name tname
from student,teacher
where student.tid=teacher.id
</select>
<resultMap id="StudentTeacher2" type="com.wjc.pojo.Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<association property="teacher" javaType="Teacher">
<result property="id" column="sid"/>
<result property="name" column="tname"/>
</association>
</resultMap>
嵌套查询
<!-- 查询语句,绑定查询方法-->
<select id="getStudent" resultMap="StudentTeacher">
select * from student
</select>
<resultMap id="StudentTeacher" type="Student">
<result property="id" column="id"/>
<result property="name" column="name"/>
<!-- 复杂的属性我们要单独处理
对象:association
集合:collection-->
<association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
</resultMap>
<select id="getTeacher" resultType="com.wjc.pojo.Teacher">
select * from teacher where id=#{tid}
</select>
我们可以看出嵌套结果更加直接明了,嵌套查询更类似于sql子语句的意思。
@Test
public void getStudent(){
//1.获取SqlSession对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
//2.方式一:getMapper
StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
List<Student> student = mapper.getStudent();
for (Student student1 : student) {
System.out.println(student1);
}
}
@Test
public void getStudent2(){
//1.获取SqlSession对象
SqlSession sqlSession = MybatisUtils.getSqlSession();
//2.方式一:getMapper
StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
List<Student> student = mapper.getStudent2();
for (Student student2 : student) {
System.out.println(student2);
}
}
这两种方式都能查询到结果!
一对多的处理
一对多的理解:
-
一个老师拥有多个学生
-
如果对于老师这边,就是一个一对多的现象,即从一个老师下面拥有一群学生(集合)!
实体类编写
@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;
}
TeacherMapper.class
public interface TeacherMapper {
//获取指定老师下的所有学生信息和老师信息
Teacher getTeacher(@Param("tid") int id);
}
嵌套结果
<select id="getTeacher" resultMap="TeacherStudent">
select s.id sid,s.name sname,t.id tid,t.name tname
from teacher t,student s
where s.tid=t.id and t.id=#{tid}
</select>
<resultMap id="TeacherStudent" type="com.wjc.pojo.Teacher">
<result property="id" column="tid"/>
<result property="name" column="tname"/>
<!--复杂的属性,我们需要单独处理对象: association 集合: collectionjavaType=""”指定属性的类型!
集合中的泛型信息,我们使用ofType获取-->
<collection property="students" ofType="Student">
<result property="id" column="sid"/>
<result property="name" column="sname"/>
<result property="tid" column="tid"/>
</collection>
</resultMap>
嵌套查询
<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>
小结
1、对象-association
2、集合-collection
3、所以association是用于一对一和多对一,而collection是用于一对多的关系
4、JavaType和ofType都是用来指定对象类型的
-
JavaType是用来指定pojo中属性的类型
-
ofType指定的是映射到list集合属性中pojo的类型。
注意说明:
1、保证SQL的可读性,尽量通俗易懂
2、根据实际要求,尽量编写性能更高的SQL语句
3、注意属性名和字段不一致的问题
4、注意一对多和多对一 中:字段和属性对应的问题
5、尽量使用Log4j,通过日志来查看自己的错误
注意说明:
1、保证SQL的可读性,尽量通俗易懂
2、根据实际要求,尽量编写性能更高的SQL语句
3、注意属性名和字段不一致的问题
4、注意一对多和多对一 中:字段和属性对应的问题
5、尽量使用Log4j,通过日志来查看自己的错误