十三、MyBatis的高级映射及延迟加载
模块名：mybatis-009-advanced-mapping
打包方式：jar
依赖：mybatis依赖、mysql驱动依赖、junit依赖、logback依赖
配置文件：mybatis-config.xml、logback.xml、jdbc.properties
拷贝工具类：SqlSessionUtil
准备数据库表：一个班级对应多个学生。班级表：t_clazz。学生表：t_student
创建pojo：Student、Clazz
package com.study.mybatis.pojo;
/**
* 学生类
* @author sqnugy
* @version 1.0
* @since 1.0
*/
public class Student {
private Integer sid;
private String sname;
//......
}
package com.study.mybatis.pojo;
/**
* 班级类
* @author sqnugy
* @version 1.0
* @since 1.0
*/
public class Clazz {
private Integer cid;
private String cname;
//......
}
创建mapper接口：StudentMapper、ClazzMapper
创建mapper映射文件：StudentMapper.xml、ClazzMapper.xml
13.1 多对一
多种方式，常见的包括三种：
- 第一种方式：一条SQL语句，级联属性映射。
- 第二种方式：一条SQL语句，association。
- 第三种方式：两条SQL语句，分步查询。（这种方式常用：优点一是可复用。优点二是支持懒加载。）
第一种方式：级联属性映射
pojo类Student中添加一个属性：Clazz clazz; 表示学生关联的班级对象。
package com.study.mybatis.pojo;
/**
* 学生类
* @author sqnugy
* @version 1.0
* @since 1.0
*/
public class Student {
private Integer sid;
private String sname;
private Clazz clazz;
public Clazz getClazz() {
return clazz;
}
public void setClazz(Clazz clazz) {
this.clazz = clazz;
}
@Override
public String toString() {
return "Student{" +
"sid=" + sid +
", sname='" + sname + '\'' +
", clazz=" + clazz +
'}';
}
public Student() {
}
public Student(Integer sid, String sname) {
this.sid = sid;
this.sname = sname;
}
public Integer getSid() {
return sid;
}
public void setSid(Integer sid) {
this.sid = sid;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
}
<?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.study.mybatis.mapper.StudentMapper">
<resultMap id="studentResultMap" type="Student">
<id property="sid" column="sid"/>
<result property="sname" column="sname"/>
<result property="clazz.cid" column="cid"/>
<result property="clazz.cname" column="cname"/>
</resultMap>
<select id="selectBySid" resultMap="studentResultMap">
select s.*, c.* from t_student s join t_clazz c on s.cid = c.cid where sid = #{sid}
</select>
</mapper>
package com.study.mybatis.test;
import com.study.mybatis.mapper.StudentMapper;
import com.study.mybatis.pojo.Student;
import com.study.mybatis.utils.SqlSessionUtil;
import org.junit.Test;
public class StudentMapperTest {
@Test
public void testSelectBySid(){
StudentMapper mapper = SqlSessionUtil.openSession().getMapper(StudentMapper.class);
Student student = mapper.selectBySid(1);
System.out.println(student);
}
}
执行结果：
第二种方式：association
其他位置都不需要修改，只需要修改resultMap中的配置：association即可。
<resultMap id="studentResultMap" type="Student">
<id property="sid" column="sid"/>
<result property="sname" column="sname"/>
<association property="clazz" javaType="Clazz">
<id property="cid" column="cid"/>
<result property="cname" column="cname"/>
</association>
</resultMap>
association翻译为：关联。
学生对象关联一个班级对象。
第三种方式：分步查询
其他位置不需要修改，只需要修改以及添加以下三处：
第一处：association中select位置填写sqlId。sqlId=namespace+id。其中column属性作为这条子sql语句的条件。
<resultMap id="studentResultMap" type="Student">
<id property="sid" column="sid"/>
<result property="sname" column="sname"/>
<association property="clazz"
select="com.study.mybatis.mapper.ClazzMapper.selectByCid"
column="cid"/>
</resultMap>
<select id="selectBySid" resultMap="studentResultMap">
select s.* from t_student s where sid = #{sid}
</select>
第二处：在ClazzMapper接口中添加方法
package com.study.mybatis.mapper;
import com.study.mybatis.pojo.Clazz;
/**
* Clazz映射器接口
* @author sqnugy
* @version 1.0
* @since 1.0
*/
public interface ClazzMapper {
/**
* 根据cid获取Clazz信息
* @param cid
* @return
*/
Clazz selectByCid(Integer cid);
}
第三处：在ClazzMapper.xml文件中进行配置
<?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.study.mybatis.mapper.ClazzMapper">
<select id="selectByCid" resultType="Clazz">
select * from t_clazz where cid = #{cid}
</select>
</mapper>
执行结果，可以很明显看到先后有两条sql语句执行：
分步优点：
- 第一个优点：代码复用性增强。
- 第二个优点：支持延迟加载。【暂时访问不到的数据可以先不查询。提高程序的执行效率。】
13.2 多对一延迟加载
要想支持延迟加载，非常简单，只需要在association标签中添加fetchType="lazy"即可。
修改StudentMapper.xml
文件：
<resultMap id="studentResultMap" type="Student">
<id property="sid" column="sid"/>
<result property="sname" column="sname"/>
<association property="clazz"
select="com.study.mybatis.mapper.ClazzMapper.selectByCid"
column="cid"
fetchType="lazy"/>
</resultMap>
我们现在只查询学生名字，修改测试程序：
public class StudentMapperTest {
@Test
public void testSelectBySid(){
StudentMapper mapper = SqlSessionUtil.openSession().getMapper(StudentMapper.class);
Student student = mapper.selectBySid(1);
//System.out.println(student);
// 只获取学生姓名
String sname = student.getSname();
System.out.println("学生姓名：" + sname);
}
}
如果后续需要使用到学生所在班级的名称，这个时候才会执行关联的sql语句，修改测试程序：
public class StudentMapperTest {
@Test
public void testSelectBySid(){
StudentMapper mapper = SqlSessionUtil.openSession().getMapper(StudentMapper.class);
Student student = mapper.selectBySid(1);
//System.out.println(student);
// 只获取学生姓名
String sname = student.getSname();
System.out.println("学生姓名：" + sname);
// 到这里之后，想获取班级名字了
String cname = student.getClazz().getCname();
System.out.println("学生的班级名称：" + cname);
}
}
通过以上的执行结果可以看到，只有当使用到班级名称之后，才会执行关联的sql语句，这就是延迟加载。
在mybatis中如何开启全局的延迟加载呢？需要setting配置，如下：
<settings>
<setting name="lazyLoadingEnabled" value="true"/>
</settings>
把fetchType="lazy"去掉。
执行以下程序：
public class StudentMapperTest {
@Test
public void testSelectBySid(){
StudentMapper mapper = SqlSessionUtil.openSession().getMapper(StudentMapper.class);
Student student = mapper.selectBySid(1);
//System.out.println(student);
// 只获取学生姓名
String sname = student.getSname();
System.out.println("学生姓名：" + sname);
// 到这里之后，想获取班级名字了
String cname = student.getClazz().getCname();
System.out.println("学生的班级名称：" + cname);
}
}
通过以上的测试可以看出，我们已经开启了全局延迟加载策略。
开启全局延迟加载之后，所有的sql都会支持延迟加载，如果某个sql你不希望它支持延迟加载怎么办呢？将fetchType设置为eager：
<resultMap id="studentResultMap" type="Student">
<id property="sid" column="sid"/>
<result property="sname" column="sname"/>
<association property="clazz"
select="com.study.mybatis.mapper.ClazzMapper.selectByCid"
column="cid"
fetchType="eager"/>
</resultMap>
这样的话，针对某个特定的sql，你就关闭了延迟加载机制。
后期我们要不要开启延迟加载机制，主要看实际的业务需求是怎样的。
13.3 一对多
一对多的实现，通常是在一的一方中有List集合属性。
在Clazz类中添加List<Student> stus; 属性。
public class Clazz {
private Integer cid;
private String cname;
private List<Student> stus;
// set get方法
// 构造方法
// toString方法
}
一对多的实现通常包括两种实现方式：
- 第一种方式：collection
- 第二种方式：分步查询
第一种方式：collection
package com.study.mybatis.mapper;
import com.study.mybatis.pojo.Clazz;
/**
* Clazz映射器接口
* @author sqnugy
* @version 1.0
* @since 1.0
*/
public interface ClazzMapper {
/**
* 根据cid获取Clazz信息
* @param cid
* @return
*/
Clazz selectByCid(Integer cid);
/**
* 根据班级编号查询班级信息。同时班级中所有的学生信息也要查询。
* @param cid
* @return
*/
Clazz selectClazzAndStusByCid(Integer cid);
}
<resultMap id="clazzResultMap" type="Clazz">
<id property="cid" column="cid"/>
<result property="cname" column="cname"/>
<collection property="stus" ofType="Student">
<id property="sid" column="sid"/>
<result property="sname" column="sname"/>
</collection>
</resultMap>
<select id="selectClazzAndStusByCid" resultMap="clazzResultMap">
select * from t_clazz c join t_student s on c.cid = s.cid where c.cid = #{cid}
</select>
注意是ofType，表示“集合中的类型”。
package com.study.mybatis.test;
import com.study.mybatis.mapper.ClazzMapper;
import com.study.mybatis.pojo.Clazz;
import com.study.mybatis.utils.SqlSessionUtil;
import org.junit.Test;
public class ClazzMapperTest {
@Test
public void testSelectClazzAndStusByCid() {
ClazzMapper mapper = SqlSessionUtil.openSession().getMapper(ClazzMapper.class);
Clazz clazz = mapper.selectClazzAndStusByCid(1001);
System.out.println(clazz);
}
}
执行结果：
第二种方式：分步查询
修改以下三个位置即可：
<resultMap id="clazzResultMap" type="Clazz">
<id property="cid" column="cid"/>
<result property="cname" column="cname"/>
<!--主要看这里-->
<collection property="stus"
select="com.study.mybatis.mapper.StudentMapper.selectByCid"
column="cid"/>
</resultMap>
<!--sql语句也变化了-->
<select id="selectClazzAndStusByCid" resultMap="clazzResultMap">
select * from t_clazz c where c.cid = #{cid}
</select>
/**
* 根据班级编号获取所有的学生。
* @param cid
* @return
*/
List<Student> selectByCid(Integer cid);
<select id="selectByCid" resultType="Student">
select * from t_student where cid = #{cid}
</select>
执行结果：
13.4 一对多延迟加载
一对多延迟加载机制和多对一是一样的。同样是通过两种方式：
- 第一种：fetchType=“lazy”
- 第二种：修改全局的配置setting，**
lazyLoadingEnabled=true，**如果开启全局延迟加载，想让某个sql不使用延迟加载：fetchType="eager"