Mybatis中支持缓存的query与不支持缓存的query

已于 2024-07-02 21:13:34 修改
阅读量300 收藏 6
点赞数 1
分类专栏： Java 文章标签： mybatis 缓存 java
于 2024-07-01 16:15:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sxtopc/article/details/140099500
版权

mybatis拦截器中，通常添加两个query的签名方法，如下：

@Intercepts({
    @Signature(
        type = Executor.class,
        method = "query",
        args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
    @Signature(
        type = Executor.class,
        method = "query",
        args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class})
})

第一个，表示不支持缓存的query。

第二个，表示支持缓存的query。

a.某些数据变化不频繁，但查询非常频繁。缓存可以减少数据库查询次数，提高响应速度。

b.在分页查询中，缓存可以显著提高性能，尤其是当用户频繁浏览不同页面时。

c.对于复杂查询，生成的 SQL 可能涉及多个表的联接，执行时间较长。缓存可以显著减少这种查询的执行次数。

具体区别

  1. 访问频率和实时性：

    • 不需要缓存：每次查询都直接访问数据库，适用于数据变化频繁或需要最新数据的场景。
    • 需要缓存：查询结果可以被缓存，适用于数据变化不频繁但查询频繁的场景。

  2. 性能和资源使用：

    • 不需要缓存：每次都访问数据库，可能会增加数据库负载。
    • 需要缓存：利用缓存减少数据库访问次数，显著提高性能和响应速度。

有哪些方法，可以判断是否应用缓存：
1.通过sql语句标识：

@Intercepts({
    @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
})
public class CacheInterceptor implements Interceptor {

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
        String sqlId = mappedStatement.getId();

        // 假设我们有一个特定的SQL ID需要使用缓存
        if ("com.example.mapper.UserMapper.selectUsers".equals(sqlId)) {
            // 使用缓存逻辑
            CacheKey cacheKey = ...; // 创建 CacheKey
            BoundSql boundSql = ...; // 获取 BoundSql
            // 执行带缓存的查询
            return executor.query(mappedStatement, parameter, rowBounds, resultHandler, cacheKey, boundSql);
        } else {
            // 直接访问数据库
            return invocation.proceed();
        }
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
        // 可选：设置一些属性
    }
}

2.通过注解或配置

<select id="selectUsers" resultType="User" useCache="true">
    SELECT * FROM users
</select>



@Intercepts({
    @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
})
public class CacheInterceptor implements Interceptor {

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
        Object parameter = invocation.getArgs()[1];
        RowBounds rowBounds = (RowBounds) invocation.getArgs()[2];
        ResultHandler resultHandler = (ResultHandler) invocation.getArgs()[3];
        Executor executor = (Executor) invocation.getTarget();

        // 读取自定义属性
        Boolean useCache = (Boolean) mappedStatement.getConfiguration().getVariables().get("useCache");

        if (useCache != null && useCache) {
            // 使用缓存逻辑
            CacheKey cacheKey = executor.createCacheKey(mappedStatement, parameter, rowBounds, mappedStatement.getBoundSql(parameter));
            BoundSql boundSql = mappedStatement.getBoundSql(parameter);
            return executor.query(mappedStatement, parameter, rowBounds, resultHandler, cacheKey, boundSql);
        } else {
            // 直接访问数据库
            return invocation.proceed();
        }
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
        // 可选：设置一些属性
    }
}

3.通过业务逻辑判断

@Intercepts({
    @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
})
public class CacheInterceptor implements Interceptor {

    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
        Object parameter = invocation.getArgs()[1];
        RowBounds rowBounds = (RowBounds) invocation.getArgs()[2];
        ResultHandler resultHandler = (ResultHandler) invocation.getArgs()[3];
        Executor executor = (Executor) invocation.getTarget();

        // 根据业务逻辑判断
        if (shouldUseCache(mappedStatement, parameter)) {
            // 使用缓存逻辑
            CacheKey cacheKey = executor.createCacheKey(mappedStatement, parameter, rowBounds, mappedStatement.getBoundSql(parameter));
            BoundSql boundSql = mappedStatement.getBoundSql(parameter);
            return executor.query(mappedStatement, parameter, rowBounds, resultHandler, cacheKey, boundSql);
        } else {
            // 直接访问数据库
            return invocation.proceed();
        }
    }

    private boolean shouldUseCache(MappedStatement mappedStatement, Object parameter) {
        // 根据业务逻辑判断是否使用缓存
        // 示例：如果参数包含某个特定值，则使用缓存
        if (parameter instanceof Map) {
            Map<String, Object> paramMap = (Map<String, Object>) parameter;
            return "useCache".equals(paramMap.get("cacheFlag"));
        }
        return false;
    }

    @Override
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

    @Override
    public void setProperties(Properties properties) {
        // 可选：设置一些属性
    }
}

两个query方法的区别：

其实，mapper文件中useCache参数会用来构建MappedStatement对象。即ms.isUseCache()被用来判断是否走缓存逻辑。

或者 通过@Options注解方式配置useCache参数：

import org.apache.ibatis.annotations.Options;
import org.apache.ibatis.annotations.Select;

public interface UserMapper {
    
    @Select("SELECT * FROM your_table WHERE your_conditions")
    @Options(useCache = false)
    List<YourResultType> selectRealTimeData();
}

public abstract class BaseExecutor implements Executor {

    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
        BoundSql boundSql = ms.getBoundSql(parameter);
        CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
        return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }

    @Override
    public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        // 检查二级缓存
        if (ms.isUseCache() && resultHandler == null) {
            Cache cache = ms.getCache();
            if (cache != null) {
                // 从二级缓存中获取结果
                @SuppressWarnings("unchecked")
                List<E> list = (List<E>) cache.getObject(key);
                if (list != null) {
                    return list;
                }
            }
        }
        // 如果缓存没有命中，执行数据库查询
        List<E> result = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
        // 将结果存入二级缓存
        if (ms.isUseCache() && resultHandler == null && cache != null) {
            cache.putObject(key, result);
        }
        return result;
    }

    protected abstract <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException;
}

其中，mybatis中，启用二级缓存的配置方式：

1.全局配置

<configuration>
    <!-- 其他配置 -->
    <settings>
        <setting name="cacheEnabled" value="true"/>
    </settings>
</configuration>

2.映射文件配置

<mapper namespace="com.example.mapper.UserMapper">
    <!-- 启用二级缓存 -->
    <cache/>

    <!-- 其他映射配置 -->
    <select id="selectUsers" resultType="User">
        SELECT * FROM users
    </select>
</mapper>

3.自定义缓存配置

<mapper namespace="com.example.mapper.UserMapper">
    <!-- 启用二级缓存，并设置自定义属性 -->
    <cache
        eviction="LRU"       <!-- 缓存回收策略：LRU（默认） -->
        flushInterval="60000" <!-- 刷新间隔，单位：毫秒 -->
        size="512"           <!-- 缓存大小 -->
        readOnly="true"/>    <!-- 只读缓存 -->

    <!-- 其他映射配置 -->
    <select id="selectUsers" resultType="User">
        SELECT * FROM users
    </select>
</mapper>

4.使用注解配置

import org.apache.ibatis.annotations.CacheNamespace;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.cache.decorators.LruCache;

@CacheNamespace(
    eviction = LruCache.class,   // 缓存回收策略
    flushInterval = 60000,       // 刷新间隔，单位：毫秒
    size = 512,                  // 缓存大小
    readWrite = false            // 是否可读写
)
public interface UserMapper {
    
    @Select("SELECT * FROM users")
    List<User> selectUsers();
}

提取有效信息：

private Object extractRouteParameterValue(Invocation invocation, Set<String> routerPropertyNames) {

        Object routeValue = null;
        try {
            Object[] args = invocation.getArgs();
            MappedStatement mappedStatement = (MappedStatement) args[0];
            Object parameterObject = args[1];
            BoundSql boundSql = mappedStatement.getBoundSql(parameterObject);
            List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();
            TypeHandlerRegistry typeHandlerRegistry = mappedStatement.getConfiguration().getTypeHandlerRegistry();
            Configuration configuration = mappedStatement.getConfiguration();

            for (ParameterMapping parameterMapping : parameterMappings) {
                String rawPropertyName = parameterMapping.getProperty();
                String actualPropertyName = resolvePropertyName(rawPropertyName);

                if (!routerPropertyNames.contains(actualPropertyName.toLowerCase())) {
                    continue;
                }
                // copy from DefaultParameterHandler.setParameter方法
                //  ParameterMode.IN 输入， OUT、INOUT 是在存储过程中使用，暂时无视
                if (parameterMapping.getMode() != ParameterMode.OUT) {
                    String propertyName = parameterMapping.getProperty();
                    if (boundSql.hasAdditionalParameter(propertyName)) {
                        routeValue = boundSql.getAdditionalParameter(propertyName);
                    } else if (parameterObject == null) {
                        routeValue = null;
                    } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
                        routeValue = parameterObject;
                    } else {
                        MetaObject metaObject = configuration.newMetaObject(parameterObject);
                        routeValue = metaObject.getValue(propertyName);
                    }
                }
                if (routeValue != null && hasText(routeValue.toString())) {
                    return routeValue;
                }
                throw new DataSourceRoutingException(String.format("未检测到有效的数据库路由，请检测是否传入：(%s)", boundSql.getSql()));
            }
        } catch (DataSourceRoutingException dataSourceRoutingException) {
            throw dataSourceRoutingException;
        } catch (RuntimeException e) {
            throw new DataSourceRoutingException(String.format("数据库路由解析异常, invocation method:{%s}, args:{%s}, routerPropertyNames:{%s}",
                    invocation.getMethod().toGenericString(), Arrays.toString(invocation.getArgs()), routerPropertyNames), e);
        }
        return null;
    }

Anpedestrian
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot 中 Mybatis 一级缓存使用与分析
For-的博客
09-04 2084
Mybatis 的一级缓存默认是开启不能关闭的，它的作用范围为SqlSession，即在同一个SqlSession中共享。在 SpringBoot 中需要添加注解才能生效。下面的代码展示一级缓存如何使用：先不添加}查看控制台是否会执行两次数据库查询（通过查看控制台打印 SQL 的次数得知是够查询两次）可以看到在没加注解的时候确实执行了两次数据库的查询，证明没有使用到缓存。加上再次执行查看结果}
mybatis缓存与mysql缓存_MyBatis|缓存机制
weixin_30453651的博客
02-01 499
1. MyBatis缓存1.1 缓存介绍就是将用户经常查询的数据的结果的一个保存，保存到一个内存中(缓存就是内存中的一个对象)，用户在查询的时候就不用到数据库文件中查询(磁盘)，从而减少与数据库的交付次数提高了响应速度，解决了并发系统的西能问题。1.2 MyBatis缓存分类MyBatis提供了一级缓存和二级缓存一级缓存：也称为本地缓存，用于保存用户在一次会话过程中查询的结果，用户一次会话中只能使...
SpringBoot整合Redis配置MyBatis二级缓存
热门推荐
微枫Micromaple的博客
10-01 1万+
本文讲的是在SpringBoot项目中整合使用 Redis，并使用 Redis实现MyBatis 的二级缓存。使用场景就是在高并发的环境下，大量的查询直接落入DB，会导致数据库宕机，从而导致服务雪崩的情况。我们使用Redis作为MyBatis二级缓存，可以充分的缓解数据库的压力，从而达到服务的高可用。
Mybatis二级缓存
kandroid的博客
05-19 2943
Mybatis二级缓存原理
Mybatis 一级缓存与Spring 事务管理联系
weixin_47215049的博客
07-10 363
spring整合mybatis，一级缓存失效
Mybatis二级缓存详解
共勉
11-17 3867
基于3.5.10版本的Mybatis源码，彻底搞清楚二级缓存是什么，是在哪里生效的，是怎么开启的，各自作用域是什么
mybatis 二级缓存失效_你不能不知道的Mybatis缓存机制
weixin_39722070的博客
12-21 1272
缓存的重要性是不言而喻的。使用缓存， 我们可以避免频繁的与数据库进行交互， 尤其是在查询越多、缓存命中率越高的情况下， 使用缓存对性能的提高更明显。同样地，mybatis作为ORM框架，也必然会支持缓存它分别支持一级缓存和二级缓存。其中一级缓存是sqlSession级的缓存，而二级缓存则可以实现多个sqlSession间的缓存什么意思？往下看喽~一级缓存01. 什么是一级缓存之所以说mybatis...
MyBatis中二级缓存的配置与实现原理
wyz_1945的博客
07-07 716
大家好，我是王有志。上一篇文章，我们学习了 MyBatis 的一级缓存，那么今天我们来学习 MyBatis 的二级缓存。
Mybatis缓存 自定义缓存
just_learing的博客
04-03 840
Mybatis缓存 自定义缓存
详解Java的MyBatis框架中的缓存与缓存的使用改进
09-02
然而，使用MyBatis缓存的过程中可能会遇到一些问题，尤其是在进行分页查询时。由于缓存的key通常是基于原始SQL和参数构建的，当使用自动生成的SQL插件或分页插件修改SQL语句时，原有的缓存key可能不再适用，导致无论...
MyBatis一二级缓存
08-30
在CachingExecutor的query方法中，MyBatis首先检查是否存在缓存，如果存在缓存，则从缓存中获取结果，如果不存在缓存，则执行查询操作，并将结果存储在缓存中。这样可以大大提高查询效率。 二级缓存是Mapper级别的...
Mybatis的缓存1
08-03
2. 并发问题：在多线程环境下，一级缓存不能保证数据的一致性，二级缓存则需要正确配置并发控制策略。 3. 数据一致性：二级缓存可能导致数据不一致，尤其是在多个SqlSession并发操作同一数据时。因此，对于实时性...
支持连表查询的mybatis-plus
04-21
MyBatis-Plus（简称MP）是MyBatis框架的一个扩展，它在MyBatis的基础上提供了许多便捷的功能，包括但不限于自动填充 CRUD 操作、条件构造器、动态 SQL 等。在描述中提到的“支持连表查询的mybatis-plus”，意味着MP...
Mybatis与Hibernate的区别
09-02
在数据库扩展性方面，Hibernate的数据库无关性更强，其HQL（Hibernate Query Language）允许开发者在不考虑具体数据库的情况下编写查询，而Mybatis的SQL编写则依赖于特定的数据库语法，这限制了其在不同数据库间的...
自制一个指定容量缓存，并实现最近使用的最后删除
ZHUSHANGLIN的博客
07-17 546
【代码】自制一个指定容量缓存，并实现最近使用的最后删除。
Caffeine缓存
最新发布
辰兮
07-17 298
示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。提示：这里对文章进行总结：例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。
ubuntu虚拟机安装ssh时报错 正在等待缓存锁
shiyq的技术小白博客
07-15 236
连接vm ubuntu虚拟机安装ssh时报错 正在等待缓存锁。
HTTP缓存/强缓存/协商缓存
qingdouxiaohua的博客
07-16 461
HTTP缓存是指当客户端（如浏览器）向服务器请求资源时，如果资源已经缓存在本地（如浏览器缓存或代理服务器缓存），则可以直接从缓存中获取资源，而无需再次从原始服务器下载。这样可以减少网络延迟和带宽消耗，提高页面加载速度。HTTP缓存的工作原理主要依赖于HTTP请求和响应报文头中的特定字段，这些字段用于控制缓存的策略和有效性。
mybatis关系映射和缓存机制
09-09
MyBatis关联映射是指通过MyBatis框架实现对象之间的关系映射，包括一对一、一对多、多对一和多对多等关系。关联映射可以通过配置文件和注解的方式来实现。 MyBatis缓存机制是指MyBatis框架自带的缓存功能，可以提高数据库查询的性能。MyBatis缓存可以分为一级缓存和二级缓存。一级缓存是指在同一个SqlSession中，对于相同的查询语句，MyBatis会将查询结果缓存起来，下次再执行相同的查询时，直接从缓存中获取结果，而不需要再次访问数据库。二级缓存是指在多个SqlSession中，对于相同的查询语句，MyBatis会将查询结果缓存起来，当其他SqlSession执行相同的查询时，可以直接从缓存中获取结果，而不需要再次访问数据库。 关于Spring JdbcTemplate类中几个常用方法的作用，我无法在提供的引用内容中找到明确的回答。但是一般来说，Spring JdbcTemplate类提供了一系列方法来执行数据库的增删改查操作。常用的方法包括：execute()方法用于执行SQL语句，query()方法用于执行查询操作并返回结果集，update()方法用于执行更新操作并返回受影响的行数，batchUpdate()方法用于执行批处理操作等。这些方法可以帮助开发人员简化数据库操作的代码，并提高开发效率。 但是，如果您对Spring JdbcTemplate类中具体方法的作用有进一步的疑问，我建议您参考《Java EE企业级应用开发教程 第2版（Spring Spring MVC MyBatis）》这本书，其中可能会有更详细的解释和示例。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值