Mybatis的延迟加载和缓存

最新推荐文章于 2022-11-05 01:24:04 发布
最新推荐文章于 2022-11-05 01:24:04 发布
阅读量158 收藏
点赞数
分类专栏： SSM框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/aaa_56234/article/details/108872163
版权

MyBatis框架

今日内容

  • 掌握Mybatis的延迟加载
  • 掌握Mybatis缓存
  • 掌握Mybatis注解开发

项目准备

用户主键查询用户信息

<!--
   主键查询用户信息
-->
<select id="queryUserById" resultType="user" parameterType="int">
    select * from user where id = #{id}
</select>

/**
 * 主键查询用户信息
 */
@Test
public void queryUserById(){
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User user = userMapper.queryUserById(1);
    System.out.println(user);
    sqlSession.close();
}

订单查询用户信息 一对一

<!--
  订单，查询订单对应的用户
-->
<select id="queryOrdersUser" resultMap="queryOrdersUserResultMap">
    SELECT o.id,o.user_id,o.number,o.createtime,o.note,u.username,u.address FROM orders o LEFT JOIN USER u
    ON o.user_id = u.id
</select>

<resultMap id="queryOrdersUserResultMap" type="orders">
    <id column="id" property="id"></id>
    <result column="user_id" property="userId"></result>
    <result column="number" property="number"></result>
    <result column="createtime" property="createtime"></result>
    <result column="note" property="note"></result>

    <association property="user" javaType="user">
        <id column="user_id" property="id"></id>
        <result column="username" property="username"></result>
        <result column="address" property="address"></result>
    </association>
</resultMap>

/**
 * 订单查询用户信息，一对一
 */
@Test
public void queryOrdersUser(){
    System.out.println();
    SqlSession sqlSession = sqlSessionFactory.openSession();
    OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class);
    List<Orders> ordersList = ordersMapper.queryOrdersUser();
    if(ordersList != null && ordersList.size() > 0){
        for (Orders orders : ordersList){
            System.out.println(orders);
        }
    }
    sqlSession.close();
}

用户查询订单信息 一对多

<!--
   根据用户查询订单，一对多
-->
<select id="queryUserOrders" resultMap="queryUserOrdersResultMap">
    SELECT u.id,u.username,u.sex,u.birthday,u.address,o.id oid,o.number,o.createtime  FROM USER u LEFT JOIN orders o
    ON u.id = o.user_id
</select>

<resultMap id="queryUserOrdersResultMap" type="user">
    <id column="id" property="id"></id>
    <result column="username" property="username"></result>
    <result column="sex" property="sex"></result>
    <result column="birthday" property="birthday"></result>
    <result column="address" property="address"></result>

    <collection property="ordersList" ofType="orders">
        <id column="oid" property="id"></id>
        <result column="number" property="number"></result>
        <result column="createtime" property="createtime"></result>
    </collection>
</resultMap>

/**
 * 用户查询订单，一对多
 */
@Test
public void queryUserOrders(){
    System.out.println();
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> list = mapper.queryUserOrders();
    if(list != null && list.size() > 0){
        for(User user : list){
            System.out.println(user);
        }
    }
    sqlSession.close();
}

一对一延迟加载

  • 针对的是关联对象

​ 用户和订单从面相对象的角度来说就是关联对象，当只需要订单数据，尚不需要用户数据的时候，就不应该去查询用户表，啥时候用到用户数据，啥时候查询

  • 一对一延迟加载

​ 关联的sql语句肯定要拆分了

  • association标签
    • column属性：关联查询条件的属性
    • select属性：指定另一个查询语句
<!--
  订单，查询订单对应的用户
  拆分SQL语句，实现延迟加载
-->
<select id="queryOrdersUser" resultMap="queryOrdersUserResultMap">
    SELECT o.id,o.user_id,o.number,o.createtime,o.note FROM orders o
</select>

<resultMap id="queryOrdersUserResultMap" type="orders">
    <id column="id" property="id"></id>
    <result column="user_id" property="userId"></result>
    <result column="number" property="number"></result>
    <result column="createtime" property="createtime"></result>
    <result column="note" property="note"></result>
    <!--
       column指定查询的参数
       select关联其他查询语句 
    -->
    <association property="user" javaType="user" column="user_id" select="queryUserByUserId">
       <!-- <id column="user_id" property="id"></id>
        <result column="username" property="username"></result>
        <result column="address" property="address"></result>-->
    </association>
</resultMap>

<select id="queryUserByUserId" parameterType="int" resultType="user">
    select id,username,sex,birthday,address from user where id=#{user_id}
</select>

/**
 * 订单查询用户信息，一对一
 * 延迟加载
 */
@Test
public void queryOrdersUser(){
    System.out.println();
    SqlSession sqlSession = sqlSessionFactory.openSession();
    OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class);
    List<Orders> ordersList = ordersMapper.queryOrdersUser();
    if(ordersList != null && ordersList.size() > 0){
        for (Orders orders : ordersList){
            System.out.println(orders);
            System.out.println(orders.getUser());
        }
    }
    sqlSession.close();
}

开启延迟加载配置

<settings>
    <!-- 开启延迟加载-->
    <setting name="lazyLoadingEnabled" value="true" />
    <!-- 关闭立即加载-->
    <setting name="aggressiveLazyLoading" value="false" />
    <!-- 设定tostring等方法延迟加载-->
    <setting name="lazyLoadTriggerMethods" value="true" />
</settings>

一对多延迟加载

<!--
   根据用户查询订单，一对多
   延迟加载，拆分SQL语句
-->
<select id="queryUserOrders" resultMap="queryUserOrdersResultMap">
    SELECT u.id,u.username,u.sex,u.birthday,u.address  FROM USER u
</select>

<resultMap id="queryUserOrdersResultMap" type="user">
    <id column="id" property="id"></id>
    <result column="username" property="username"></result>
    <result column="sex" property="sex"></result>
    <result column="birthday" property="birthday"></result>
    <result column="address" property="address"></result>

    <collection property="ordersList" ofType="orders" column="id" select="queryOrdersByUserId">
      <!--  <id column="oid" property="id"></id>
        <result column="number" property="number"></result>
        <result column="createtime" property="createtime"></result>-->
    </collection>
</resultMap>

<select id="queryOrdersByUserId" parameterType="int" resultType="orders">
    select id,number,createtime from orders where user_id = #{user_id}
</select>

/**
 * 用户查询订单，一对多
 * 延迟加载
 */
@Test
public void queryUserOrders(){
    System.out.println();
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> list = mapper.queryUserOrders();
    if(list != null && list.size() > 0){
        for(User user : list){
            System.out.println(user);
            List<Orders> ordersList = user.getOrdersList();
            System.out.println(ordersList);
        }
    }
    sqlSession.close();
}

MyBatis一级缓存

一级缓存：是SqlSession级别的，也就是同一个SqlSession内执行相同select语句的时候，不再去查询数据库，而是从Mybatis内部的缓存内存结构去直接拿到数据。

  • 缓存失效时机：
    • sqlSession关闭
    • sqlSession提交事务（意味着可能是一个增删改的动作，需要更新缓存，那么这个时候Mybatis就会把已有的一级缓存给清理掉）

MyBatis二级缓存

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-EbhYsrlL-1601370821542)(img/1.jpg)]

  • 开启二级缓存

    <setting name="cacheEnabled" value="true" />

    <!-- 具体Mapper.xml配置-->
<cache></cache>

  • 执行结果

/**
 * 主键查询用户信息
 */
@Test
public void queryUserById(){
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User user = userMapper.queryUserById(1);
    System.out.println(user);
    sqlSession.close();
    SqlSession sqlSession1 = sqlSessionFactory.openSession();
    UserMapper userMapper1 = sqlSession1.getMapper(UserMapper.class);
    User user1 = userMapper1.queryUserById(1);
    System.out.println(user1);
    sqlSession1.close();
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Z9FKZ4oL-1601370821544)(img/2.jpg)]

ratio，两次都会去查询二级缓存，但是第一次的时候缓存中没有数据，第二次才有，所以命中率是0.5

  • 注意：Mybatis的二级缓存在使用的时候有很多限制，在实际开发的时候Mybatis的二级缓存应用很少

    比如在其他mapper.xml文件中有对user表的更新，那么UserMapper.xml的二级缓存就可能错误，我们很难要求对一张表的操作全部放到同一个mapper.xml中。

MyBatis注解开发

@Insert注解

  • 注解属性value:写入SQL语句

@Options注解

  • 实现添加新数据的主键封装
  • 注解属性
    • useGeneratedKeys：使用生成的主键，配置为true
    • keyProperty：主键封装的pojo对象属性

@SelectKey注解

  • 实现添加新数据的主键封装
  • 注解属性
    • statement：要执行的SQL语句
    • before：在添加SQL语句之前还是之后进行，配置为false
    • keyProperty：主键封装的pojo对象属性

注解实现添加数据

  • UserMapper接口

    //新增用户数据
@Insert("insert into user(username,sex,birthday,address)values(#{username},#{sex},#{birthday},#{address})")
void saveUser(User user);

  • UserMapper测试

    /**
 * 注解开发
 * 添加用户数据
 */
@Test
public void testSaveUser(){
    SqlSession sqlSession = sqlSessionFactory.openSession();
    User user = new User();
    user.setUsername("孙权");
    user.setSex("1");
    user.setBirthday(new Date());
    user.setAddress("东吴");
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    userMapper.saveUser(user);
    sqlSession.commit();
    System.out.println(user);
    sqlSession.close();
}

@Update注解

  • 注解属性value:写入SQL语句

注解实现更新数据

  • UserMapper接口

    //跟新用户
@Update("update user set username=#{username},sex=#{sex},birthday=#{birthday},address=#{address} where id=#{id}")
void updateUser(User user);

  • UserMapper测试

    /**
 * 注解开发
 * 更新用户数据
 */
@Test
public void testUpdateUser(){
    SqlSession sqlSession = sqlSessionFactory.openSession();
    User user = new User();
    user.setId(21);
    user.setUsername("孙策");
    user.setSex("2");
    user.setBirthday(new Date());
    user.setAddress("江东");
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    userMapper.updateUser(user);
    sqlSession.commit();
    sqlSession.close();
}

@Delete注解

  • 注解属性value:写入SQL语句

注解实现删除数据

  • UserMapper接口

    //删除用户
@Delete("delete from user where id = #{id}")
void deleteUser(int id);

  • UserMapper测试

    /**
 * 注解开发
 * 更新用户数据
 */
@Test
public void testDeleteUser(){
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    userMapper.deleteUser(21);
    sqlSession.commit();
    sqlSession.close();
}

@Select注解

  • 注解属性value:写入SQL语句

注解实现主键查询用户数据

  • UserMapper接口

    //主键查询用户
@Select("select id,username,sex,birthday,address from user where id = #{id}")
User queryUserById(int id);

  • UserMapper测试

    /**
 * 注解开发
 * 主键查询用户
 */
@Test
public void testQueryUserById(){
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User user = userMapper.queryUserById(1);
    System.out.println(user);
    sqlSession.close();
}

注解实现查询全部用户数据

  • UserMapper接口

    //查询全部用户
@Select("select id,username,sex,birthday,address from user")
List<User> queryUserByList();

  • UserMapper测试

    /**
 * 注解开发
 * 查询全部用户
 */
@Test
public void testQueryUserByList(){
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    List<User> userList = userMapper.queryUserByList();
    if (userList != null && userList.size() > 0){
        for (User user : userList){
            System.out.println(user);
        }
    }
    sqlSession.close();
}

动态SQL语句之where和if

  • UserMapper接口

    //多条件查询用户
@Select("<script>select id,username,sex,birthday,address from user" +
        "<where>" +
        "<if test = \"sex != null and sex != ''\">" +
        " and sex = #{sex}" +
        "</if>" +
        "<if test = \"username != null and username != ''\">" +
        " and username like #{username}" +
        "</if>" +
        "</where></script>")
List<User> queryUserByWhere(User user);

  • UserMapper测试

     /**
  * 注解开发
  * 多条件查询用户信息
  */
 @Test
public void testQueryUserByWhere(){
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    User user = new User();
    user.setSex("2");
    user.setUsername("%王%");
    List<User> userList = userMapper.queryUserByWhere(user);
    if(userList != null && userList.size() > 0){
        for(User user1 : userList){
            System.out.println(user1);
        }
    }
    sqlSession.close();
}

动态SQL语句之foreach

  • UserMapper接口

    @Select("<script>select id,username,sex,birthday,address from user" +
        "<foreach collection = \"list\" open = \"where id in(\" close = \")\" separator = \",\" item = \"item\">" +
        "#{item}" +
        "</foreach>" +
        "</script>")
List<User> queryUserByListIds(List<Integer> ids);

  • UserMapper测试

    /**
  * 注解开发
  * 传入List集合，查询用户数据
  */
@Test
public void testQueryUserByListIds(){
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    List<Integer> ids = new ArrayList<Integer>();
    ids.add(1);
    ids.add(2);
    ids.add(3);
    List<User> userList = userMapper.queryUserByListIds(ids);
    if(userList != null && userList.size() > 0){
        for(User user : userList){
            System.out.println(user);
        }
    }
    sqlSession.close();
}

一对一的注解开发

@Results注解

配置手动映射，取代resultMap标签

@Result注解

配置手动映射，取代result标签

  • OrdersMapper接口

    //根据订单查询用户，一对一查询
@Select(" SELECT o.id,o.user_id,o.number,o.createtime,o.note FROM orders o")
@Results({
        //配置主键映射，id默认false,不是主键
        @Result(id = true,column = "id",property = "id"),
        //配置其他映射关系
        @Result(column = "user_id",property = "userId"),
        @Result(column = "number",property = "number"),
        @Result(column = "createtime",property = "createtime"),
        @Result(column = "note",property = "note"),
        /*
             配置关联查询用户表
             property查询的pojo对象哪个属性做为条件查询
               这个属性还是个pojo对象
             column查询条件的pojo对象的属性
             @One注解配置一对一的另一个查询语句
               此语句需要对应的接口方法出现
         */
        @Result(column = "user_id",property = "user",javaType = User.class,
                one = @One(select = "com.itheima.mapper.UserMapper.queryUserByUserId",fetchType = FetchType.LAZY))
})
List<Orders> queryOrdersUser();

  • UserMapper接口

    @Select("select id,username,sex,birthday,address from user where id=#{user_Id}")
User queryUserByUserId(Integer id);

  • OrdersMapp接口测试

    /**
 *  注解开发
 *  一对一延迟加载测试
 */
@Test
public void testQueryOrdersUser(){
    SqlSession sqlSession = sqlSessionFactory.openSession();
    OrdersMapper ordersMapper = sqlSession.getMapper(OrdersMapper.class);
    List<Orders> ordersList = ordersMapper.queryOrdersUser();
    if(ordersList != null && ordersList.size() > 0){
        for(Orders orders : ordersList){
            System.out.println(orders);
            System.out.println(orders.getUser());
        }
    }
    sqlSession.close();
}

一对多注解开发

  • UserMapper接口

    //用户查询订单，一对多
@Select("select id,username,sex,birthday,address from user")
@Results({
        @Result(id = true,column = "id",property = "id"),
        @Result(column = "username",property ="username" ),
        @Result(column = "sex",property ="sex" ),
        @Result(column = "birthday",property ="birthday" ),
        @Result(column = "address",property ="address" ),
        @Result(column = "id",property = "ordersList",javaType = List.class,
        many = @Many(select = "com.itheima.mapper.OrdersMapper.queryOrdersByUserId",fetchType = FetchType.LAZY))
})
List<User> queryUserOrders();

  • OrdersMapper接口

    //用户查询订单，一对多
@Select("select number,createtime from orders where user_id = #{user_id}" )
List<Orders> queryOrdersByUserId(Integer user_id);

  • UserMapper接口测试

    /**
  * 注解开发
  * 查询用户下的订单，一对多
  */
@Test
public void testQueryUserOrders(){
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    List<User> userList = userMapper.queryUserOrders();
    if(userList != null && userList.size() > 0){
        for(User user : userList){
            System.out.println(user);
            System.out.println(user.getOrdersList());
        }
    }
    sqlSession.close();
}

[扩展]逆向工程小工具

帮我们生成pojo,mapper接口类和mapper的xml文件（dao层常用接口：根据id查询，根据条件查询，根据id更新删除等常用的接口方法）

  • 往往用它来生成pojo

  • 往往针对单表操作

  • UserMapper接口测试

    /**
  * 注解开发
  * 查询用户下的订单，一对多
  */
@Test
public void testQueryUserOrders(){
    SqlSession sqlSession = sqlSessionFactory.openSession();
    UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
    List<User> userList = userMapper.queryUserOrders();
    if(userList != null && userList.size() > 0){
        for(User user : userList){
            System.out.println(user);
            System.out.println(user.getOrdersList());
        }
    }
    sqlSession.close();
}

[扩展]逆向工程小工具

帮我们生成pojo,mapper接口类和mapper的xml文件（dao层常用接口：根据id查询，根据条件查询，根据id更新删除等常用的接口方法）

  • 往往用它来生成pojo
  • 往往针对单表操作
  • 如果数据库结构有变化，那么逆向出来的代码需要重新生成
侯舒怀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Mybatis延迟加载和缓存
07-22
Mybatis延迟加载和缓存
Mybatis框架学习17- Mybatis 注解开发
qq_41302594的博客
09-10 319
文章目录Mybatis 注解开发1. Mybatis 注解开发的环境搭建2. Mybatis 常用的基础注解说明3. Mybatis 使用注意事项 - 以查询为例4. Mybatis 注解开发进行 CRUD 操作4.1 使用 Mybatis 注解开发进行保存操作4.2 使用 Mybatis 注解开发进行更新操作4.3 使用 Mybatis 注解开发进行删除操作4.4 使用 Mybatis 注解开发...
Mybatis关于缓存机制及延迟加载等了解
qq_46084827的博客
11-05 508
延迟加载是开发过程中灵活获取对象的一种求值策略，该策略在定义目标对象时并不会立即计算实际对象值，而是在该对象后续被实际调用时才去求值。在计算机科学中，延迟加载对应一个专门术语：惰性求值，其维基百科定义如下。在编程语言理论中，惰性求值（Lazy Evaluation），又译为惰性计算、懒惰求值，也称为传需求调用（call-by-need），是计算机编程中的一个概念，目的是要最小化计算机要做的工作。
Mybatis的延迟加载问题
Lecheng_的博客
05-07 588
延迟加载问题 MyBatis针对关联表中的数据支持延迟加载。延迟加载其实就是将数据加载时机推迟，比如推迟嵌套查询的执行时机。 延迟加载可以实现先查询主表，按需实时做关联查询，返回关联表结果集，一定程度上提高了效率。 <settings> <!-- 启用延迟加载特性，不配置默认关闭该特性--> <setting name="lazyLoadingEnabled" value="true" /> <!-- 按需加载:
Mybatis延迟加载以及缓存机制
qq_43814760的博客
04-17 495
1.延迟加载的概述 延迟加载的使用：嵌套查询。 延迟加载又称懒加载、按需加载。作用是使用数据的时候才去做数据库的查询，从而降低系统的消耗。 当数据量过大时，不建议使用 2.延迟加载的实现 2.1 局部加载 1.导入依赖 <dependency> <groupId>cglib</groupId> <artifactId>cglib</artifactId> <version>3.1</...
Mybatis延迟加载和缓存深入讲解
08-26
主要给大家介绍了关于Mybatis延迟加载和缓存的相关资料，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
Mybatis延迟加载和缓存（基于XML配置）.zip
12-08
Mybatis延迟加载和缓存的相关配置和使用。案例中代码演示了使用步骤，包含详细注释）
MyBatis 延迟加载、一级缓存、二级缓存(详解)
08-29
下面小编就为大家带来一篇MyBatis 延迟加载、一级缓存、二级缓存(详解)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
mybatis3--延迟加载，缓存
02-25
mybatis3--延迟加载，缓存
Java后端--57--Mybatis6：Mybatis的多级缓存和懒加载
武天旭的博客
12-13 478
一、一级缓存 缓存：程序经常要调用的对象存在内存中，方便其使用时可以快速调用，不必去数据库或者其他持久化设备中查询，主要就是提高性能。 Mybatis一级缓存：一级缓存的作用域是SqlSession，同一个SqlSession中执行相同的SQL查询时（相同的SQL和参数），第一次会去查询数据库并写在缓存中，第二次会直接从缓存中取。一级缓存是基于PerpetualCache的HashMap本地缓存，另外，一级缓存是默认开启的。 失效策略：当执行两次SQL的查询中间发生了增删改的操作，即insert、updat
《Mybatis入门到精通》——4.延迟加载&缓存配置
娜娜米的博客
03-25 479
Day_05 延迟加载； 多表查询，持有另一个表的实体的集合，不取集合的时候就不回去查关联的那一张表； 需要在Config.xml、IDAO.xml分别配置； 缓存； （默认）一级缓存SQLSession（close/commit更新、删除会清空缓存）； 二级缓存SessionFactory，多个SQLSession共用，需要在Config.xml、IDAO.xml分别配置； 1. mybatis中的延迟加载 问题：在一对多中，当我们有一个用户，它有100个账户。 在查询用户的时候，要不
Mybatis的 延迟/立即 加载、缓存与注解开发
weixin_43945141的博客
02-13 153
Mybatis中的加载 问题：在一对多中，当我们有一个用户，它有100个账户。 在查询用户的时候，要不要把关联的账户查出来？ 在查询账户的时候，要不要把关联的用户查出来？ 在查询用户时，用户下的账户信息应该是，什么时候使用，什么时候查询的。 在查询账户时，账户的所属用户信息应该是随着账户查询时一起查询出来。 什么是延迟加载 在真正使用数据时才发起查询，不用的时候不查询。按需加载（懒加载） 什么是立...
mybatis 的 延迟加载 和 查询缓存
weixin_41653442的博客
08-19 193
延迟加载 1.1什么是延迟加载 延迟加载又叫懒加载，也叫按需加载。也就是说先加载主信息，在需要的时候，再去加载从信息。 在mybatis中，resultMap标签 的association标签和collection标签具有延迟加载的功能。 1.2需求 查询订单信息，关联查询用户信息 1、创建一个statement来查询订单信息 2、创建一个statement来查询用户信息 1.3映...
MyBatis 缓存概念及延迟加载
雁迟的博客
03-25 85
一、MyBatis缓存 1.1 概念 在客户进行查询操作时，往往可能对重复的查询执行很多次，mybatis提供了默认的缓存机制一级缓存、二级缓存其中一级缓存默认开启，二级缓存需要进行配置才能进行使用,将查询的结果放置至对应的缓存，在用户重复查询时可以直接获取上一次的结果（在没有进行修改的情况下） 1.2 一级缓存 在mybatis核心配置文件中设置相应的配置开启缓存默认会直接开启一级缓存,将查询的数据缓存至当前的sqlsession会话中，当对同一sql语句进行多次查询时，除第一次进行查询外，其余直接获取当
mybatis的延迟加载及不生效原因
qq_33732195的博客
11-09 2124
延迟加载的配置 fetchType=“lazy” <!-- userMapper.xml --> <resultMap id="userRoleMapSelect" extends="userMap" type= "ser" > <association property="role" fetchType="lazy" column="id" select="tk.mybatis.simple.mapper.RoleMapper.selectRoleByid" /&gt
Mybatis中的延迟加载和缓存
qq_40867650的博客
05-20 262
往期内容，如下 一、MyBatis简介 二、MyBatis环境搭建 三、MyBatis入门案例 四、MyBatis自定义 五、MyBatis CRUD操作 六、Mybatis中参数和返回值的深入了解 七、MyBatis 配置文件标签 八、MyBatis POOLED连接池深入了解 九、MyBatis中的动态sql语句 十、MyBatis多表查询操作 延迟加载和立即加载 延迟加载： 在真正使用数据时才发起查询，不用的时候不查询。按需加载，即使懒加载 立即加载： 不管用不用，只要一调用方法，马上发起查.
MyBatis插入相关问题（insert、InsertSelective）
技术探求
03-26 2499
本文转载于：简书《MyBatis插入相关问题（insert、InsertSelective）》 自动生成代码insert和insertSelective的区别 自动生成的mybatis对应配置文件里面，有两个方法，分别为insert和insertSelective。这两个方法均是插入对象的方法。这里说一下两者的区别。 首先看一下两者代码： insert <insert id="inser...
mybatis的三级缓存机制
最新发布
03-28
其中，cacheEnabled表示是否开启缓存，localCacheScope表示一级缓存的作用域，lazyLoadingEnabled表示是否启用延迟加载。 需要注意的是，开启二级缓存时，需要在Mapper.xml文件中添加如下配置： ``` ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值