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

已于 2023-05-11 22:48:32 修改
阅读量600 收藏 10
点赞数 5
分类专栏： 第四步：SSM框架 文章标签： mybatis java mysql
于 2023-02-07 21:42:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61933976/article/details/128586831
版权

目录

一：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

学⽣表：t_student

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

1. 多对⼀

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

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

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">
    <!--多对一映射的第一种方式：一条SQL语句，级联属性映射-->
    <resultMap id="studentResultMap" type="Student">
        <id property="id" column="id"/>
        <result property="sid" column="sid"/>
        <!--Clazz类中的属性，采用"引用.属性名"的形式访问-->
        <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();
    }
}

执行结果：

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">
    <!--一条SQL语句，引入association标签-->
    <resultMap id="studentResultMapAssociation" type="Student">
        <id property="sid" column="sid"/>
        <result property="sname" column="sname"/>
        <!--使用assocaition标签-->
        <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();
    }
}

执行结果：

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">   
    <!--这是第一步：根据学生的id查询学生的所有信息，包含cid-->
    <resultMap id="studentResultMapByStep" type="Student">
        <id property="sid" column="sid"/>
        <result property="sname" column="sname" />
        <!--使用association标签，指明关联关系-->
        <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">
    <!--分布查询第二步：根据cid获取班级信息-->
    <select id="selectByIdStep2" resultType="Clazz">
        select cid,cname from t_clazz where cid = #{id};
    </select>
</mapper>

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

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);
        sqlSession.close();
    }
}

执行结果：

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

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

例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标签，并开启延迟加载机制-->
        <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属性，此时就是只查询一张表即可

（4）在association标签中配置fetchType=“lazy”，实际上是局部的设置，只对当前的association关联的SQL语句起作用！

（5）那么怎样在mybatis中如何开启全局的延迟加载呢？需要setting配置，如下：

在核心配置文件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标签，不开启延迟加载机制-->
        <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集合属性的方式出现在⼀的⼀⽅！

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"/>
        <!--ofType用来指定集合当中的元素类型-->
        <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形成递归循环 

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">
   <!--分布查询第一步：根据班级的cid获取班级信息-->
    <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();
    }
}

执行结果：

2.3 延迟加载

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

①第⼀种：fetchType="lazy";

②第⼆种：修改全局的配置setting，lazyLoadingEnabled=true；

注：如果开启全局延迟加载，想让某个 sql不使⽤延迟加载：fetchType="eager"。

@每天都要敲代码
关注
专栏目录
面向对象基础语法
liupc的学习笔记
11-03 478
一、dir内置函数 二、定义简单的类 三、方法中的self参数 四、初始化方法 五、内置方法和属性 一、dir内置函数 首先推荐一个Python的内置函数：dir()。 在Python中，对象无所不在。我们之前学习的变量、数据、函数都是对象。比如a = 10。a就是变量（引用）；10就是数据。 我们前面在IPython中，通过下面的方式查看一个对象都有哪些方法： ...
MyBatis的⾼级映射及延迟加载
m0_55381502的博客
10-12 93
MyBatis的⾼级映射及延迟加载
Mybatis高级映射及延迟加载
小钟不想敲代码
04-20 322
Mybatis高级映射及延迟加载
mybatis延迟加载及其原理
最新发布
Yi__Xin_的博客
08-14 118
延迟加载就是说，在需要用到数据的时候才就行加载，不需要用到数据的时候就不加载。mybatis支持一对一关联对象和一对多关联集合对象的延迟加载。我们可以在Mybatis配置文件中选择是否启用延迟加载，lazyLoadingEnable=true/fals，默认是关闭的。其原理就是使用cglib创建目标对象的代理对象。当目标方法被调用时，进入拦截器invoke方法，发现目标方法是null，执行sql查询。获取数据后，调用set方法设置属性值，再继续查询目标方法后，值就有了。
mybatis延迟加载（XML）
weixin_46083389的博客
02-02 219
对于一对一和多对一（mybatis映射为一对一）。查询的时候一起查询即可。 但是对于一对多，和多对多。也许那个多对应的数据很多，而我们不需要那个多。那么一起查询会浪费性能资源。 所以，mybatis有懒加载。 mysql默认是立即加载。 懒加载在Collection或者association属性中有一个fetchType属性，eager立即加载。lazy懒加载。 在mybatis的配置文件中： <settings> <!--延迟加载总开关-->
Mybatis延迟加载
Forrit的博客
10-21 235
5h 什么是延迟加载呢？ 通俗的讲就是按需加载，我们需要什么的时候再去进行什么操作。 5h 什么时候会用到延迟加载呢？ 多表单独查询的时候。 而且先从单表查询，需要时再从关联表去关联查询，能大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。 延迟加载分为两种：深度延时加载，侵入式延迟加载 5h 如何开启延时加载？ mybatis.xml中进行配置 <settings> <!--延迟加载总开关,打开后，默认的是深度延时加载 --> <setting name="la
mybatis的关联映射及延迟加载的使用
05-27
java学习-java学习-mybatis的关联映射(一对一关联映射/一对多关联映射/多对多关联映射)，mybatis的延迟加载的好处及使用。
Mybatis查询延迟加载详解及实例
09-09
Mybatis的查询延迟加载是一种优化策略，用于提高数据查询效率。在默认情况下，Mybatis不会自动启用延迟加载，而是会一次性加载所有关联的数据。这意味着，当你执行一个查询时，如果查询结果包含其他对象的引用，...
mybatis延迟加载样例
05-17
1. **配置延迟加载**：在MyBatis的XML映射文件中，通过`<association>`或`<collection>`元素配置延迟加载。例如，对于一个一对多的关系，我们需要在`<collection>`元素中设置`lazyLoadingEnabled="true"`来开启延迟...
mybatis教程之延迟加载详解
08-30
MyBatis延迟加载详解 MyBatis是一款流行的Java持久层框架，它提供了延迟加载功能来提高数据库查询性能。在本篇文章中，我们将详细介绍MyBatis延迟加载的意义、配置和实现。 延迟加载的意义 在进行数据查询时，...
mybatis高级映射
05-27
### MyBatis 高级映射详解 #### 一、高级结果映射 在 MyBatis 的使用过程中，经常会遇到需要处理复杂的数据关联情况，如一对一、一对多、多对多的关系。这些关系的处理主要依赖于 MyBatis 的高级结果映射特性。 *...
Mybatis 中的延迟加载
Zystem
06-15 9151
1、问题提出 在之前的文章一对多中，当我们有一个用户，他又一百个账户。 （1）在查询用户时，要不要把关联的账户信息查询出来？ （2）在查询账户时，要不要把关联的用户信息查询出来？ 对于第一个问题，我们应该是什么时候需要查询账户信息，才查询。没必要每次查询用户信息都把账户信息也查询出来。因为如果每次都查询出账户信息，对我们的内存开销是很大的，而且每次查询也都不一定用到账户信息。 对于第二个问题，...
Mybatis延迟加载原理
金牛区代码仔的博客
06-05 276
阶段一 调用SQLSession的查询方法时： 例如执行代码“T t = sqlSession.selecOne();”时Mybatis会返回一个T类型的代理对象，部分源码如图 // 创建映射后的结果对象 Object resultObject = createResultObject(rsw, resultMap, constructorArgTypes, constructorArgs, columnPrefix); if (resultObject != null
MyBatis 延迟加载原理
春风化雨
12-24 2482
1、延迟加载配置 MyBatis 支持延迟加载，需要设置 lazyLoadingEnabled = true 2、延迟加载的原理 是调用时触发加载，而非初始化时就加载信息。 举例：调用 a. getB(). getName()，发现 a. getB() 的值为 null，此时会单独触发事件，先保存好的关联 B 对象的 SQL，查询出来 B，然后再调用 a. setB(b)，于是再调用 a. getB(). getName() 就有值了，此为延迟加载的基本原理。 ...
【Mybatis】延迟加载原理
菜鸡也有大佬梦
02-27 850
延迟加载 延迟加载如何使用 Setting 参数配置 设置参数 描述 有效值 默认值 lazyLoadingEnabled 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。 特定关联关系中可通过设置fetchType属性来覆盖该项的开关状态。 true、false false aggressiveLazyLoading 当开启时，任何方法的调用都会加载该对象的所有属性。否则，每个属性会按需加载（参考lazyLoadTriggerMethods). true、false false
mybatis延迟加载原理
克豪的博客
04-07 780
使用CGLIB创建目标对象的代理对象，当调用目标方法时，进入拦截器方法，比如调用A.getB().getName()，拦截器invoke()方法发现A.getB()是null值，那么就会单独发送事先保存好的查询关联B对象的sql，把B查询上来，然后调用A.setB(b)，于是a的对象b属性就有值了，接着完成A.getB().getName()方法的调用。这就是延迟加载的基本原理。 所以在b/s开发，似乎没有什么用？ 因为传递到前端的时候，转换成json字符串的过程中依然是，调用了get方法，所以一次请求，依
Mybaits延迟加载实现原理
纸上得来终觉浅，绝知此事要躬行
08-14 535
最终都会来到 org.apache.ibatis.session.defaults.DefaultSqlSession#selectList(java.lang.String, java.lang.Object, org.apache.ibatis.session.RowBounds, org.apache.ibatis.session.ResultHandler)如果方法是setter方法 则从 lazyLoader map集合中移除该属性的延迟加载。有则调用 , 并从 loaderMap 中删除。.
mybaits延迟加载原理_Mybatis之延迟加载机制
weixin_27943395的博客
12-24 760
1. 延迟加载的含义： 用到的时候才会去进行相关操作2.延迟加载的例子：2.1 spring的BeanFactory，在getBean()的时候才创建Bean2.2 物理分页查询，只有点击某一页时采取数据库查询该页的数据3.Mybatis启用延迟加载机制4. Mybatis延迟加载的策略：侵入式延迟加载机制【如果只查询主表数据而不进行使用，级联表的数据不会被查询；如果使用了主表数据，即使级联表...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

@每天都要敲代码

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值