springboot中使用自定义两级缓存的方法_springboot多级缓存redisCaffeine资源-CSDN文库资源-CSDN文库

82 浏览量 2020-08-27 11:19:35 上传评论收藏 110KB PDF 举报

Spring Boot 中使用自定义两级缓存的方法在 Spring Boot 应用程序中，缓存机制是非常重要的，它可以大大提高应用程序的性能和效率。缓存机制可以将经常访问的数据存储在内存中，以便快速地访问和检索数据。但是，Spring Boot 的默认缓存机制有一定的限制，例如无法实现两级缓存机制，即本地一级缓存和集中式的二级缓存。为了解决这个问题，需要实现自定义的两级缓存机制。需要定义两个注解，分别是 `@Cacheable` 和 `@CacheEvict`。这些注解与 Spring 中的缓存注解基本一致，只是去掉了一些不常用的属性。这些注解用于标注需要缓存的方法，并指定缓存的名称和键。 ```java @Target({ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) public @interface Cacheable { String value() default ""; String key() default ""; Class<?> type() default Exception.class; } @Target({ElementType.METHOD}) @Retention(RetentionPolicy.RUNTIME) public @interface CacheEvict { String value() default ""; String key() default ""; } ``` 接下来，需要实现一个注解处理类，用于拦截和处理缓存注解。这个类使用 AOP 的切面来进行拦截处理。 ```java import com.xuanwu.apaas.core.multicache.annotation.CacheEvict; import com.xuanwu.apaas.core.multicache.annotation.Cacheable; import com.xuanwu.apaas.core.utils.JsonUtil; import org.apache.commons.lang3.StringUtils; import org.aspectj.lang.ProceedingJoinPoint; import org.aspectj.lang.annotation.Around; import org.aspectj.lang.annotation.Aspect; import org.aspectj.lang.annotation.Pointcut; import org.aspectj.lang.reflect.MethodSignature; @Aspect public class CacheAspect { @Pointcut("@annotation(com.xuanwu.apaas.core.multicache.annotation.Cacheable)") public void cacheablePointcut() { } @Around("cacheablePointcut()") public Object cacheable(ProceedingJoinPoint joinPoint) throws Throwable { // 实现缓存逻辑 } @Pointcut("@annotation(com.xuanwu.apaas.core.multicache.annotation.CacheEvict)") public void cacheEvictPointcut() { } @Around("cacheEvictPointcut()") public Object cacheEvict(ProceedingJoinPoint joinPoint) throws Throwable { // 实现缓存删除逻辑 } } ``` 在这个注解处理类中，使用 AOP 的切面来拦截和处理缓存注解。`cacheablePointcut()` 方法用于标注需要缓存的方法，而 `cacheEvictPointcut()` 方法用于标注需要删除缓存的方法。`cacheable()` 方法和 `cacheEvict()` 方法用于实现缓存逻辑和缓存删除逻辑。在实现了这些注解和注解处理类后，就可以在 Spring Boot 应用程序中使用自定义的两级缓存机制了。这个机制可以将本地一级缓存和集中式的二级缓存结合起来，实现高效的缓存机制。需要注意的是，在 Spring Boot 中使用 Redis 缓存时，`@Cacheable` 和 `@CacheEvict` 注解的 `value` 属性实际上是摆设，键的唯一性只由 `key` 属性保证。这可能是 Spring 的缓存实现的 bug 或者是特意这么设计的。使用自定义的两级缓存机制可以大大提高 Spring Boot 应用程序的性能和效率。但是，需要注意的是，在实现这种机制时需要考虑到缓存的同步问题，以确保缓存数据的一致性。

资源推荐

资源详情

资源评论

springboot中使用自定义两级缓存的方法中使用自定义两级缓存的方法

主要介绍了springboot中使用自定义两级缓存的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参

考。一起跟随小编过来看看吧

工作中用到了springboot的缓存，使用起来挺方便的，直接引入redis或者ehcache这些缓存依赖包和相关缓存的starter依赖

包，然后在启动类中加入@EnableCaching注解，然后在需要的地方就可以使用@Cacheable和@CacheEvict使用和删除缓存

了。这个使用很简单，相信用过springboot缓存的都会玩，这里就不再多说了。美中不足的是，springboot使用了插件式的集

成方式，虽然用起来很方便，但是当你集成ehcache的时候就是用ehcache，集成redis的时候就是用redis。如果想两者一起

用，ehcache作为本地一级缓存，redis作为集成式的二级缓存，使用默认的方式据我所知是没法实现的(如果有高人可以实

现，麻烦指点下我)。毕竟很多服务需要多点部署，如果单独选择ehcache可以很好地实现本地缓存，但是如果在多机之间共

享缓存又需要比较费时的折腾，如果选用集中式的redis缓存，因为每次取数据都要走网络，总感觉性能不会太好。本话题主

要就是讨论如何在springboot的基础上，无缝集成ehcache和redis作为一二级缓存，并且实现缓存同步。

为了不要侵入springboot原本使用缓存的方式，这里自己定义了两个缓存相关的注解，如下

@Target({ElementType.METHOD})

@Retention(RetentionPolicy.RUNTIME)

public @interface Cacheable {

String value() default "";

String key() default "";

//泛型的Class类型

Class<?> type() default Exception.class;

}

@Target({ElementType.METHOD})

@Retention(RetentionPolicy.RUNTIME)

public @interface CacheEvict {

String value() default "";

String key() default "";

}

如上两个注解和spring中缓存的注解基本一致，只是去掉了一些不常用的属性。说到这里，不知道有没有朋友注意过，当你在

springboot中单独使用redis缓存的时候，Cacheable和CacheEvict注解的value属性，实际上在redis中变成了一个zset类型的

值的key，而且这个zset里面还是空的，比如@Cacheable(value="cache1",key="key1"),正常情况下redis中应该是出现cache1

-> map(key1,value1)这种形式，其中cache1作为缓存名称,map作为缓存的值，key作为map里的键，可以有效的隔离不同的

缓存名称下的缓存。但是实际上redis里确是cache1 -> 空(zset)和key1 -> value1,两个独立的键值对，试验得知不同的缓存名

称下的缓存完全是共用的，如果有感兴趣的朋友可以去试验下，也就是说这个value属性实际上是个摆设，键的唯一性只由key

属性保证。我只能认为这是spring的缓存实现的bug，或者是特意这么设计的，(如果有知道啥原因的欢迎指点)。

回到正题，有了注解还需要有个注解处理类，这里我使用aop的切面来进行拦截处理，原生的实现其实也大同小异。切面处理

类如下:

import com.xuanwu.apaas.core.multicache.annotation.CacheEvict;

import com.xuanwu.apaas.core.multicache.annotation.Cacheable;

import com.xuanwu.apaas.core.utils.JsonUtil;

import org.apache.commons.lang3.StringUtils;

import org.aspectj.lang.ProceedingJoinPoint;

import org.aspectj.lang.annotation.Around;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Pointcut;

import org.aspectj.lang.reflect.MethodSignature;

import org.json.JSONArray;

import org.json.JSONObject;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.core.LocalVariableTableParameterNameDiscoverer;

import org.springframework.expression.ExpressionParser;

import org.springframework.expression.spel.standard.SpelExpressionParser;

import org.springframework.expression.spel.support.StandardEvaluationContext;

import org.springframework.stereotype.Component;

import java.lang.reflect.Method;

/**

* 多级缓存切面

* @author rongdi

@Aspect

@Component

public class MultiCacheAspect {

private static final Logger logger = LoggerFactory.getLogger(MultiCacheAspect.class);

@Autowired

private CacheFactory cacheFactory;

//这里通过一个容器初始化监听器，根据外部配置的@EnableCaching注解控制缓存开关

private boolean cacheEnable;

@Pointcut("@annotation(com.xuanwu.apaas.core.multicache.annotation.Cacheable)")

public void cacheableAspect() {

}

@Pointcut("@annotation(com.xuanwu.apaas.core.multicache.annotation.CacheEvict)")

public void cacheEvict() {

}

@Around("cacheableAspect()")

public Object cache(ProceedingJoinPoint joinPoint) {

//得到被切面修饰的方法的参数列表

Object[] args = joinPoint.getArgs();

// result是方法的最终返回结果

Object result = null;

//如果没有开启缓存，直接调用处理方法返回

if(!cacheEnable){

try {

result = joinPoint.proceed(args);

} catch (Throwable e) {

logger.error("",e);

}

return result;

}

// 得到被代理方法的返回值类型

Class returnType = ((MethodSignature) joinPoint.getSignature()).getReturnType();

// 得到被代理的方法

Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();

// 得到被代理的方法上的注解

Cacheable ca = method.getAnnotation(Cacheable.class);

//获得经过el解析后的key值

String key = parseKey(ca.key(),method,args);

Class<?> elementClass = ca.type();

//从注解中获取缓存名称

String name = ca.value();

try {

//先从ehcache中取数据

String cacheValue = cacheFactory.ehGet(name,key);

if(StringUtils.isEmpty(cacheValue)) {

//如果ehcache中没数据，从redis中取数据

cacheValue = cacheFactory.redisGet(name,key);

if(StringUtils.isEmpty(cacheValue)) {

//如果redis中没有数据

// 调用业务方法得到结果

result = joinPoint.proceed(args);

//将结果序列化后放入redis

cacheFactory.redisPut(name,key,serialize(result));

} else {

//如果redis中可以取到数据

//将缓存中获取到的数据反序列化后返回

if(elementClass == Exception.class) {

result = deserialize(cacheValue, returnType);

} else {

result = deserialize(cacheValue, returnType,elementClass);

}

//将结果序列化后放入ehcache

cacheFactory.ehPut(name,key,serialize(result));

} else {

//将缓存中获取到的数据反序列化后返回

if(elementClass == Exception.class) {

result = deserialize(cacheValue, returnType);

} else {

result = deserialize(cacheValue, returnType,elementClass);

}

剩余8页未读，继续阅读

评论收藏

内容反馈

weixin_38738983

粉丝: 6

springboot中使用自定义两级缓存的方法

自定义注解实现缓存机制

springboot-cache

详解Guava Cache本地缓存在Spring Boot应用中的实践

Springboot项目启动时加载数据库数据到内存.rar

基于SpringBoot,更简洁的后台管理系统 Guns

petty-cache:Node.js的缓存模块，它使用两级缓存（内存缓存用于最近访问的数据，Redis用于分布式缓存），并具有一些额外的功能，可以避免缓存踩踏和群殴。 还包括互斥量和信号量分布式锁定原语

springboot-redis-mybatis:redis实现mybatis的二级缓存

基于spring 方法级缓存的多种实现

spring aop 自定义缓存实现

spring二级缓存

springboot+mybatis+ehcache实现缓存数据

SpringBoot2 整合Ehcache组件，轻量级缓存管理.docx

128元尚硅谷Java视频教程_Spring Boot视频教程（下）整合篇

springboot+vue 在线报表设计和大屏设计系统源码.zip

SpringBoot中使用Ehcache的详细教程

springboot整合redis

springboot实现消息转换、切面AOP和Redis缓存

在Spring Boot中实现HTTP缓存的方法

springboot1.x基于spring注解实现J2Cache两级缓存集成

spring boot+spring cache实现两级缓存(redis+caffeine)

SpringBoot项目+MybatisPlus使用+Redis缓存

spring-ehcache-redis两级缓存

springboot2.x整合redis做mybatis的二级缓存

Springboot中使用缓存的示例代码

springmvc开启二级缓存.

最基本的SpringBoot2.0,+Swagger-ui,以及redis作为缓存使用,CacheManage管理

SpringBoot企业级开发教程教学大纲.pdf

springboot整合redis、mybatis以及redis和mybatis的联合使用

bootstarap模板（狂神说springboot）

springboot-redis-demo

最新资源

petty-cache:Node.js的缓存模块，它使用两级缓存（内存缓存用于最近访问的数据，Redis用于分布式缓存），并具有一些额外的功能，可以避免缓存踩踏和群殴。还包括互斥量和信号量分布式锁定原语