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

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

    1. @Intercepts({
    2.     @Signature(
    3.         type = Executor.class,
    4.         method = "query",
    5.         args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
    6.     @Signature(
    7.         type = Executor.class,
    8.         method = "query",
    9.         args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class, CacheKey.class, BoundSql.class})
    10. })
    11.  
    12. 第一个，表示不支持缓存的query。
    13.  
    14. 第二个，表示支持缓存的query。
    15.  
    16. a.某些数据变化不频繁，但查询非常频繁。缓存可以减少数据库查询次数，提高响应速度。
    17.  
    18. b.在分页查询中，缓存可以显著提高性能，尤其是当用户频繁浏览不同页面时。
    19.  
    20. c.对于复杂查询，生成的 SQL 可能涉及多个表的联接，执行时间较长。缓存可以显著减少这种查询的执行次数。

    具体区别

    1. 访问频率和实时性：

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

    2. 性能和资源使用：

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

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

    1. @Intercepts({
    2.     @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
    3. })
    4. public class CacheInterceptor implements Interceptor {
    5.  
    6.     @Override
    7.     public Object intercept(Invocation invocation) throws Throwable {
    8.         MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
    9.         String sqlId = mappedStatement.getId();
    10.  
    11.         // 假设我们有一个特定的SQL ID需要使用缓存
    12.         if ("com.example.mapper.UserMapper.selectUsers".equals(sqlId)) {
    13.             // 使用缓存逻辑
    14.             CacheKey cacheKey = ...; // 创建 CacheKey
    15.             BoundSql boundSql = ...; // 获取 BoundSql
    16.             // 执行带缓存的查询
    17.             return executor.query(mappedStatement, parameter, rowBounds, resultHandler, cacheKey, boundSql);
    18.         } else {
    19.             // 直接访问数据库
    20.             return invocation.proceed();
    21.         }
    22.     }
    23.  
    24.     @Override
    25.     public Object plugin(Object target) {
    26.         return Plugin.wrap(target, this);
    27.     }
    28.  
    29.     @Override
    30.     public void setProperties(Properties properties) {
    31.         // 可选：设置一些属性
    32.     }
    33. }

    2.通过注解或配置

    2.  
    3.  
    4.  
    5. @Intercepts({
    6.     @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
    7. })
    8. public class CacheInterceptor implements Interceptor {
    9.  
    10.     @Override
    11.     public Object intercept(Invocation invocation) throws Throwable {
    12.         MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
    13.         Object parameter = invocation.getArgs()[1];
    14.         RowBounds rowBounds = (RowBounds) invocation.getArgs()[2];
    15.         ResultHandler resultHandler = (ResultHandler) invocation.getArgs()[3];
    16.         Executor executor = (Executor) invocation.getTarget();
    17.  
    18.         // 读取自定义属性
    19.         Boolean useCache = (Boolean) mappedStatement.getConfiguration().getVariables().get("useCache");
    20.  
    21.         if (useCache != null && useCache) {
    22.             // 使用缓存逻辑
    23.             CacheKey cacheKey = executor.createCacheKey(mappedStatement, parameter, rowBounds, mappedStatement.getBoundSql(parameter));
    24.             BoundSql boundSql = mappedStatement.getBoundSql(parameter);
    25.             return executor.query(mappedStatement, parameter, rowBounds, resultHandler, cacheKey, boundSql);
    26.         } else {
    27.             // 直接访问数据库
    28.             return invocation.proceed();
    29.         }
    30.     }
    31.  
    32.     @Override
    33.     public Object plugin(Object target) {
    34.         return Plugin.wrap(target, this);
    35.     }
    36.  
    37.     @Override
    38.     public void setProperties(Properties properties) {
    39.         // 可选：设置一些属性
    40.     }
    41. }

    3.通过业务逻辑判断

    1. @Intercepts({
    2.     @Signature(type = Executor.class, method = "query", args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
    3. })
    4. public class CacheInterceptor implements Interceptor {
    5.  
    6.     @Override
    7.     public Object intercept(Invocation invocation) throws Throwable {
    8.         MappedStatement mappedStatement = (MappedStatement) invocation.getArgs()[0];
    9.         Object parameter = invocation.getArgs()[1];
    10.         RowBounds rowBounds = (RowBounds) invocation.getArgs()[2];
    11.         ResultHandler resultHandler = (ResultHandler) invocation.getArgs()[3];
    12.         Executor executor = (Executor) invocation.getTarget();
    13.  
    14.         // 根据业务逻辑判断
    15.         if (shouldUseCache(mappedStatement, parameter)) {
    16.             // 使用缓存逻辑
    17.             CacheKey cacheKey = executor.createCacheKey(mappedStatement, parameter, rowBounds, mappedStatement.getBoundSql(parameter));
    18.             BoundSql boundSql = mappedStatement.getBoundSql(parameter);
    19.             return executor.query(mappedStatement, parameter, rowBounds, resultHandler, cacheKey, boundSql);
    20.         } else {
    21.             // 直接访问数据库
    22.             return invocation.proceed();
    23.         }
    24.     }
    25.  
    26.     private boolean shouldUseCache(MappedStatement mappedStatement, Object parameter) {
    27.         // 根据业务逻辑判断是否使用缓存
    28.         // 示例：如果参数包含某个特定值，则使用缓存
    29.         if (parameter instanceof Map) {
    30.             Map paramMap = (Map) parameter;
    31.             return "useCache".equals(paramMap.get("cacheFlag"));
    32.         }
    33.         return false;
    34.     }
    35.  
    36.     @Override
    37.     public Object plugin(Object target) {
    38.         return Plugin.wrap(target, this);
    39.     }
    40.  
    41.     @Override
    42.     public void setProperties(Properties properties) {
    43.         // 可选：设置一些属性
    44.     }
    45. }

    两个query方法的区别：

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

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

    1. import org.apache.ibatis.annotations.Options;
    2. import org.apache.ibatis.annotations.Select;
    3.  
    4. public interface UserMapper {
    5.     
    6.     @Select("SELECT * FROM your_table WHERE your_conditions")
    7.     @Options(useCache = false)
    8.     List selectRealTimeData();
    9. }
    1. public abstract class BaseExecutor implements Executor {
    2.  
    3.     @Override
    4.     public  List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    5.         BoundSql boundSql = ms.getBoundSql(parameter);
    6.         CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    7.         return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
    8.     }
    9.  
    10.     @Override
    11.     public  List query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    12.         // 检查二级缓存
    13.         if (ms.isUseCache() && resultHandler == null) {
    14.             Cache cache = ms.getCache();
    15.             if (cache != null) {
    16.                 // 从二级缓存中获取结果
    17.                 @SuppressWarnings("unchecked")
    18.                 List list = (List) cache.getObject(key);
    19.                 if (list != null) {
    20.                     return list;
    21.                 }
    22.             }
    23.         }
    24.         // 如果缓存没有命中，执行数据库查询
    25.         List result = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    26.         // 将结果存入二级缓存
    27.         if (ms.isUseCache() && resultHandler == null && cache != null) {
    28.             cache.putObject(key, result);
    29.         }
    30.         return result;
    31.     }
    32.  
    33.     protected abstract  List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException;
    34. }

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

    1.全局配置

    2.     
    3.     
    4.         "cacheEnabled" value="true"/>
    5.

    2.映射文件配置

    1. "com.example.mapper.UserMapper">
    2.     
    3.     
    4.  
    5.     
    6.

    3.自定义缓存配置

    1. "com.example.mapper.UserMapper">
    2.     
    3.     
    4.         eviction="LRU"       
    5.         flushInterval="60000" 
    6.         size="512"           
    7.         readOnly="true"/>    
    8.  
    9.     
    10.

    4.使用注解配置

    1. import org.apache.ibatis.annotations.CacheNamespace;
    2. import org.apache.ibatis.annotations.Select;
    3. import org.apache.ibatis.cache.decorators.LruCache;
    4.  
    5. @CacheNamespace(
    6.     eviction = LruCache.class,   // 缓存回收策略
    7.     flushInterval = 60000,       // 刷新间隔，单位：毫秒
    8.     size = 512,                  // 缓存大小
    9.     readWrite = false            // 是否可读写
    10. )
    11. public interface UserMapper {
    12.     
    13.     @Select("SELECT * FROM users")
    14.     List selectUsers();
    15. }

    提取有效信息：

    1. private Object extractRouteParameterValue(Invocation invocation, Set routerPropertyNames) {
    2.  
    3.         Object routeValue = null;
    4.         try {
    5.             Object[] args = invocation.getArgs();
    6.             MappedStatement mappedStatement = (MappedStatement) args[0];
    7.             Object parameterObject = args[1];
    8.             BoundSql boundSql = mappedStatement.getBoundSql(parameterObject);
    9.             List parameterMappings = boundSql.getParameterMappings();
    10.             TypeHandlerRegistry typeHandlerRegistry = mappedStatement.getConfiguration().getTypeHandlerRegistry();
    11.             Configuration configuration = mappedStatement.getConfiguration();
    12.  
    13.             for (ParameterMapping parameterMapping : parameterMappings) {
    14.                 String rawPropertyName = parameterMapping.getProperty();
    15.                 String actualPropertyName = resolvePropertyName(rawPropertyName);
    16.  
    17.                 if (!routerPropertyNames.contains(actualPropertyName.toLowerCase())) {
    18.                     continue;
    19.                 }
    20.                 // copy from DefaultParameterHandler.setParameter方法
    21.                 //  ParameterMode.IN 输入， OUT、INOUT 是在存储过程中使用，暂时无视
    22.                 if (parameterMapping.getMode() != ParameterMode.OUT) {
    23.                     String propertyName = parameterMapping.getProperty();
    24.                     if (boundSql.hasAdditionalParameter(propertyName)) {
    25.                         routeValue = boundSql.getAdditionalParameter(propertyName);
    26.                     } else if (parameterObject == null) {
    27.                         routeValue = null;
    28.                     } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
    29.                         routeValue = parameterObject;
    30.                     } else {
    31.                         MetaObject metaObject = configuration.newMetaObject(parameterObject);
    32.                         routeValue = metaObject.getValue(propertyName);
    33.                     }
    34.                 }
    35.                 if (routeValue != null && hasText(routeValue.toString())) {
    36.                     return routeValue;
    37.                 }
    38.                 throw new DataSourceRoutingException(String.format("未检测到有效的数据库路由，请检测是否传入：(%s)", boundSql.getSql()));
    39.             }
    40.         } catch (DataSourceRoutingException dataSourceRoutingException) {
    41.             throw dataSourceRoutingException;
    42.         } catch (RuntimeException e) {
    43.             throw new DataSourceRoutingException(String.format("数据库路由解析异常, invocation method:{%s}, args:{%s}, routerPropertyNames:{%s}",
    44.                     invocation.getMethod().toGenericString(), Arrays.toString(invocation.getArgs()), routerPropertyNames), e);
    45.         }
    46.         return null;
    47.     }

  • 相关阅读:
    Redis解决优惠券秒杀
    ubuntu双系统安装以及启动时卡死解决办法
    网站小程序分类目录网源码系统+会员登录注册功能 带完整搭建教程
    5个实用的SQLite数据库可视化工具(GUI)
    如何用Excel软件制作最小二乘法①
    跟着我一起通关java面试吧（30）
    pcie reset系列之 内核框架
    CF1899B 250 Thousand Tons of TNT
    【毕业设计】基于单片机的智慧农业管理系统 -大棚管理系统 自动灌溉系统
    MindRecord-Windows下中文路径问题Unexpected error. Failed to open file
  • 原文地址：https://blog.csdn.net/sxtopc/article/details/140099500