【MyBatis】| MyBatis的⾼级映射及延迟加载

我不是女神ヾ 2024-03-30 01:31 51阅读 0赞

**目录**

一：MyBatis的⾼级映射及延迟加载

1. 多对⼀

1.1 第⼀种⽅式：使用级联属性映射resultMap

1.2 第⼆种⽅式：使用association标签

1.3 第三种⽅式：分步查询（常用）

1.4 多对⼀延迟加载

2. ⼀对多

2.1 第⼀种⽅式：使用collection标签

2.2 第⼆种⽅式：分步查询

2.3 延迟加载

--------------------

## 一：MyBatis的⾼级映射及延迟加载 ##

> **前期准备：**
> 
> 模块名：mybatis-010-advanced-mapping
> 
> 打包⽅式：jar
> 
> 引⼊依赖：mysql驱动依赖、mybatis依赖、junit依赖、logback依赖
> 
> pojo：com.bjpowernode.mybatis.pojo.Student和Calzz
> 
> mapper接⼝：com.bjpowernode.mybatis.mapper.StudentMapper和ClazzMapper
> 
> 引⼊配置⽂件：mybatis-config.xml、jdbc.properties、logback.xml
> 
> mapper配置⽂件：com/bjpowernode/mybatis/mapper/StudentMapper.xml和ClazzMapper.xml
> 
> 编写测试类：com.bjpowernode.mybatis.test.StudentMapperTest和ClazzMapperTest
> 
> 拷⻉⼯具类：com.bjpowernode.mybatis.utils.SqlSessionUtil
> 
> 准备数据库表：⼀个班级对应多个学⽣：

**班级表：t\_clazz**

![f8bb7bd77587427da89dc3369b9a0f9f.png][]

**学⽣表：t\_student**

![22f32105bf62435abaee865781782e4d.png][]

**clazz实体类**

package com.bjpowernode.mybatis.pojo;
    
    /**
     * @Author：朗朗乾坤
     * @Package：com.bjpowernode.mybatis.pojo
     * @Project：mybatis
     * @name：Clazz
     * @Date：2023/1/7 18:18
     */
    public class Clazz {
        private Integer cid;
        private String cname;
    
        public Clazz() {
        }
    
        public Clazz(Integer cid, String cname) {
            this.cid = cid;
            this.cname = cname;
        }
    
        @Override
        public String toString() {
            return "Clazz{" +
                    "cid=" + cid +
                    ", cname='" + cname + '\'' +
                    '}';
        }
    
        public Integer getCid() {
            return cid;
        }
    
        public void setCid(Integer cid) {
            this.cid = cid;
        }
    
        public String getCname() {
            return cname;
        }
    
        public void setCname(String cname) {
            this.cname = cname;
        }
    }

**Student实体类：只定义两个字段；对于cid属性，是为了维护两者关系的属性**

package com.bjpowernode.mybatis.pojo;
    
    /**
     * @Author：朗朗乾坤
     * @Package：com.bjpowernode.mybatis.pojo
     * @Project：mybatis
     * @name：Student
     * @Date：2023/1/7 18:18
     */
    public class Student { 
        private Integer sid;
        private String sname;
       
        public Student() {
        }
        public Student(Integer sid, String sname) {
            this.sid = sid;
            this.sname = sname;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "sid=" + sid +
                    ", 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;
        }
    }

![0244e15ddaf64088912043894c9e5623.png][]

### 1. 多对⼀ ###

**多对一：多的一方在前面，那么多就是主表，一就是副表！**

**例如：多个学生（主表）对应一个班级（副表）！****一的一方在是以属性的方式存在多的一方！**

![3bfd0df66c3543c6847890f169ae609b.png][]

> **pojo类Student中添加⼀个属性：Clazz clazz; 表示学⽣关联的班级对象，增加setter and getter方法，重写toString方法。**

package com.bjpowernode.mybatis.pojo;
    
    /**
     * @Author：朗朗乾坤
     * @Package：com.bjpowernode.mybatis.pojo
     * @Project：mybatis
     * @name：Student
     * @Date：2023/1/7 18:18
     */
    public class Student { // Student是多的一方
        private Integer sid;
        private String sname;
        private Clazz clazz; // Clazz是一的一方
    
        public Student() {
        }
        public Student(Integer sid, String sname) {
            this.sid = sid;
            this.sname = sname;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "sid=" + sid +
                    ", sname='" + sname + '\'' +
                    ", clazz=" + clazz +
                    '}';
        }
    
        public Clazz getClazz() {
            return clazz;
        }
    
        public void setClazz(Clazz clazz) {
            this.clazz = clazz;
        }
    
        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;
        }
    }

**多对一：多个学生Student对应一个班级Clazz；多种实现⽅式，常⻅的包括三种：**

①第⼀种⽅式：⼀条SQL语句，级联属性映射ResultMap。

②第⼆种⽅式：⼀条SQL语句，association。

③第三种⽅式：两条SQL语句，分步查询（常用的）。

####  ####

#### 1.1 第⼀种⽅式：使用级联属性映射resultMap ####

三兄弟之一：StudentMapper接口，编写方法

> 根据id获取学生Student信息，同时获取学生关联的班级Clazz信息

package com.bjpowernode.mybatis.mapper;
    
    import com.bjpowernode.mybatis.pojo.Student;
    
    public interface StudentMapper {
        /*
         * @param id 学生的id
         * @return 返回一个Student对象，但是Student对象中含有Clazz对象
         */
        Student selectById(Integer id);
        
    }

三兄弟之二：StudentMapper.xml文件，编写sql语句

> （1）**使用resultMap来指定映射关系，结果映射resultMap有两个参数：**
> 
> ①一个参数是id，指定resultMap的唯一标识，这个id将来在select标签中使用。
> 
> ②一个参数是type，用来指定POJO类的类名。
> 
> （2）**在resultMap下还有一个子标签result；**
> 
> ①首先对于有主键的需要配一个id，不是必须的，但可以增加效率；
> 
> ②下面使用result子标签的property属性和column属性分别指定POJO类的属性名和数据库表中的字段表之间的映射关系；
> 
> ③对于clazz对象的属性映射，采用“引用.属性”的方式，例如：clazz.cid，clazz.cname；

<?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.bjpowernode.mybatis.mapper.StudentMapper">
        
        <resultMap id="studentResultMap" type="Student">
            <id property="id" column="id"/>
            <result property="sid" column="sid"/>
            
            <result property="clazz.cid" column="cid"/>
            <result property="clazz.cname" column="cname" />
        </resultMap>
    
        <select id="selectById" resultMap="studentResultMap">
          select
            s.sid,s.sname,c.cid,c.cname
          from
            t_student s
          left join
            t_clazz c
          on s.cid = c.cid
          where
            s.sid = #{sid}
        </select>
    </mapper>

三兄弟之三：StudentMappeTest类，用来编写测试类

package com.bjpowernode.mybatis.test;
    
    import com.bjpowernode.mybatis.mapper.StudentMapper;
    import com.bjpowernode.mybatis.pojo.Student;
    import com.bjpowernode.mybatis.utils.SqlSessionUtil;
    import org.apache.ibatis.session.SqlSession;
    import org.junit.Test;
    
    public class StudentMapperTest {
        @Test
        public void testSelectById(){
            SqlSession sqlSession = SqlSessionUtil.openSession();
            StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
            Student student = mapper.selectById(1);
            // 直接输出Student对象
            System.out.println(student);
            // 输出每个属性
            System.out.println(student.getSid());
            System.out.println(student.getSname());
            System.out.println(student.getClazz().getCid());
            System.out.println(student.getClazz().getCname());
    
            sqlSession.close();
        }
    }

执行结果：

![5e611eea103d46aa8b0853f38a16f10f.png][]

#### 1.2 第⼆种⽅式：使用association标签 ####

> 第二种方式，和第一种方式的代码很类似，就是多引入一个association标签，association翻译为关联的意思；相当于resultMap和association的联合使用！

三兄弟之一：StudentMapper接口，编写方法

> 根据id获取学生Student信息，同时获取学生关联的班级Clazz信息

package com.bjpowernode.mybatis.mapper;
    
    import com.bjpowernode.mybatis.pojo.Student;
    
    public interface StudentMapper {
         /**
         * 一条SQL语句，使用association标签的方式
         * @param id 学生的id
         * @return 学生对象，但是学生对象当中含有班级对象
         */
        Student selectByIdAssociation(Integer id);
        
    }

三兄弟之二：StudentMapper.xml文件，编写sql语句

> **association：翻译为关联，配置两个属性，一个Student对象关联一个Clazz对象**
> 
> ①**property属性：**提供要映射的POJO类的属性名，这里就是clazz；
> 
> ②**javaType属性：**用来指定要映射的java类型，这里就是com.bjpowernode.mybatis.Clazz；
> 
> ③association配置两个属性以后，也要配置关联对象的Clazz的映射关系，也要使用id标签和result标签进行配置；

<?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.bjpowernode.mybatis.mapper.StudentMapper">
        
        <resultMap id="studentResultMapAssociation" 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>
        
        <select id="selectByIdAssociation" resultMap="studentResultMapAssociation">
            select
            s.sid,s.sname,c.cid,c.cname
          from
            t_student s
          left join
            t_clazz c
          on s.cid = c.cid
          where
            s.sid = #{sid}
        </select>
    </mapper>

三兄弟之三：StudentMappeTest类，用来编写测试类

package com.bjpowernode.mybatis.test;
    
    import com.bjpowernode.mybatis.mapper.StudentMapper;
    import com.bjpowernode.mybatis.pojo.Student;
    import com.bjpowernode.mybatis.utils.SqlSessionUtil;
    import org.apache.ibatis.session.SqlSession;
    import org.junit.Test;
    
    public class StudentMapperTest {
         @Test
        public void testSelectByIdAssociation(){
            SqlSession sqlSession = SqlSessionUtil.openSession();
            StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
            Student student = mapper.selectByIdAssociation(2);
            // 直接输出Student对象
            System.out.println(student);
            sqlSession.close();
        }
    }

执行结果：

![32a27d0b509641d3851fdb2d9a1313a4.png][]

#### 1.3 第三种⽅式：分步查询（常用） ####

> **分布查询，需要两条SQL语句，这种⽅式常⽤：**
> 
> ①优点⼀是可复⽤。
> 
> ②优点⼆是⽀持懒加载（延迟加载）

**（1）分布查询第一步：先根据学生的sid查询学生信息**

①在**StudentMapper**中编写第一步的查询方法

package com.bjpowernode.mybatis.mapper;
    
    import com.bjpowernode.mybatis.pojo.Student;
    
    public interface StudentMapper {
        
        // 分布查询第一步：现根据学生的sid查询学生信息
        Student selectByIdStep1(Integer id);
    
    }

②在**StudentMapper.xml**中编写SQL语句，并指明两者之间的关联关系

> **还是需要association标签：**
> 
> ①**property属性**：还是**提供要映射的POJO类的属性名**，这里就是clazz；
> 
> ②**select属性：用来指定另外第二步SQL语句的id**，这个id实际上就是namespace+id；通过第二步语句的查询结果，把值赋值给clazz；
> 
> ③**column属性：是把第一条SQL语句查询出来的cid传给第第二条SQL语句**，然后第二条语句根据cid进行查询；

<?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.bjpowernode.mybatis.mapper.StudentMapper">   
        
        <resultMap id="studentResultMapByStep" type="Student">
            <id property="sid" column="sid"/>
            <result property="sname" column="sname" />
            
            <association property="clazz"
                         select="com.bjpowernode.mybatis.mapper.ClazzMapper.selectByIdStep2"
                         column="cid"/>
        </resultMap>
    
        <select id="selectByIdStep1" resultMap="studentResultMapByStep">
            select sid,sname,cid from t_student where sid = #{sid};
        </select>
    
    </mapper>

**（2）分布查询第二步：根据学生的cid查询班级信息**

①在**ClazzMapper**中编写第二步的查询方法

package com.bjpowernode.mybatis.mapper;
    
    import com.bjpowernode.mybatis.pojo.Clazz;
    
    public interface ClazzMapper {
        // 分布查询第二步：根据cid获取查询信息
        Clazz selectByIdStep2(Integer cid);
    }

②在ClazzMapper.xml中编写SQL语句

<?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.bjpowernode.mybatis.mapper.ClazzMapper">
        
        <select id="selectByIdStep2" resultType="Clazz">
            select cid,cname from t_clazz where cid = #{id};
        </select>
    </mapper>

**（3）最终StudentMapperTest编写测试，因为Student是主表**

执行结果：

![12437daf5f0f4b37aa85f5ddcf869b9c.png][]

#### 1.4 多对⼀延迟加载 ####

> （1）延迟加载的核心是：用到的在查询，暂时访问不到的数据可以先不查询。
> 
> （2）作用：提⾼程序的执⾏效率；不用的时候也查性能肯定低，例如笛卡尔积现象
> 
> （3）在MyBatis中如何开启延迟加载：**association标签当中添加fetchType="lazy"**

**例1：**不开启延迟加载机制，假如只访问学生表t\_student的sname属性，和t\_clazz表实际上是没有任何关系的

package com.bjpowernode.mybatis.test;
    
    import com.bjpowernode.mybatis.mapper.StudentMapper;
    import com.bjpowernode.mybatis.pojo.Student;
    import com.bjpowernode.mybatis.utils.SqlSessionUtil;
    import org.apache.ibatis.session.SqlSession;
    import org.junit.Test;
    
    
    public class StudentMapperTest {
        @Test
        public void testSelectByIdStep1(){
            SqlSession sqlSession = SqlSessionUtil.openSession();
            StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
            Student student = mapper.selectByIdStep1(3);
            // System.out.println(student);
            // 只访问sname属性
            System.out.println(student.getSname());
            sqlSession.close();
        }
    }

执行结果：实际上执行了两个查询语句，效率变低

![1ee519dd513f432880a241d00ef6a013.png][]

**例2：**在asspciation标签中开启延迟机制，就能做到只执行第一条SQL语句，第二条不执行；

<?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.bjpowernode.mybatis.mapper.StudentMapper">
        <resultMap id="studentResultMapByStep" type="Student">
            <id property="sid" column="sid"/>
            <result property="sname" column="sname" />
            
            <association property="clazz"
                         select="com.bjpowernode.mybatis.mapper.ClazzMapper.selectByIdStep2"
                         column="cid"
                         fetchType="lazy"/>
        </resultMap>
    
        <select id="selectByIdStep1" resultMap="studentResultMapByStep">
            select sid,sname,cid from t_student where sid = #{sid};
        </select>
    
    
    </mapper>

执行结果：同样还是只访问学生表t\_student的sname属性，此时就是只查询一张表即可

![aba27d07da7e4e87b4e99790a16c4727.png][]

> （4）**在association标签中配置fetchType=“lazy”**，实际上**是局部的设置，只对当前的association关联的SQL语句起作用！**
> 
> （5）那么怎样在mybatis中**如何开启全局的延迟加载**呢？需要**setting配置**，如下：

![4d011e1d15404c93aa27dc31823549cf.png][]

**在核心配置文件mybatis-config.xml文件当中使用setting标签进行配置全局的延迟加载**

<settings>
            <setting name="lazyLoadingEnabled" value="true"/>
        </settings>

> （6）开启全局延迟加载之后，所有的SQL都会⽀持延迟加载！但是**如果某个SQL你不希望它⽀持延迟加载怎么办呢？ 将fetchType设置为eager**

<?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.bjpowernode.mybatis.mapper.StudentMapper">
        <resultMap id="studentResultMapByStep" type="Student">
            <id property="sid" column="sid"/>
            <result property="sname" column="sname" />
            
            <association property="clazz"
                         select="com.bjpowernode.mybatis.mapper.ClazzMapper.selectByIdStep2"
                         column="cid"
                         fetchType="eager"/>
        </resultMap>
    
        <select id="selectByIdStep1" resultMap="studentResultMapByStep">
            select sid,sname,cid from t_student where sid = #{sid};
        </select>
    
    
    </mapper>

### 2. ⼀对多 ###

**一对多：一的一方在前面，那么一就是主表，多就是副表！**

**例如：一个班级（主表）对应多个学生（副表）！****⼀对多的实现，通常是多的一方以List集合属性的方式出现在⼀的⼀⽅！**

![dd606b4a872d4f2cb281aaa1f81b09bf.png][]

> **pojo类Clazz中添加⼀个属性：List<Student> stu; 表示班级关联的学生对象，增加setter and getter方法，重写toString方法。**

package com.bjpowernode.mybatis.pojo;
    
    import java.util.*;
    
    public class Clazz {
        private Integer cid;
        private String cname;
        private List<Student> stus;
        
        public Clazz() {
        }
    
        public Clazz(Integer cid, String cname) {
            this.cid = cid;
            this.cname = cname;
        }
    
        @Override
        public String toString() {
            return "Clazz{" +
                    "cid=" + cid +
                    ", cname='" + cname + '\'' +
                    ", stus=" + stus +
                    '}';
        }
    
        public List<Student> getStus() {
            return stus;
        }
    
        public void setStus(List<Student> stus) {
            this.stus = stus;
        }
    
        public Integer getCid() {
            return cid;
        }
    
        public void setCid(Integer cid) {
            this.cid = cid;
        }
    
        public String getCname() {
            return cname;
        }
    
        public void setCname(String cname) {
            this.cname = cname;
        }
    }

**⼀对多的实现通常包括两种实现⽅式：**

①第⼀种⽅式：collection；

②第⼆种⽅式：分步查询；

####  ####

#### 2.1 第⼀种⽅式：使用collection标签 ####

> **注：**这次t\_calss是主表，所以是在ClazzMapper、ClazzMapper.xml、ClazzMapperTest当中完成一些列操作。

三兄弟之一：ClazzMapper接口，编写方法

package com.bjpowernode.mybatis.mapper;
    
    import com.bjpowernode.mybatis.pojo.Clazz;
    
    public interface ClazzMapper {
        
       // 根据班级编号查询班级信息
        Clazz selectByIdCollection(Integer cid);
    }

三兄弟之二：ClazzMapper.xml文件，编写sql语句

**注：使用collection标签，和上面使用association标签的第二种方法是很相似的！主要注意两点：一是把association替换成collection；二是把javaType替换成ofType**

> ①property属性：提供要映射的POJO类的属性名，这里就是stus
> 
> ②ofType属性：用来指定集合当中的元素类型com.bjpowernode.mybatis.Student

<?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.bjpowernode.mybatis.mapper.ClazzMapper">
        <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="selectByIdCollection" resultMap="clazzResultMap">
            select
              c.cid,c.cname,s.sid,s.sname
            from
              t_clazz c
            left join
              t_student s
            on c.cid = s.cid
            where c.cid = #{cid}
        </select>
    </mapper>

三兄弟之三：ClazzMappeTest类，用来编写测试类

package com.bjpowernode.mybatis.test;
    
    import com.bjpowernode.mybatis.mapper.ClazzMapper;
    import com.bjpowernode.mybatis.pojo.Clazz;
    import com.bjpowernode.mybatis.utils.SqlSessionUtil;
    import org.apache.ibatis.session.SqlSession;
    import org.junit.Test;
    
    public class ClazzMapperTest {
        @Test
        public void testSelectByIdCollection(){
            SqlSession sqlSession = SqlSessionUtil.openSession();
            ClazzMapper mapper = sqlSession.getMapper(ClazzMapper.class);
            Clazz clazz = mapper.selectByIdCollection(1001);
            System.out.println(clazz);
            sqlSession.close();
        }
    
    
    }

执行结果：

> 查询的结果是stus变量是一个有三个数据的List集合，其中clazz是null属于正常现象，如果clazz还有值，就会与前面的Student形成递归循环

![29be552ddab44c568aafd42371dbeb02.png][]

#### 2.2 第⼆种⽅式：分步查询 ####

**（1）分布查询第一步：先根据班级编号获取班级信息**

①在ClazzMapper中编写第一步的查询方法

package com.bjpowernode.mybatis.mapper;
    
    import com.bjpowernode.mybatis.pojo.Clazz;
    
    public interface ClazzMapper {
     
        // 分布查询第一步：根据班级编号，获取班级信息
        Clazz selectByStep1(Integer cid);
    }

②在ClazzMapper.xml中编写SQL语句，并指明两者之间的关联关系

<?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.bjpowernode.mybatis.mapper.ClazzMapper">
       
        <resultMap id="clazzResultMapStep" type="Clazz">
            <id property="cid" column="cid"/>
            <result property="cname" column="cname"/>
            <collection property="stus"
                        select="com.bjpowernode.mybatis.mapper.StudentMapper.selectByCidStep2"
                        column="cid" />
        </resultMap>
        <select id="selectByStep1" resultMap="clazzResultMapStep">
            select cid,cname from t_clazz where cid = #{cid}
        </select>
    </mapper>

**（2）分布查询第二步：根据学生的cid查询班级信息**

①在StudentMapper中编写第二步的查询方法

package com.bjpowernode.mybatis.mapper;
    
    import com.bjpowernode.mybatis.pojo.Student;
    import java.util.List;
    
    public interface StudentMapper {
       
        // 分布查询第二步：根据班级编号查询学生信息
        List<Student> selectByCidStep2(Integer cid);
    }

②在StudentMapper.xml中编写SQL语句

<?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.bjpowernode.mybatis.mapper.StudentMapper">
        <select id="selectByCidStep2" resultType="Student">
            select * from t_student where cid = #{cid}
        </select>
    </mapper>

**（3）最终ClazzMapperTest编写测试，因为Clazz是主表**

package com.bjpowernode.mybatis.test;
    
    import com.bjpowernode.mybatis.mapper.ClazzMapper;
    import com.bjpowernode.mybatis.pojo.Clazz;
    import com.bjpowernode.mybatis.utils.SqlSessionUtil;
    import org.apache.ibatis.session.SqlSession;
    import org.junit.Test;
    
    public class ClazzMapperTest {
        @Test
        public void testSelectByStep1(){
            SqlSession sqlSession = SqlSessionUtil.openSession();
            ClazzMapper mapper = sqlSession.getMapper(ClazzMapper.class);
            Clazz clazz = mapper.selectByStep1(1001);
            System.out.println(clazz);
            sqlSession.close();
        }
    }

执行结果：

![2004d1dfb47a4c6b95159d7cc99a5008.png][]

####  ####

#### 2.3 延迟加载 ####

**⼀对多延迟加载机制和多对⼀是⼀样的，同样是通过两种⽅式：**

> ①第⼀种：fetchType="lazy";
> 
> ②第⼆种：修改全局的配置setting，lazyLoadingEnabled=true；
> 
> 注：如果开启全局延迟加载，想让某个 sql不使⽤延迟加载：fetchType="eager"。

[f8bb7bd77587427da89dc3369b9a0f9f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d7723596420947d8839eeaae94ee92b8.png
[22f32105bf62435abaee865781782e4d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/8a64b413388c4840a7a4ad41c363f1ee.png
[0244e15ddaf64088912043894c9e5623.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/c2103f1e92f647598338084de55d9f76.png
[3bfd0df66c3543c6847890f169ae609b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/3e8f9f50ccfa48f6815c80575ffffc10.png
[5e611eea103d46aa8b0853f38a16f10f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/7ed18ad53ac04560b4e72eb39a66b092.png
[32a27d0b509641d3851fdb2d9a1313a4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/ee7223488d6e4d109430902aef179c1c.png
[12437daf5f0f4b37aa85f5ddcf869b9c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/67c615a2d5d24d50819ce442c1ede058.png
[1ee519dd513f432880a241d00ef6a013.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/d5a8cb52f55b4885958dac7f98bc18ed.png
[aba27d07da7e4e87b4e99790a16c4727.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/9c9f22dc1f9c479985c1a4e0ad407bb6.png
[4d011e1d15404c93aa27dc31823549cf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/0a5c871fb72b43369d676329c8301a62.png
[dd606b4a872d4f2cb281aaa1f81b09bf.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/2326c27128104b039215e8fb05add9bd.png
[29be552ddab44c568aafd42371dbeb02.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/732178d5e5f24fcca9d445e544847344.png
[2004d1dfb47a4c6b95159d7cc99a5008.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/327f0a56c59344e38649fe58d27c3278.png