mybatis事务与懒加载和缓存机制

最新推荐文章于 2023-05-05 13:47:04 发布
最新推荐文章于 2023-05-05 13:47:04 发布
阅读量289 收藏
点赞数
分类专栏： javaEE
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41578371/article/details/108956263
版权

mybatis事务与懒加载和缓存机制

mybatis连接池与事务

连接池
<?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>
    <!--配置数据库信息-->
    <environments default="mysql">
        <!--数据库编号-->
        <environment id="mysql">
            <!--配置 jdbc 事务管理器-->
            <transactionManager type="JDBC"></transactionManager>
            <!--配置数据源 采用mybatis提供的连接池（POOLED,UNPOOLED,JNDL）-->
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                <property name="username" value="root"/>
                <property name="password" value="root"/>
            </dataSource>
        </environment>
    </environments>

    <!--xml sql 配置文件映射位置-->
    <mappers>
        <mapper resource="com/stack/mapper/UserMapper.xml"></mapper>
    </mappers>
</configuration>

mybatis在使用时我们可以通过配置 datasource的 type 属性来决定是否使用数据库连接池。mybatis 内部分别定义和实现了 Java.sql.DataSource 接口的UnPooledDateSource,PooledDateSource 类来表示 UNPOOLED、POOLED的数据源。也就是我们可以在配置中选择我们将要采用的数据源。使用数据连接池可以减少我们频繁的创建释放连接，获取资源。可以提高数据库连接的利用效率，减少我们的资源浪费。

image-20201005215041022

事务

事务是一组sql语句，这组sql语句作为整体来执行，要么全都成功，要么全都失败，具有ACID属性。关于更详细的有关事务的理论我就不在这里过多说明。大家都知道mybatis本身就是对jdbc进行的封装，所以mybatis本身的事务支持也就是 jdbc 的事务支持。

image-20201005215000285

在 jdbc中在 JDBC 中我们可以通过手动方式将事务的提交改为手动方式，通过 setAutoCommit() [connection对象]方法就可以调整。

mybatis中对事务默认是手动提交的方式，这也符合我们对事务进行控制的特点。

//1.读取配置文件
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.创建构建者对象
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//3.创建 SqlSession 工厂对象
factory = builder.build(in);
//4.创建 SqlSession 对象,手动提交事务
session = factory.openSession();
//5.创建 Dao 的代理对象
userDao = session.getMapper(IUserDao.class);
//6.事务提交
session.commit()
//7.事务回滚
session. rollback()

mybatis自动提交事务支持

//4.创建 SqlSession 对象,自动提交事务
session = factory.openSession(true);

延迟加载

通过mybatis中一对一，一对多，多对多关系的配置，我们可以实现对象的关联查询。实际应用中很多时候我们并不需要总是在加载用户信息时就加载他相关的账户信息，此时就需要我们所说的延迟加载

延迟加载就是我们需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称为懒加载。

好处：先从单表查询，需要时在去从关联表查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。

坏处：只有当需要用到数据时，才进行数据库查询，这样在大批量数据查询时，因为查询工作也需要时间，所以可能造成用户等待时间变长，造成用户体验下降。

/**
需求：查询账户 Account 信息并且关联查询用户 User 信息。如果先查询账户 Account 信息即可满足要求，当我们需要查询用户 User 信息时再查询用户 User 信息。把对用户 User 信息的按需查询就是延迟加载。
mybatis在实现多表操作时，我们使用 resultMap 来实现 一对一，一对多，多对多关系操作，主要用过 association collection 实现 一对一 一对多 映射。因此 association collection 具备延迟加载的功能
*/
使用assocation 实现延迟加载

查询账户信息同时延迟加载查询其用户信息

mapper接口
public interface IAccountDao {
/**
* 查询所有账户，同时获取账户的所属用户名称以及它的地址信息
* @return
*/
List<Account> findAll();
}

public interface IUserDao {
/**
* 根据 id 查询
* @param userId
* @return
*/
User findById(Integer userId);
}
map映射配置文件
<?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.stack.dao.IAccountDao">
<!-- 建立对应关系 --> 
<resultMap type="com.stack.bean.Account" id="accountMap">
    <id column="aid" property="id"/>
    <result column="uid" property="uid"/>
    <result column="money" property="money"/>
     <!-- 它是用于指定从表方的引用实体属性的 --> 
    <association property="user" javaType="user"
         select="com.stack.dao.IUserDao.findById"
         column="uid">
    </association>
</resultMap> 
    <select id="findAll" resultMap="accountMap">
       select * from account
    </select>
</mapper>
select： 填写我们要调用的 select 映射的 id 
column ： 填写我们要传递给 select 映射的参数

<?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.stack.dao.IUserDao">
<!-- 根据 id 查询 --> 
    <select id="findById" resultType="user" parameterType="int" >
      select * from user where id = #{uid}
     </select>
</mapper>
在mybatis环境中配置（SqlMapConfig）开启 mybatis 延迟加载的设置
<settings> 
    <!--开启延迟加载可用-->
    <setting name="lazyLoadingEnabled" value="true"/>
    <!--关闭延迟加载不可用-->
    <setting name="aggressiveLazyLoading" value="false"/>
</settings>
编写测试类
public class AccountTest {
    private InputStream in ;
    private SqlSessionFactory factory;
    private SqlSession session;
    private IAccountDao accountDao;
    
   @Before//在测试方法执行之前执行
   public void init()throws Exception {
       //1.读取配置文件
       in = Resources.getResourceAsStream("SqlMapConfig.xml");
       //2.创建构建者对象
       SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
       //3.创建 SqlSession 工厂对象
       factory = builder.build(in);
       //4.创建 SqlSession 对象
       session = factory.openSession();
       //5.创建 Dao 的代理对象
      accountDao = session.getMapper(IAccountDao.class);
   } 
   @Test
    public void testFindAll() {
       //6.执行操作
        List<Account> accounts = accountDao.findAll();
    }
   @After//在测试方法执行完成之后执行
   public void destroy() throws Exception{
   //7.释放资源
   session.close();
   in.close();
   }
}
测试结果

image-20201006111741130

本次只是将Account对象查询出来放入List集合中，并没有涉及到 User 对象，所以就没有发出Sql语句查询账户所关联的User信息。延迟加载生效。

使用collection 实现延迟加载

查询用户信息同时延迟加载查询其相关账户信息

用户实体类
public class User implements Serializable {
private Integer id;
private String username;
private Date birthday;
private String sex;
private String address;
private List<Account> accounts;
//get set 无参构造方法省略
    
}
编写mapper接口相关方法
/**
*查询所有用户信息
*/
List<User> findAll();
/**
* 根据用户 id 查询账户信息
* @param uid
* @return
*/
List<Account> findByUid(Integer uid);
map映射配置文件
<resultMap type="com.stack.bean.User" id="userMap">
    <id column="id" property="id"></id>
    <result column="username" property="username"/>
    <result column="address" property="address"/>
    <result column="sex" property="sex"/>
    <result column="birthday" property="birthday"/>
     <!-- collection 是用于建立一对多中集合属性的对应关系
      ofType 用于指定集合元素的数据类型
      select 是用于指定查询账户的唯一标识（账户的 dao 全限定类名加上方法名称）
      column 是用于指定使用哪个字段的值作为条件查询
      --> 
    <collection property="accounts" ofType="account"
       select="com.stack.dao.IAccountDao.findByUid"
       column="id">
     </collection>
</resultMap>
<!-- 配置查询所有操作 --> 
<select id="findAll" resultMap="userMap">
      select * from user
</select>
collection标签：
主要用于加载关联的集合对象
select 属性：
用于指定查询 account 列表的 sql 语句，所以填写的是该 sql 映射的 id
column 属性：
用于指定 select 属性的 sql 语句的参数来源，上面的参数来自于 user 的 id 列，所以就写成 id 这一
个字段名了

<!-- 根据用户 id 查询账户信息 --> 
<select id="findByUid" resultType="com.stack.bean.Account" parameterType="int">
     select * from account where uid = #{uid}
</select>
编写测试类
public class UserTest {
      private InputStream in ;
      private SqlSessionFactory factory;
      private SqlSession session;
      private IUserDao userDao;
   
      @Before//在测试方法执行之前执行
      public void init()throws Exception {
      //1.读取配置文件
      in = Resources.getResourceAsStream("SqlMapConfig.xml");
      //2.创建构建者对象
      SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
      //3.创建 SqlSession 工厂对象
      factory = builder.build(in);
     //4.创建 SqlSession 对象
     session = factory.openSession();
     //5.创建 Dao 的代理对象
     userDao = session.getMapper(IUserDao.class);
    }
    
   @Test
   public void testFindAll() {
    //6.执行操作
    List<User> users = userDao.findAll();
   }

     @After//在测试方法执行完成之后执行
    public void destroy() throws Exception{
     session.commit();
     //7.释放资源
     session.close();
     in.close();
   }
}
测试结果

image-20201006113304867

我们发现并没有加载 Account 账户信息。延迟加载成功。

mybatis缓存机制

mybatis作为一个持久层的ORM框架，同样向我们提供了缓存策略。通过缓存机制可以减少我们数据库的查询次数，从而提高性能。mybatis的缓存机制分为两级，一级缓存是SqlSession级别的，也就是针对一个SqlSession会话，当SqlSession.close()掉或重新获取SqlSession对象，一级缓存也就消失没有了。二级缓存是NameSpace级别的，针对于一个NameSpace配置。作用范围大于SqlSession。

image-20201006142653351

一级缓存测试

一级缓存是SqlSession级别的缓存，只要SqlSession没有flush 或 close,它就存在

public interface IUserDao {
/**
* 根据 id 查询
* @param userId
* @return
*/
User findById(Integer userId);
}

<?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.stack.dao.IUserDao">
    <!-- 根据 id 查询 --> 
    <select id="findById" resultType="con.stack.bean.User" parameterType="int">
         select * from user where id = #{uid}
      </select>
</mapper>

public class UserTest {
private InputStream in ;
private SqlSessionFactory factory;
private SqlSession session;
private IUserDao userDao;
@Test
public void testFindById() {
//6.执行操作
User user = userDao.findById(41);
System.out.println("第一次查询的用户："+user);
User user2 = userDao.findById(41);
System.out.println("第二次查询用户："+user2);
System.out.println(user == user2);
}
@Before//在测试方法执行之前执行
public void init()throws Exception {
//1.读取配置文件
in = Resources.getResourceAsStream("SqlMapConfig.xml");
//2.创建构建者对象
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
//3.创建 SqlSession 工厂对象
factory = builder.build(in);
//4.创建 SqlSession 对象
session = factory.openSession();
//5.创建 Dao 的代理对象
userDao = session.getMapper(IUserDao.class);
}
@After//在测试方法执行完成之后执行
public void destroy() throws Exception{
//7.释放资源
session.close();
in.close();
} 
}

image-20201006143310410

我们可以发现，虽然在上面的代码中我们查询了两次，但最后只执行了一次数据库操作，这就是 Mybatis 提

供给我们的一级缓存在起作用了。因为一级缓存的存在，导致第二次查询 id 为 41 的记录时，并没有发出 sql 语句

从数据库中查询数据，而是从一级缓存中查询。

image-20201006143419210

image-20201006143442125

二级缓存测试

二级缓存是mapper映射级别的缓存，多个SqlSession去操作同一个Mapper映射的Sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。注意点：当我们在使用二级缓存时，所缓存的类一定要实现 java.io.Serializable 接口，这种就可以使用序列化方式来保存对象。

image-20201006143801047

image-20201006143819017

二级缓存的使用
SqlMapConfig中开启二级缓存支持
<settings>
<!-- 开启二级缓存的支持 --> 
    <setting name="cacheEnabled" value="true"/>
</settings>
因为 cacheEnabled 的取值默认就为 true，所以这一步可以省略不配置。为 true 代表开启二级缓存；为
false 代表不开启二级缓存。

<cache>标签表示当前这个 mapper 映射将使用二级缓存，区分的标准就看 mapper 的 namespace 值。
<?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.stack.dao.IUserDao">
      <!-- 开启二级缓存的支持 -->
      <cache></cache>
</mapper>

<!-- 根据 id 查询 -->
<select id="findById" resultType="com.stack.bean.User" parameterType="int" useCache="true">
  select * from user where id = #{uid}
</select> 
将 UserDao.xml 映射文件中的<select>标签中设置 useCache=”true”代表当前这个 statement 要使用
二级缓存，如果不使用二级缓存可以设置为 false。
注意：针对每次查询都需要最新的数据 sql，要设置成 useCache=false，禁用二级缓存

public class SecondLevelCacheTest {
 private InputStream in;
 private SqlSessionFactory factory;
 @Before//用于在测试方法执行之前执行
 public void init()throws Exception{
 //1.读取配置文件，生成字节输入流
 in = Resources.getResourceAsStream("SqlMapConfig.xml");
 //2.获取 SqlSessionFactory
 factory = new SqlSessionFactoryBuilder().build(in);
 }
 @After//用于在测试方法执行之后执行
 public void destroy()throws Exception{
 in.close();
 }
 /**
 * 测试一级缓存
 */
 @Test
 public void testFirstLevelCache(){
 SqlSession sqlSession1 = factory.openSession();
 IUserDao dao1 = sqlSession1.getMapper(IUserDao.class);
 User user1 = dao1.findById(41);
 System.out.println(user1);
 sqlSession1.close();//一级缓存消失
 SqlSession sqlSession2 = factory.openSession();
 IUserDao dao2 = sqlSession2.getMapper(IUserDao.class);
 User user2 = dao2.findById(41);
 System.out.println(user2);
 sqlSession2.close();
 System.out.println(user1 == user2);
 } }

经过上面的测试，我们发现执行了两次查询，并且在执行第一次查询后，我们关闭了一级缓存，再去执行第二

次查询时，我们发现并没有对数据库发出 sql 语句，所以此时的数据就只能是来自于我们所说的二级缓存。

补充

如果使用注解开发的话，要想使用二级缓存的话，就在Mapper映射接口上使用@CacheNamespace注解就可以。

stackldy
关注
专栏目录
第十八篇：MyBatis事务管理详解
AI天才研究院
08-01 2546
MyBatis 是一款优秀的持久层框架。它支持自定义 SQL、存储过程以及高级映射，是一个强大的 ORM 框架。MyBatis 在 SQL 执行过程中的自动提交、事务管理都是基于数据库来实现的，但是对于嵌套事务的处理并不友好。因此，开发人员需要在 MyBatis 的基础上自行编写相关的代码来实现事务管理功能。本文将从以下几个方面对 MyBatis 中的事务管理进行详细阐述：1) MyBatis 中事务管理的机制2) 分布式事务的实现方法。
mybatis教程5(延迟加载和缓存)
波波烤鸭的博客
01-22 2538
关联关系 在关系型数据库中，表与表之间很少是独立与其他表没关系的。所以在实际开发过程中我们会碰到很多复杂的关联关系。在此我们来分析下载mybatis中怎么处理这些关系 1对1关系 我们有一张员工表(T_EMP)，一张部门表(T_DEPT)。员工表中的一条记录对应于部门表中有且仅有一条记录。这就是一对一的关联关系。 查询每个员工的信息及对应的部门信息 对象与对象1对1 部门对象: // 部...
Mybatis的懒加载
Jiale1998的博客
05-11 685
1.什么是mybatis懒加载？ 懒加载也叫延时加载，一般出现在有一对一或者一对多映射的情况下。简单的说就是你需要的时候就加载，你不需要的时候就不加载 2.使用场景：比如说查询所有订单有时候我们需要关联出下单人的信息 第一种方法传统方法：直男思想，一步查，例如 <select id="getOrderAndCustomer" resultType="com.jl.pojo.Order"&...
mybatis中懒加载 及缓存机制——小马同学@Tian
SigleDog的博客
11-15 263
mybatis懒加载（必须是嵌套查询情况） 1.1简述 也称为延时加载，刚开始查询的时候，不会查询出关联的数据，当使用这些数据时，再进行查询 第一步 映射文件中：fetchType="lazy" 第二步 主配置文件中： <!-- 参数设置 --> <settings> <!-- 启用懒加载，必须按照下面方式配置 --> <setting name="lazyLoadingEnabled" value="true"/> <!-- 将
mybatis懒加载与缓存
Gavin
12-05 818
懒加载与积极懒加载; 在接触mybatis时我们会学到接触小知识,关于懒加载的一些知识点还是需要亲自去测试一下才能加深理解; 在这之前问我们都接触过关于时间和空间局部性原理,在这里不做多说; 接下来是案例的实际操作过程---->> 首先准备两个关联的表,还是熟悉的表,还是熟悉的数据— 商品信息与订单信息表
Mybatis懒加载和缓存机制
qq_32130127的博客
09-18 677
mybatis的配置缓存机制和懒加载                                                       开启二级缓存还需要在nameSpace中配置cache标签，在需要开启二级缓存的Mapper映射文件中添加一行：，表示此mapper开启二级缓存。而且在pojo类中药实现序列化，如果存在父类，则父类也需要序列化。
Mybatis缓存+懒加载概念
Strong_shady的博客
07-14 217
一级缓存： 一级缓存是sqlsession级别的缓存，会话一结束缓存就被刷新 在操作数据库时，需要构造sqlsession对象，在对象中有一个数据结构（HashMap）用于存储缓存数据 不同的sqlsession之间的缓存区域是互相不影响的。 第一次发起查询sql查询用户id为1的用户，先去找缓存中是否有id为1的用户，如果没有，再去数据库查询用户信息。得到用户信息，将用户信息存储到一级缓存中。 如果sqlsession执行了commit操作（插入，更新，删除），会清空sqlsession中的一级缓存，
Mybatis延迟加载和缓存
07-22
本篇将深入探讨 Mybatis 的两个重要特性：延迟加载（Lazy Loading）和缓存机制。 ### 延迟加载（Lazy Loading） 延迟加载是一种优化策略，它的核心思想是不立即加载所有数据，而是在实际需要时才进行加载。在 ...
Mybatis延迟加载与缓存深度解析
"本文将深入探讨Mybatis框架中的延迟加载和缓存机制，提供相关示例代码以帮助理解和应用。" 在Mybatis中，延迟加载（Lazy Loading）和缓存是两个关键特性，它们能够显著提升数据库操作的性能。延迟加载是一种优化...
MyBatis中的懒加载与代理模式
在开发中，当一个对象的创建和初始化过程较为复杂、耗时且并不是必需的时候，我们可以采用懒加载的方式来实现延迟加载，只有在真正需要使用该对象时才去创建和初始化。 ## 1.2 什么是代理模式 代理模式（Proxy ...
mybatis中association和collection标签的分步执行和懒加载
qq_34917117的博客
06-16 477
association和collection是mybatis sql映射文件中封装结果集的两个标签 association标签 1、简单级联封装Bean 类似于一个员工对应一个部门的pojo封装 public class Employee { private Integer id; private String lastName; private char gender...
Mybatis延迟加载以及缓存机制
qq_43814760的博客
04-17 575
1.延迟加载的概述 延迟加载的使用：嵌套查询。 延迟加载又称懒加载、按需加载。作用是使用数据的时候才去做数据库的查询，从而降低系统的消耗。 当数据量过大时，不建议使用 2.延迟加载的实现 2.1 局部加载 1.导入依赖 <dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>3.1</...
mybatis association 懒加载实现原理
wangjun5159的专栏
08-06 5937
前言mybatis的association 标签可以设置关联对象，加载方式；如下的user关联dept，加载方式fetchType=”eager” <resultMap id="BaseResultMap" type="testmaven.entity.User"> <id column="id" jdbcType="INTEGER" property="id" /> <result
mybatis的加载机制和缓存
weixin_43423541的博客
07-12 210
mybatis的加载机制和缓存 1.mybatis中的延迟加载 延迟加载：在真正使用数据时才发起查询，不用的时候不查询。按需加载（懒加载） 立即加载：不管用不用，只要一调用方法，马上发起查询。 在对应的四种表关系中：一对多，多对一，一对一，多对多 一对多，多对多：通常情况下我们都是采用延迟加载。 多对一，一对一：通常情况下我们都是采用立即加载。 2.mybatis中的缓存 缓存： 存在于内存中的临时数据 缓存的意义： 减少和数据库的交互次数，提高执行效率。 适用于缓存： 经
spring中的懒加载与事务+StringBuilder+规则引擎drools+RPC+etcd=2020/9/7~9/18（待补充）
qq_37337660的博客
09-20 300
一、spring中的懒加载与事务 问题出在为了在使用jpa的时候为了避免ifPresent判断。自己把jpa的find方法改成了get方法。就会出现no session报错。 原因和办法： 1.getOne和findOne都是springdata提供的根据id查找单个实体的方法，区别是前者是懒加载，后者是立即加载。我们使用getOne来进行懒加载的实验，就不用大费周章去写懒加载属性，设置多个实体类了。 2.因为spring的session是和线程绑定的，在整个model->dao->servic
八、(了解即可)MyBatis懒加载(或者叫延迟加载)
最新发布
刘大猫
05-05 2072
八、(了解即可)MyBatis懒加载(或者叫延迟加载)
MyBatis懒加载(延迟加载)
Mu木
03-12 420
定义： 懒加载就是在需要使用这个数据的时候再去进行查询加载，不需要的时候就不查询。也就是按需加载 优点： 把关联查询分两次来做，而不是一次性查出所有的，延迟加载即先从单表查询、需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。 mybatis支持懒加载，resultMap可以实现高级映射(使用association、collection实现一对一及一对多映射)，association、collection具备延迟加载功能。 需求： 假如现在有两张数据表，购物车和购物车项
MyBatis 延迟加载（懒加载）—— association 延迟加载、collection 延迟加载
骑着蜗牛行天下
09-22 749
一、概述 1、延迟加载： 就是在需要用到数据时才进行加载，不需要用到数据时就不加载数据。延迟加载也称懒加载 2、好处： 先从单表查询，需要时再从关联表去关联查询，大大提高数据库性能，因为查询单表要比关联查询多张表速度要快。 3、坏处： 因为只有当需要用到数据时，才会进行数据库查询，这样在大批量数据查询时，因为查询工作也要消耗时间，所以可能造成用户等待时间变长，造成用户体验下降。 4、MyBatis 多表查询 在多表查询时，使用了resultMap来实现一对一，一对多，多对多关系的操作。主要是通过
mybatis懒加载(延迟加载)
疯狂世界
11-16 1207
Mybatis的懒加载(延迟加载)机制。 懒加载：按需加载，即当使用时候再去查询而不是，未在使用时就发送sql查询出来数据。 作用：降低数据库压力。 用于一对一查询，一对多查询时。 使用：使用resultMap映射数据库类型。使用association、collection实现一对一及一对多映射)。 其实：懒加载就是按需执行，也可以不做此配置。 例如：查询用户并查询出该用户的所有订单，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值