持久层之 MyBatis: 第三篇 ：缓存 And 高级查询

最新推荐文章于 2024-03-19 20:36:01 发布
最新推荐文章于 2024-03-19 20:36:01 发布
阅读量3.9k 收藏 64
点赞数 13
文章标签： MyBatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42897427/article/details/89191524
版权

MyBatis入门到精通3

缓存机制

正如大多数持久层框架一样，MyBatis 同样提供了一级缓存和二级缓存的支持

  1. 一级缓存: 基于PerpetualCache 的 HashMap本地缓存，其存储作用域为 Session，当 Session flush 或 close 之后，该Session中的所有 Cache 就将清空。
  2. 二级缓存与一级缓存其机制相同，默认也是采用 PerpetualCache，HashMap存储，不同在于其存储作用域为 Mapper(Namespace)，并且可自定义存储源，如 Ehcache。
  3. 对于缓存数据更新机制，当某一个作用域(一级缓存Session/二级缓存Namespaces)的进行了 C/U/D 操作后，默认该作用域下所有 select 中的缓存将被clear。

Mybatis一级缓存测试

package com.spiritmark.test;

import menghan.domain.User;
import spiritmark.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

/**
 * @author gacl
 * 测试一级缓存
 */
public class TestOneLevelCache {
    
    /*
     * 一级缓存: 也就Session级的缓存(默认开启)
     */
    @Test
    public void testCache1() {
        SqlSession session = MyBatisUtil.getSqlSession();
        String statement = "me.gacl.mapping.userMapper.getUser";
        User user = session.selectOne(statement, 1);
        System.out.println(user);
        
        /*
         * 一级缓存默认就会被使用
         */
        user = session.selectOne(statement, 1);
        System.out.println(user);
        session.close();
        /*
         1. 必须是同一个Session,如果session对象已经close()过了就不可能用了 
         */
        session = MyBatisUtil.getSqlSession();
        user = session.selectOne(statement, 1);
        System.out.println(user);
        
        /*
         2. 查询条件是一样的
         */
        user = session.selectOne(statement, 2);
        System.out.println(user);
        
        /*
         3. 没有执行过session.clearCache()清理缓存
         */
        //session.clearCache(); 
        user = session.selectOne(statement, 2);
        System.out.println(user);
        
        /*
         4. 没有执行过增删改的操作(这些操作都会清理缓存)
         */
        session.update("me.gacl.mapping.userMapper.updateUser",
                new User(2, "user", 23));
        user = session.selectOne(statement, 2);
        System.out.println(user);
        
    }
}

Mybatis二级缓存测试

1、开启二级缓存，在userMapper.xml文件中添加如下配置

<mapper namespace="com.spiritmark.pojo.userMapper">
<!-- 开启二级缓存 -->
<cache/>

2、测试二级缓存

package com.spiritmark.test;

import spiritmark.gacl.domain.User;
import spiritmark.util.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.junit.Test;

/**
1. @author gacl
2. 测试二级缓存
*/
public class TestTwoLevelCache {
 
 /*
  * 测试二级缓存
  * 使用两个不同的SqlSession对象去执行相同查询条件的查询，第二次查询时不会再发送SQL语句，而是直接从缓存中取出数据
  */
 @Test
 public void testCache2() {
     String statement = "me.gacl.mapping.userMapper.getUser";
     SqlSessionFactory factory = MyBatisUtil.getSqlSessionFactory();
     //开启两个不同的SqlSession
     SqlSession session1 = factory.openSession();
     SqlSession session2 = factory.openSession();
     //使用二级缓存时，User类必须实现一个Serializable接口===> User implements Serializable
     User user = session1.selectOne(statement, 1);
     session1.commit();//不懂为啥，这个地方一定要提交事务之后二级缓存才会起作用
     System.out.println("user="+user);
     
     //由于使用的是两个不同的SqlSession对象，所以即使查询条件相同，一级缓存也不会开启使用
     user = session2.selectOne(statement, 1);
     //session2.commit();
     System.out.println("user2="+user);
 }
}

二级缓存补充说明

  1. 映射语句文件中的所有select语句将会被缓存。
  2. 映射语句文件中的所有insert，update和delete语句会刷新缓存。
  3. 缓存会使用Least Recently Used（LRU，最近最少使用的）算法来收回。
  4. 缓存会根据指定的时间间隔来刷新
  5. 缓存会存储1024个对象

cache标签常用属性：

<cache 
eviction="FIFO"  <!--回收策略为先进先出-->
flushInterval="60000" <!--自动刷新时间60s-->
size="512" <!--最多缓存512个引用对象-->
readOnly="true"/> <!--只读-->

高级查询

表关系说明

在这里插入图片描述

  • 创建表
CREATE TABLE tb_order (
id int(11) NOT NULL AUTO_INCREMENT,
user_id int(11) DEFAULT NULL,
order_number varchar(255) DEFAULT NULL,
create datetime DEFAULT NULL,
updated datetime DEFAULT NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;

对应的实体类

public class Order {
   private Integer id;
   private Long userId;
   private String orderNumber;
   private Date created;
   private Date updated;
}

需求说明：
在这里插入图片描述

一对一查询

方法一：核心思想扩展Order对象，来完成映射
新建OrderUser实体类继承Order：

public class OrderUser extends Order {
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private Integer sex;
    private Date birthday;
    private Date created;
    private Date updated;
}

OrderMapper接口：

public interface OrderMapper {
     OrderUser queryOrderUserByOrderNumber(@Param("number") String number);
}

配置OrderMapper：

<mapper namespace="com.lx.mybatis.dao.OrderMapper">
    <select id="queryOrderUserByOrderNumber" resultType="com.zpc.mybatis.pojo.OrderUser">
      select * from tb_order o left join tb_user u on o.user_id=u.id where o.order_number = #{number}
   </select>
</mapper>

测试：

@Test
public void queryOrderUserByOrderNumber() throws Exception {
    OrderUser orderUser = orderMapper.queryOrderUserByOrderNumber("201807010001");
    System.out.println(orderUser);
}

方法二：面向对象的思想，在Order对象中添加User对象
在Order对象中添加User属性：

public class Order {
    private Integer id;
    private Long userId;
    private String orderNumber;
    private Date created;
    private Date updated;
    private User user;
}

接口：

/**
 * 根据订单号查询订单用户的信息
 * @param number
 * @return
 */
 public Order queryOrderWithUserByOrderNumber(@Param("number") String number);

使用resultType不能完成自动映射，需要手动完成结果集映射resultMap：

<resultMap id="OrderUserResultMap" type="com.LX.mybatis.pojo.Order" autoMapping="true">
     <id column="id" property="id"/>
     <!--association:完成子对象的映射-->
     <!--property:子对象在父对象中的属性名-->
     <!--javaType:子对象的java类型-->
     <!--autoMapping:完成子对象的自动映射，若开启驼峰，则按驼峰匹配-->
     <association property="user" javaType="com.LX.mybatis.pojo.User" autoMapping="true">
         <id column="user_id" property="id"/>
     </association>
 </resultMap>

 <select id="queryOrderWithUserByOrderNumber" resultMap="OrderUserResultMap">
   select * from tb_order o left join tb_user u on o.user_id=u.id where o.order_number = #{number}
</select>

测试：

@Test
public void queryOrderWithUserByOrderNumber() throws Exception {
    Order order = orderMapper.queryOrderWithUserByOrderNumber("201807010001");
    System.out.println(order.getUser());
}

一对多查询

一对多查询：查询订单，查询出下单人信息并且查询出订单详情。
Order类：

public class Order {
   private Integer id;
   private Long userId;
   private String orderNumber;
   private Date created;
   private Date updated;
   private User user;
   private List<OrderDetail> detailList;
}

public class OrderDetail {
   private Integer id;
   private Integer orderId;
   private Double totalPrice;
   private Integer status;
}

接口：

/**
* 根据订单号查询订单用户的信息及订单详情
* @param number
* @return
*/
Order queryOrderWithUserAndDetailByOrderNumber(@Param("number") String number);

Mapper映射：

<resultMap id="OrderUserDetailResultMap" type="com.LX.mybatis.pojo.Order" autoMapping="true">
   <id column="id" property="id"/>
   <!--collection:定义子对象集合映射-->
   <!--association:完成子对象的映射-->
   <!--property:子对象在父对象中的属性名-->
   <!--javaType:子对象的java类型-->
   <!--autoMapping:完成子对象的自动映射，若开启驼峰，则按驼峰匹配-->
   <association property="user" javaType="com.zpc.mybatis.pojo.User" autoMapping="true">
       <id column="user_id" property="id"/>
   </association>
   <collection property="detailList" javaType="List" ofType="com.zpc.mybatis.pojo.OrderDetail" autoMapping="true">
       <id column="id" property="id"/>
   </collection>
</resultMap>

<select id="queryOrderWithUserAndDetailByOrderNumber" resultMap="OrderUserDetailResultMap">
  select * from tb_order o
  left join tb_user u on o.user_id=u.id
  left join tb_orderdetail od on o.id=od.order_id
  where o.order_number = #{number}
</select>

测试：

@Test
public void queryOrderWithUserAndDetailByOrderNumber() throws Exception {
   Order order = orderMapper.queryOrderWithUserAndDetailByOrderNumber("201807010001");
   System.out.println(order.getUser());
   System.out.println(order.getDetailList());
}

多对多查询

多对多查询：查询订单，查询出下单人信息并且查询出订单详情中的商品数据。
OrderDetail类

public class OrderDetail {
   private Integer id;
   private Integer orderId;
   private Double totalPrice;
   private Integer status;
   private Item item;
}

public class Item {
   private Integer id;
   private String itemName;
   private Float itemPrice;
   private String itemDetail;
}

接口：

/**
 * 根据订单号查询订单用户的信息及订单详情及订单详情对应的商品信息
 * @param number
 * @return
 */
Order queryOrderWithUserAndDetailItemByOrderNumber(@Param("number") String number);

Mapper配置：

<resultMap id="OrderUserDetailItemResultMap" type="com.LX.mybatis.pojo.Order" autoMapping="true">
    <id column="id" property="id"/>
    <association property="user" javaType="com.LX.mybatis.pojo.User" autoMapping="true">
        <id column="user_id" property="id"/>
    </association>
    <collection property="detailList" javaType="List" ofType="com.zpc.mybatis.pojo.OrderDetail" autoMapping="true">
        <id column="detail_id" property="id"/>
        <association property="item" javaType="com.zpc.mybatis.pojo.Item" autoMapping="true">
            <id column="item_id" property="id"/>
        </association>
    </collection>
</resultMap>

 <select id="queryOrderWithUserAndDetailItemByOrderNumber" resultMap="OrderUserDetailItemResultMap">
   select * ,od.id as detail_id from tb_order o
   left join tb_user u on o.user_id=u.id
   left join tb_orderdetail od on o.id=od.order_id
   left join tb_item i on od.item_id=i.id
   where o.order_number = #{number}
</select>

测试：

@Test
public void queryOrderWithUserAndDetailItemByOrderNumber() throws Exception {
    Order order = orderMapper.queryOrderWithUserAndDetailItemByOrderNumber("201807010001");
    System.out.println(order);
    System.out.println(order.getUser());
    System.out.println(order.getDetailList());
}

SQL语句如下 :

CREATE TABLE tb_order (
id int(11) NOT NULL AUTO_INCREMENT,
user_id int(11) DEFAULT NULL,
order_number varchar(255) DEFAULT NULL,
create datetime DEFAULT NULL,
updated datetime DEFAULT NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB AUTO_INCREMENT=2 DEFAULT CHARSET=utf8;
INSERT INTO tb_order VALUES (‘1’, ‘2’, ‘201807010001’, ‘2018-07-01 19:38:35’, ‘2018-07-01 19:38:40’);

CREATE TABLE tb_item (
id int(11) NOT NULL,
itemName varchar(255) DEFAULT NULL,
itemPrice decimal(10,2) DEFAULT NULL,
itemDetail varchar(255) DEFAULT NULL,
PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
INSERT INTO tb_item VALUES (‘1’, ‘袜子’, ‘29.90’, ‘香香的袜子’);
INSERT INTO tb_item VALUES (‘2’, ‘套子’, ‘99.99’, ‘冈本001’);

CREATE TABLE tb_orderdetail (
id int(11) NOT NULL AUTO_INCREMENT,
order_id int(11) DEFAULT NULL,
total_price decimal(10,0) DEFAULT NULL,
item_id int(11) DEFAULT NULL,
status int(10) unsigned zerofill DEFAULT NULL COMMENT ‘0成功非0失败’,
PRIMARY KEY (id)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
INSERT INTO tb_orderdetail VALUES (‘1’, ‘1’, ‘10000’, ‘1’, ‘0000000001’);
INSERT INTO tb_orderdetail VALUES (‘2’, ‘1’, ‘2000’, ‘2’, ‘0000000000’);

路在自己脚下，没有人可以决定你前进的方向。 加油!

关注公众号 ,更多笔记，等你来拿，谢谢

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

刘架构
关注
MyBatis（4）Mybaits一对多查询
古道西风
07-23 2431
快上车快上车，来不及了！ 一 订单商品模型 订单关系模型如下 具体的内容请看上一篇MyBatis（3）Mybaits一对一查询 二 一对多关联查询 上一篇文章，我们实现了orders表一对一关联查询user表，这里我们实现一下orders表一对多关联查询orderdetail。（orderdetail表对应的外键orders_id是orders的主键id） 2.1需求 ...
Mybatis教程 | 第七篇：Mybatis的事务管理和缓存机制
好记性不如烂笔头
03-02 474
Mybatis的事务管理 1、事务的概念 在我们开发过程中，几乎每个业务逻辑都离不开对数据库的操作。那么对数据的的单个操作(单个CRUD)或者多个操作(多个CRUD)绑定在一起，就称为事务。 单个事务是一个最小的逻辑执行单元，整个事务不能分开执行，要么同时成功，要么同时失败。(PS:初次接触事务概念的朋友，也许会难以理解最小逻辑执行单元,反正当初我是误解了，误解的地方还真有点描述不出来，原谅...
myBatis持久层缓存
lapland的博客
03-28 1290
缓存的意义：将用户经常查询的数据当在缓存（内存）中，用户去查询数据就不用从磁盘（关系型数据库数据文件）查询，而是从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。 myBatis提供一级缓存和二级缓存：myBatis一级缓存是一个SqlSession级别，sqlsession只能访问自己的一级缓存的数据，二级缓存是跨sqlsession的，是mapper级别的缓存，对于mapper级别的
java框架SSM学习——持久层Mybatis之延迟加载和缓存
weixin_43877761的博客
06-08 234
延迟加载 举个例子来说吧：如果查询用户并且关联查询用户的账户信息。如果先查询用户信息就可以满足要求，当我们需要查询账户信息的时候再去查询账户信息。把用用户信息去查询账户信息的这一过程进行延迟处理，就被称为延迟加载。 延迟加载有什么好处呢？那我们都知道，单表查询的速度肯定是要比多表要快的，那么当我们只需要查询单表，但又有时候要联合多表查询，那么开启延迟加载就是最好的选择，既可以提升查询速度，当要使用到多表的时候就可以级联。在这我们用一个案例来讲解一下。 第一步：User表以及Account表 建表信息我就不给
Mybatis持久层框架 | 动态SQL、缓存
wei_shuo的博客
02-27 1590
Mybatis持久层框架 | 动态SQL、缓存
MyBatis（十三）mybatis的缓存
刘伟佳的博客
05-06 200
目录MyBatis的缓存一级缓存 MyBatis的缓存 像大多数的持久化框架一样，mybatis也提供了缓存策略，通过缓存策略来减少数据库的查询次数，从而提高性能。mybatis的缓存分为一级缓存和二级缓存： 一级缓存 一级缓存指的是mybatis中SqlSession对象的缓存。 当我们执行查询之后，查询的结果会同时存入到sqlSession为我们提供的一块区域中。 该区域的结构是一个Map，...
MyBatis:MyBatis演示
05-19
MyBatis是一款优秀的Java持久层框架，它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis可以使用简单的XML或注解进行配置和原始映射，将接口和Java的...
SSM持久层框架MyBatis，看这一篇就够了
m0_74674454的博客
03-23 1304
是一个基于Java的半自动的ORM（Object Relation Mapping）持久层框架iBatis提供的持久层框架包括SQL Maps和Data Access Objects（DAO支持存储过程以及高级映射不需要手动写jdbc代码、不需要手动设置参数和获取结果集使用简单的XML或注解用于配置和原始映射SQL 和 Java 编码分开，SQL语句专注于数据，java代码专注于业务逻辑封装了jdbc，简化操作为什么需要自定义映射？无疑，自动映射解决不了问题了,因为字段名和属性名不一致了。
一款优秀持久层框架Mybatis详解！
m0_67392931的博客
07-28 581
MyBatis是一款优秀的持久层框架.它支持定制化SQL、存储过程以及高级映射。MyBatis避免了几乎所有的JDBC代码和手动设置参数以及获取结果集。MyBatis可以使用简单的XML或注解来配置和映射原生类型、接口和JavaPOJO(PlainOldJavaObjects,普通老式Java对象)为数据库中的记录。如何获取MyBatis？Maven仓库httpshttps1.什么是缓存[Cache]存在内存中的临时数据。要在程序中使用ehcache,先要导包!...
第三方缓存整合mybatis.rar
06-24
在Java开发中，MyBatis是一个非常流行的持久层框架，它简化了数据库操作，通过XML或注解方式配置SQL和映射结果。然而，在大型应用中，为了提高系统的响应速度和减少数据库压力，通常会引入第三方缓存。本教程将讨论...
Mybatis全面详解——下（学习总结）
田坎上
04-19 3323
一、Mybatis关联查询映射这里采用一个案例来进行分析：(下面的案例都是采用Mapper接口编程的方式来实现)数据库准备：在数据库中创建一个Mybatis数据库，并在中创建user（用户）、orders（订单）、orderdetail（订单详情）、items（商品）表。各表的设计：user表：orders表：orderdetail表：items表：表与表的关系：user/orders表：user...
mybatis 乘法_MyBatis迷信者，清醒点！
weixin_39827625的博客
01-23 1893
点击关注上方“Java技术江湖”，设为“置顶或星标”，第一时间送达技术干货。导读不要以为MyBatis更方便，如果只是用一些简单1+1=2，MyBatis会很简单，但当业务实体之间存在复杂的关联、继承关系时，MyBatis的结果集映射会就比较繁琐了。技术潮流往往一波一波的：初中级开发者往往被裹夹其中，随波逐流，但这些人往往嗓门最大。十多年前，Hibernate如火如荼时，初中级开发者高呼...
Mybatis 最全教程（一篇从入门到精通）
lucky_fd的博客
06-09 6605
创建Mybatis的核心配置文件创建mapper接口对象创建mapper接口映射文件（mapper接口的全类名和映射文件的namespace一致、mapper接口中的方法的方法名要和映射文件中的sql的id保持一致）创建测试方法/*** SSM*/@Override'}';一个resultMap标签，就是对应着一个实体类。
MyBatis全方位指南：从入门到精通
最新发布
silenceallat的博客
03-19 930
本本文深入介绍了MyBatis这一Java持久层框架的核心概念和使用技巧。从映射文件、动态SQL到结果映射，讲解了如何简化数据库操作并提高代码的可读性和可维护性。接着，文章展示了如何通过自定义插件和类型处理器扩展My文深入探讨了Spring MVC的三个核心组件：控制器、视图解析器和拦截器。控制器负责处理用户请求，视图解析器负责渲染视图，拦截器则提供了请求处理的前后逻辑扩展点。通过这些组件的协同工作，可以高效地构建出灵活且强大的Web应用。文章还提供了实用的技巧和应用场景，帮助读者更好地理解和应用这些组件。
FK-精通Mybatis
qq_33274797的博客
09-01 437
1.Mybatis 1.什么是MyBatis？ MyBatis是一个半自动的持久层ORM映射框架，操作使用比较灵活多变，SQL语句需要手动编写。 2.为什么是半自动的ORM映射框架？ 因为MyBatis在做高级复杂查询时，需要手动编写SQL和ResultMap,进行数据库字段和实体字段的映射， 所以MyBatis是一个半自动的ORM映射框架。 3.什么是ORM? 对象关系映射(ORM Object Relational Mapping) 简单讲就是将数据库表字段与Java对象属性字段建立映射
mybatis-day01笔记
weixin_45185764的博客
09-16 429
1.Mybatis简介 1.1原始jdbc操作（查询数据） 1.2原始jdbc操作（插入数据） 1.3 原始jdbc操作的分析 原始jdbc开发存在的问题如下： ①数据库连接创建、释放频繁造成系统资源浪费从而影响系统性能 ②sql 语句在代码中硬编码，造成代码不易维护，实际应用 sql 变化的可能较大，sql 变动需要改变java代码。 ③查询操作时，需要手动将结果集中的数据手动封装到实体中。...
[Mybatis] 使用Mybatis实现分页
X工作室
09-25 244
????有幸相识 ,我是小相。有一个大厂梦，努力奔赴！加油陌生人！???? ☁️该文章是跟随B站狂神学习Mybatis时的笔记与心得，若与您有用，感谢点赞。文章不免有不足之处，请指出，我会及时改正！ 1.为什么要分页？ 减少数据量的处理量。 3. 如何分页 3.1 使用SQL limit select * from users limit 1,2; 下标从0开始。 第一个参数startIndex：返回查询结果下标从1开始，共两条记录结束。 第二个参数pageSize：查询的数量。 3.2 通过M
MyBatis入门到精通，最全最详细的MyBatis学习教程来了
DDDYSz的博客
11-12 4180
MyBatis 是一款优秀的持久层框架，它支持定制化 SQL、存储过程以及高级映射。MyBatis 避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。MyBatis 可以使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。 功能架构 我们把Mybatis的功能架构分为三层： (1) API接口层：提供给外部使用的接口API，开发人员通过这些本地API来操纵数据库。接
Mybatis的精通之路
海角12138的博客
12-02 228
1-----介绍： 2---mybatis内置生成实体和相关限制条件查询类： 3---
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

刘架构

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

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

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

打赏作者

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

抵扣说明：

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

余额充值