MyBatis （五）—— 延迟加载

最新推荐文章于 2024-07-05 18:07:46 发布
最新推荐文章于 2024-07-05 18:07:46 发布
阅读量3.3k 收藏 4
点赞数 2
分类专栏： 框架 文章标签： MyBatis延迟加载 mybatis的高级映射
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/QQ2899349953/article/details/97891093
版权

文章目录

高级映射

在学习延迟加载之前，先来学习什么是高级映射吧；

高级映射其实就是数据库表与表之间的关系，那么具体的关系又可以分为三种（拿学生表和班级表做说明）：

  1. 一对一关系；如学生之于班级
  2. 一对多关系；如班级至于学生
  3. 多对多关系；这个比如一个用户可以购买多个商品，而一个商品可以被多个用户购买，这样的用户表和商品表之间就是多对多关系；

一对一关联映射

使用到的两个表如下：
在这里插入图片描述
在这里插入图片描述

先创建两个bean类：

public class Student {
    private int Sid;
    private String Sname;
    private int Cid;

    //get、set和toString方法略
}

public class Classes {
    private int Cid;
    private String Cname;

    //get、set和toString方法略
}

两个对应的dao层接口：

public interface StudentDao {
    public StudentVo getById1(int id);
}

public interface ClassesDao {
    public Classes getById1(int id);
}
方式一：resultType

这个方法需要创建一个新类，因为返回的是一个新的对象，要拿一个新的类让mybatis完成映射：

public class StudentVo {
    private int Sid;
    private String Sname;
    private int Cid;
    private String Cname;

    //get、set和toString方法略
}

我是直接创建了一个新的类StudentVo，让后把对应的属性全部添加在里面，也可以通过继承Student、Classes两个类中的一个，再把缺的属性添加在这个新类里面就好，我这个例子里面属性比较少，就直接全写在里面了；

需要使用的StudentDao.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.tulun7.dao.StudentDao">
    <select id="getById1" parameterType="java.lang.Integer" resultType="com.tulun7.bean.StudentVo">
        select
            student1.Sid,
            student1.Sname,
            classes.Cid,
            classes.Cname
        from
            student1,classes
        where
            student1.Cid = classes.Cid
            and Student1.Sid = #{id}
    </select>
</mapper>

mybatis的全局配置文件mybatis.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <!-- 打印查询语句 -->
        <setting name="logImpl" value="LOG4J"/>
    </settings>

    <!--数据源配置-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?serverTimezone=GMT&amp;useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <!--映射-->
    <mappers>
        <mapper resource="延时加载/StudentDao.xml"/>
    </mappers>

</configuration>

测试：

public class TestDemo1 {
    @Test
    public void test() throws IOException {
        String resource = "延时加载/mybatis.xml";
        //读取配置文件
        InputStream asStream = Resources.getResourceAsStream(resource);
        //创建sqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(asStream);

        //创建sqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //通过动态代理产生StudentMapper对象
        StudentDao mapper = sqlSession.getMapper(StudentDao.class);
        StudentVo byId1 = mapper.getById1(1901);
        System.out.println(byId1);
    }
}

在这里插入图片描述

方式二：resultMap

这种实现方法，需要把Classes当做Student类中的一个属性，即需要改变Student类（我直接写了一个新的类Student1）：

public class Student1 {
    private int Sid;
    private String Sname;
    private int Cid;
    private Classes classes; //把关联的这儿当属性

    //get、set和toString方法略
}

在StudentDao接口里面添加一个方法：

public interface StudentDao {
    public StudentVo getById1(int id);
    public Student1 getById2(int id);  //添加新方法
}

那他的StudentDao1.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.tulun7.dao.StudentDao">
    <!-- 定义一个resultMap, 学生 > 班级 ,将查询的结果映射Student1-->
    <resultMap id="student1Map" type="com.tulun7.bean.Student1">
        <!-- 数据库表Student1对应 pojo中的Student1.java -->
        <!--  id:唯一标识
              result:普通标识
              column：数据库的字段
              property：对应bean类的属性-->
        <id column="Sid" property="Sid"/>
        <result column="Sname" property="Sname"/>
        <result column="Cid" property="Cid"/>
        <!-- 配置关联用户信息 -->
        <!-- association：用于映射关联查询单个对象的信息
              property：要将关联查询的班级信息映射到Student1中哪个属性
              javaType：映射到哪个类-->
        <association property="classes"  javaType="com.tulun7.bean.Classes">
            <id column="Cid" property="Cid"/>
            <result column="Cname" property="Cname"/>
        </association>
    </resultMap>

    <select id="getById2" resultMap="student1Map">
        select
            student1.Sid,
            student1.Sname,
            classes.Cid,
            classes.Cname
        from
            student1,classes
        where
            student1.Cid = classes.Cid
            and Student1.Sid = #{id}
    </select>
</mapper>

在mybatis的全局配置文件mybatis.xml里面添加映射文件StudentDao1.xml（略），测试：

public class TestDemo2 {
    @Test
    public void test() throws IOException {
        String resource = "延时加载/mybatis.xml";
        //读取配置文件
        InputStream asStream = Resources.getResourceAsStream(resource);
        //创建sqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(asStream);

        //创建sqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //通过动态代理产生StudentMapper对象
        StudentDao mapper = sqlSession.getMapper(StudentDao.class);
        Student1 byId2 = mapper.getById2(1902);
        System.out.println(byId2);
    }
}

在这里插入图片描述
一对一的两种实现就完了，总结：

  • resultType：使用resultType实现较为简单，如果pojo中没有包括查询出来的列名，需要增加列名对应的属性，即可完成映射。如果没有查询结果的特殊要求建议使用resultType。
  • resultMap：需要单独定义resultMap，实现有点麻烦，如果对查询结果有特殊的要求，使用resultMap可以完成将关联查询映射pojo的属性中。

resultMap可以实现延迟加载，resultType无法实现延迟加载。

一对多关联映射

方式一：resultType

这个和上面一对一关联映射的resultType实现差不多，也需要一个新类，因为返回的是一个新对象，需要注意的是一对多的时候一个班级对应多个学生，所以返回的是集合，重要的点我截图如下，其他的我就略了：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

方式二：resultMap

重点来说通过resultMap如何实现吧，因为一对多的关联映射的resultMap实现和一对一的resultMap实现不一样：

他需要在班级类里面添加学生的集合属性（创建了一个新的类Classes1）：

public class Classes1 {
    private int Cid;
    private String Cname;
    private List<Student> list;

    //get、set和toString方法略
}

在ClassesDao接口里面添加方法：

public interface ClassesDao {
    public List<ClassesVo> getById1(int id);
    public Classes1 getById2(int id);  //添加方法
}

然后主要看的就是对应的ClassesDao1.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.tulun7.dao.ClassesDao">
    <resultMap id="classesMap" type="com.tulun7.bean.Classes1">
        <id column="Cid" property="Cid"/>
        <result column="Cname" property="Cname"/>

        <!-- 一对多采用collection集合映射
            collection: 将关联查询到的多条记录映射到对象集合中
            property: 对应类的属性
            ofType:指定映射的类 -->
        <collection property="list" ofType="com.tulun7.bean.Student">
            <id column="Sid" property="Sid"/>
            <result column="Sname" property="Sname"/>
            <result column="Cid" property="Cid"/>
        </collection>
    </resultMap>

    <select id="getById2" resultMap="classesMap">
        select
            classes.Cid,
            classes.Cname,
            student1.Sid,
            student1.Sname,
            student1.Cid
        from
            student1,classes
        where
            student1.Cid = classes.Cid
            and classes.Cid = #{id}
    </select>
</mapper>

改一下全局配置文件mybati.xml的映射文件的位置，测试：

public class TestDemo4 {
    @Test
    public void test() throws IOException {
        String resource = "延时加载/mybatis3.xml";
        //读取配置文件
        InputStream asStream = Resources.getResourceAsStream(resource);
        //创建sqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(asStream);

        //创建sqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //通过动态代理产生StudentMapper对象
        ClassesDao mapper = sqlSession.getMapper(ClassesDao.class);
        Classes1 byId2 = mapper.getById2(1);
        System.out.println(byId2);
    }
}

在这里插入图片描述

多对多关联映射

这个给篇别人的博文的地址吧→https://blog.csdn.net/hefenglian/article/details/80699723

延迟加载

延迟加载或者也叫惰性加载，懒加载。使用延迟加载可以提高程序的运行效率。Java程序与数据库交互的频次越低，程序运行效率越高，所以我们应该尽量减少Java程序与数据库的交互次数，MyBatis延迟加载就很好的做到了这一点。

通过一个具体的业务场景来理解延迟加载：

班级(Classes)和学生(Student)，当我们查询Student对象时，因为有级联关系，所以会将对应的Classes对象一并查询出来，这样就需要发送两条SQL语句，分别查询classes表和student表中的数据。

延迟加载的思路是：当我们查询Student的时候，如果没有调用classes属性，则只发送了一条SQL语句查询Student；如果需要调用classes属性，则发送两条SQL语句查询Student和Classes。所以延迟加载可以看做是一种优化机制，根据具体的代码，自动选择发送的SQL语句条数。

如果不使用延迟加载：

先创建两个bean类：

public class Student1 {
    private int Sid;
    private String Sname;
    private int Cid;
    private Classes classes; //把关联的这儿当属性
    
    //get、set和toString方法略
}

public class Classes {
    private int Cid;
    private String Cname;

    //get、set和toString方法略
}

两个对应的dao层接口：

public interface StudentDao {
    public Student1 getById2(int id);
}

public interface ClassesDao {
    public Classes getById3(int id);
}

当我们不使用延迟加载的时候，那么对应的ClassesDao2.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.tulun7.dao.ClassesDao">
    <select id="getById3" parameterType="java.lang.Integer" resultType="com.tulun7.bean.Classes">
        select * from classes where classes.Cid = #{id}
    </select>
</mapper>

对应的StudentDao2.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.tulun7.dao.StudentDao">
    <resultMap id="student1Map" type="com.tulun7.bean.Student1">
        <id column="Sid" property="Sid"/>
        <result column="Sname" property="Sname"/>
        <result column="Cid" property="Cid"/>
        <!--需要使用select属性 后面跟对应接口的全路径名加对应的方法名-->
        <association column="Cid" property="classes"  javaType="com.tulun7.bean.Classes"
                     select="com.tulun7.dao.ClassesDao.getById3">
        </association>
    </resultMap>

    <select id="getById2" resultMap="student1Map">
        select * from student1 where Student1.Sid = #{id}
    </select>
</mapper>

全局配置文件如下mybatis4.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <!-- 打印查询语句 -->
        <setting name="logImpl" value="LOG4J"></setting>
        
    </settings>

    <!--数据源配置-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?serverTimezone=GMT&amp;useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <!--映射-->
    <mappers>
        <mapper resource="延时加载/ClassesDao2.xml"/>
        <mapper resource="延时加载/StudentDao2.xml"/>
    </mappers>

</configuration>

测试代码：

public class TestDemo5 {
    @Test
    public void test() throws IOException {
        String resource = "延时加载/mybatis4.xml";
        //读取配置文件
        InputStream asStream = Resources.getResourceAsStream(resource);
        //创建sqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(asStream);

        //创建sqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //通过动态代理产生StudentMapper对象
        StudentDao mapper = sqlSession.getMapper(StudentDao.class);
        Student1 byId2 = mapper.getById2(1901);
        System.out.println(byId2.getSname());
    }
}

在这里插入图片描述
结果如图所示，我查询了一个学生表并且只需要一个学生姓名即可，而实际却有两条sql，分别查询了学生表、班级表，当前我在查询的时候，查询是学生表，可以看作我并不需要班级表的信息，而它这样的加载方式也叫积极加载，即把关联的表信息也查询一次，不管你需不需要，这样就会存在一定的效率问题，所以我们引进了延迟加载这种加载方式，也即按需加载；

如果使用延迟加载：

在上面的全局配置文件里面打开延迟加载开关、开启按需加载即可：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <settings>
        <!-- 打印查询语句 -->
        <setting name="logImpl" value="LOG4J"></setting>
        <!--================================================-->
        <!-- 打开延迟加载的开关 -->
        <setting name="lazyLoadingEnabled" value="true" />
        <!-- 将即时加载改为按需加载 他默认的是积极加载-->
        <setting name="aggressiveLazyLoading" value="false"/>
        <!--================================================-->
    </settings>

    <!--数据源配置-->
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?serverTimezone=GMT&amp;useSSL=false&amp;useUnicode=true&amp;characterEncoding=UTF-8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            </dataSource>
        </environment>
    </environments>

    <!--映射-->
    <mappers>
        <mapper resource="延时加载/ClassesDao2.xml"/>
        <mapper resource="延时加载/StudentDao2.xml"/>
    </mappers>

</configuration>

再次测试（测试代码同上）：
在这里插入图片描述
它就只有一条sql语句了，而当我们需要查询班级信息时，它会按需加载：

public class TestDemo7 {
    @Test
    public void test() throws IOException {
        String resource = "延时加载/mybatis5.xml";
        //读取配置文件
        InputStream asStream = Resources.getResourceAsStream(resource);
        //创建sqlSessionFactory
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(asStream);

        //创建sqlSession
        SqlSession sqlSession = sqlSessionFactory.openSession();
        //通过动态代理产生StudentMapper对象
        StudentDao mapper = sqlSession.getMapper(StudentDao.class);
        Student1 byId2 = mapper.getById2(1901);
        System.out.println(byId2.getClasses());
    }
}

在这里插入图片描述

中都
关注
专栏目录
MyBatis延迟加载介绍——控制pojo对象延迟加载
程序员光剑
07-28 1095
在分布式系统中，应用服务器将数据库的数据通过网络传输到客户端时，在数据传输过程中会存在网络延迟、客户端处理慢等问题。为了避免这些问题发生，延迟加载（Lazy Loading）是一种常用的优化策略。它允许对象中所需字段的数据先不进行加载，直到需要用到的时候才从数据库中查询加载。MyBatis中的延迟加载实现了该功能。本文主要介绍 MyBatis 框架对延迟加载的支持及其配置方法，并结合具体代码实例演示延迟加载的使用方法。
mybatis Spring Boot启动慢
Java开源程序猿
01-07 1731
使用启动分析工具，如Spring Boot的Actuator、VisualVM等，查看启动过程中的耗时操作，定位具体的性能瓶颈。检查项目中使用的MyBatis和相关依赖的版本，可能存在一些已知的性能问题，通过升级到最新版本来解决。注解中配置了过于宽泛的包路径，导致MyBatis扫描了大量的Mapper接口，可能会拖慢启动速度。MyBatis中的二级缓存可以提高查询性能，但在某些情况下，不合理的配置可能导致启动变慢。数据库连接池的性能对启动速度也有影响，可以考虑使用性能较好的连接池，如HikariCP。
Mybatis的延迟加载
qq_43223307的博客
11-19 407
1、介绍 延迟加载，可以简单理解为，只有在使用的时候，才会发出sql语句进行查询。 2、为什么要用延迟加载 减少访问数据库的频率，我们要访问的数据量过大时，明显用缓存不太合适，因为内存容量有限为了减少并发量，减少系统资源的消耗。 3、配置延迟加载 1》局部延迟加载 （1）association、collection标签中添加fetchType=”lazy”设置局部延时加载。 <resultMap id="mtmrs02" type="student"> &lt...
MyBatis延迟加载及实现原理
最新发布
2301_76166241的博客
07-05 1157
延迟加载主要就是通过动态代理模式实现，通过代理拦截指定方法，从而现用现查，将结果设置到代理对象中返回，执行数据加载。
【MyBatis学习11】MyBatis中的延迟加载
热门推荐
武哥聊编程
06-15 4万+
1. 什么是延迟加载 　　举个例子：如果查询订单并且关联查询用户信息。如果先查询订单信息即可满足要求，当我们需要查询用户信息时再查询用户信息。把对用户信息的按需去查询就是延迟加载。 所以延迟加载即先从单表查询、需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。 　　我们来对比一下： 关联查询：SELECT orders.*, user.use
Mybatis延迟加载
Forrit的博客
10-21 235
5h 什么是延迟加载呢？ 通俗的讲就是按需加载，我们需要什么的时候再去进行什么操作。 5h 什么时候会用到延迟加载呢？ 多表单独查询的时候。 而且先从单表查询，需要时再从关联表去关联查询，能大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。 延迟加载分为两种：深度延时加载，侵入式延迟加载 5h 如何开启延时加载？ mybatis.xml中进行配置 <settings> <!--延迟加载总开关,打开后，默认的是深度延时加载 --> <setting name="la
（4）Mybatis————JNDI数据源的使用，延迟加载，缓存以及使用注解开发
qq_2533491534的博客
07-01 553
1，JNDI数据源 2，Mybatis 延迟加载策略 2.1，何为延迟加载? 2.2，使用 assocation 实现延迟加载 2.3，使用 Collection 实现延迟加载 3，Mybatis 缓存 3.1，Mybatis 一级缓存 3.2，Mybatis 二级缓存 4，Mybatis 注解开发 4.1，mybatis 的常用注解说明 4.2，使用 Mybatis 注解实现基本 CRUD 4.3，使用 Collection 实现延迟加载 4.4，Mybatis 中简化编写的 SQL 片段
使用Mybatis实现延迟加载
不思量
04-18 744
实例演示Mybatis的延迟加载
MyBatis 延迟加载（懒加载）—— association 延迟加载、collection 延迟加载
骑着蜗牛行天下
09-22 727
一、概述 1、延迟加载： 就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载 2、好处： 先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。 3、坏处： 因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗时间，所以可能造成用户等待时间变长，造成用户体验下降。 4、MyBatis 多表查询 在多表查询时，使用了resultMap来实现一对一，一对多，多对多关系的操作。主要是通过
MyBatis概述——一个优秀的持久层框架
程序员光剑
07-28 1041
MyBatis 是一款开源的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和参数处理，将 XML 配置化结果映射成 Java 对象并通过接口形式传入到业务层，使得开发人员更关注于业务逻辑而不是数据库相关的事务控制和重复代码等低级事务性工作。
Mybatis源码剖析：延迟加载源码剖析
丿涛哥哥的博客
05-27 624
Mybatis源码剖析：延迟加载源码剖析 1、什么是延迟加载？ 在开发过程中很多时候我们并不需要总是在加载用户信息时就一定要加载他的订单信息。此时就是我们所说的延迟加载。 举个栗子 * 在一对多中，当我们有一个用户，它有个100个订单 在查询用户的时候，要不要把关联的订单查出来？ 在查询订单的时候，要不要把关联的用户查出来？ * 回答 在查询用户时，用户下的订单应该是，什么时候用，什么时候查询。 在查询订单时，订单所属的用户信息应该是随着订单一起查询出来。 延迟加载 就是在需要用到数据时才进行
mybatis中的延迟加载
xiaotai1234的博客
06-21 310
mybatis中的延迟加载 1.使用场景 实际开发过程中很多时候我们并不需要总是在加载用户信息时就一定要加载他的账户信息。此时就是我们所说的延迟加载。 2.何为延迟加载 前面实现多表操作时，我们使用了resultMap来实现一对一，一对多，多对多关系的操作。主要是通过association、collection实现一对一及一对多映射。association、collection具备延迟加载功能。 3.使用Assocation实现延迟加载 第一步：只查询账户信息的Mapper接口 SQL：select *
mybatis开启延迟加载
aidupo6157的博客
01-02 123
在mybatis核心配置文件中配置： lazyLoadingEnabled、aggressiveLazyLoading 设置项 描述 允许值 默认值 lazyLoadingEnabled 全局性设置懒加载。如果设为‘false’，则所有相关联的都会被初始化加载。 true|false f...
MyBatis的延迟加载
1024
08-12 245
MyBatis的延迟加载 查询中存在的问题 前提: 在一对多的关系中, 有一个用户, 对应100个账户 在查询用户的时候, 是否需要把关联的账户查询出来? 在查询账户的时候, 是否需要把关联的用户查询出来? 如何查询 在查询用户时, 用户下的账户应该什么时候使用, 什么时候查询 (按照需求加载) 在查询账户时, 账户的所属用户信息应该时随着账户查询时一起查询出来(立即加载) 在查询用户时, 是按照需求查询该用户下的账户信息, 体现了延迟加载. 两种查询的模式因为查询数据的时机而不同. 延迟加载&a
Mybatis-延迟加载
Java后端技术栈
10-25 397
问题在开发过程中很多时候我们并不需要总是在加载用户信息时就一定要加载他的订单信息。此时就是我们所说的延迟加载。举个栗子* 在一对多中，当我们有一个用户，它有个100个订单在查询用户的时候，要不要把关联的订单查出来？在查询订单的时候，要不要把关联的用户查出来？* 回答在查询用户时，用户下的订单应该是，什么时候用，什么时候查询。在查询订单时，订单所属的用户信息应该是随着订单一起查询出来。延迟加载就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值