redis缓存切面实现(支持缓存key的spel表达式)
1.定义注解
package com.g2.order.server.annotation; import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target; /**
* redis缓存注解
* 仅支持方法
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RedisCachetAttribute {
/**
* @return 缓存的key值
* 对应的Method的返回值必须 实现 Serializable 接口
*
*/
String key(); /**
* 到期秒数
*
* @return 到期秒数
*/
int expireSeconds() default 20;
}
2.定义切面
package com.g2.order.server.aspect; import com.g2.order.server.annotation.RedisCachetAttribute;
import com.g2.order.server.utils.ObjectUtils; import org.aspectj.lang.JoinPoint;
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.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.core.DefaultParameterNameDiscoverer;
import org.springframework.core.ParameterNameDiscoverer;
import org.springframework.core.annotation.Order;
import org.springframework.expression.EvaluationContext;
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; import redis.clients.jedis.JedisCluster; //开启AspectJ 自动代理模式,如果不填proxyTargetClass=true,默认为false,
@EnableAspectJAutoProxy(proxyTargetClass = true)
@Component
@Order(-1)
@Aspect
public class RedisCacheAspect {
/**
* 日志
*/
private static Logger logger = LoggerFactory.getLogger(RedisCacheAspect.class); /**
* SPEL表达式解析器
*/
private static final ExpressionParser EXPRESSION_PARSER = new SpelExpressionParser(); /**
* 获取方法参数名称发现器
*/
private static final ParameterNameDiscoverer PARAMETER_NAME_DISCOVERER = new DefaultParameterNameDiscoverer(); /**
* Redis集群
*/
@Autowired
private JedisCluster jedisCluster; /**
* 切面切入点
*/
@Pointcut("@annotation(com.g2.order.server.annotation.RedisCachetAttribute)")
public void mergeDuplicationRequest() { } /**
* 环绕切面
*/
@Around("mergeDuplicationRequest()")
public Object handleControllerMethod(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
//获取controller对应的方法.
MethodSignature methodSignature = (MethodSignature) proceedingJoinPoint.getSignature();
//获取方法
Method method = methodSignature.getMethod(); //获取注解
RedisCachetAttribute annotation = method.getAnnotation(RedisCachetAttribute.class);
//获取缓存key的表达式,并根据上下文等数据计算表达式
String cacheKey = parseKey(annotation.key(), proceedingJoinPoint);
int seconds = annotation.expireSeconds();
//先尝试从redis里获取数据(字节)
byte[] redisKey = cacheKey.getBytes();
byte[] redisValue = jedisCluster.get(redisKey); if (redisValue != null && redisValue.length > 0) {
//redis有数据,直接返回
return ObjectUtils.toObject(redisValue);
} //redis没有数据,则调用原方法,获取结果值
Object result = proceedingJoinPoint.proceed();
//将返回值序列化为Byte[],保存到redis
redisValue = ObjectUtils.toByteArray(result);
jedisCluster.setex(redisKey, seconds, redisValue); return result;
} /**
* 计算spel表达式
*
* @param expression 表达式
* @param context 上下文
* @return String的缓存key
*/
private static String parseKey(String expression, JoinPoint context) {
//获取切入点的方法信息
MethodSignature methodSignature = (MethodSignature) context.getSignature();
Method method = methodSignature.getMethod(); // 获取传入参数值
Object[] args = context.getArgs();
if (args == null || args.length == 0) {
// 无参传入,直接计算表达式(无需参数上下文)
return EXPRESSION_PARSER.parseExpression(expression).getValue(String.class);
} // 获取参数名
String[] parameterNames = PARAMETER_NAME_DISCOVERER.getParameterNames(method);
if (parameterNames.length > args.length) {
//由于java不允许有匿名参数,所以如果参数名多于参数值,则必为非法
logger.error("参数值的长度少于参数名长度, 方法:{}, 参数名长度: {},参数值长度:{}", method, parameterNames.length, args.length);
throw new IllegalArgumentException("参数传入不足");
} // 将参数名与参数值放入参数上下文
EvaluationContext evaluationContext = new StandardEvaluationContext();
for (int i = 0; i < parameterNames.length; i++) {
evaluationContext.setVariable(parameterNames[i], args[i]);
} // 计算表达式(根据参数上下文)
return EXPRESSION_PARSER.parseExpression(expression).getValue(evaluationContext, String.class);
}
}
3.引用代码
package com.g2.order.server.business; import com.google.common.collect.ImmutableMap;
import com.g2.order.server.annotation.RedisCachetAttribute;
import com.g2.order.server.business.vo.JsonResult;
import org.springframework.stereotype.Component;
import java.util.Arrays;
import java.util.List;
import java.util.Map; /**
* SettingBusiness.
*/
@Component
public class SettingBusiness { @RedisCachetAttribute(key = "T(com.g2.order.server.vo.CommonConst)" +
".SETTING_JSON_KEY" +
" + #code"
, expireSeconds = 30
)
public JsonResult getSetting(String code) {
return new JsonResult("234");
} @RedisCachetAttribute(key = "T(com.g2.order.server.vo.CommonConst)" +
".SETTING_LIST_KEY" +
" + #code"
, expireSeconds = 30
)
public List<JsonResult> getSettingList(String code) {
return Arrays.<JsonResult>asList(new JsonResult("234"), new JsonResult("345"));
} @RedisCachetAttribute(key = "T(com.g2.order.server.vo.CommonConst)" +
".SETTING_MAP_KEY" +
" + #code"
, expireSeconds = 30
)
public Map<String, JsonResult> getSettingMap(String code) {
return ImmutableMap.of(code, new JsonResult("234"),"abc",new JsonResult("abc234"));
}
}
package com.g2.order.server.business.vo; import java.io.Serializable; import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor; /**
* Model
*/ @AllArgsConstructor
@NoArgsConstructor
@Data
public class JsonResult implements Serializable {
private Object data;
}
4.测试如下.(验证获取普通POJO,List,Map的返回结构)
package com.g2.order.server.controller; import com.g2.order.server.business.SettingBusiness;
import com.g2.order.server.business.vo.JsonResult;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.List;
import java.util.Map;
import io.swagger.annotations.Api; @Api(value = "H5Controller", description = "H5接口")
@RestController
@RequestMapping("/h5")
public class H5Controller {
private static Logger logger = LoggerFactory.getLogger(H5Controller.class); @Autowired
private SettingBusiness settingBusiness; @ResponseBody
//@MergeDuplicationRequestAttribute(redisLockKeyTemplate = "A:%s", redisLockKeyObjectFileds = {"code"})
@RequestMapping(value = "/{code}.jsonp", method = RequestMethod.GET)
public Object testJsonp1(@PathVariable("code") String code) {
// return JsonMapper.INSTANCE.toJsonP("callabc111", new JsonResult("234"));
JsonResult result = settingBusiness.getSetting(code);
logger.info("获取结果,参数:{},值:{}", code, result);
return result;
} @ResponseBody
//@MergeDuplicationRequestAttribute(redisLockKeyTemplate = "A:%s", redisLockKeyObjectFileds = {"code"})
@RequestMapping(value = "/{code}.LIST", method = RequestMethod.GET)
public Object testJsonp2(@PathVariable("code") String code) {
// return JsonMapper.INSTANCE.toJsonP("callabc111", new JsonResult("234"));
List<JsonResult> result = settingBusiness.getSettingList(code);
logger.info("获取结果,参数:{},值:{}", code, result);
return result;
} @ResponseBody
//@MergeDuplicationRequestAttribute(redisLockKeyTemplate = "A:%s", redisLockKeyObjectFileds = {"code"})
@RequestMapping(value = "/{code}.MAP", method = RequestMethod.GET)
public Object testJsonp3(@PathVariable("code") String code) {
// return JsonMapper.INSTANCE.toJsonP("callabc111", new JsonResult("234"));
Map<String,JsonResult> result = settingBusiness.getSettingMap(code);
logger.info("获取结果,参数:{},值:{}", code, result);
return result;
}
}
5.辅助代码
package com.g2.order.server.utils; import com.google.common.collect.Lists; import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors; /**
* Object帮助类
*/
public class ObjectUtils { /**
* 对象转Byte数组
*/
public static byte[] toByteArray(Object obj) throws IOException {
byte[] bytes = null;
try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos)) {
oos.writeObject(obj);
oos.flush();
bytes = bos.toByteArray();
}
return bytes;
} /**
* Byte数组转对象
*/
public static Object toObject(byte[] bytes) throws IOException, ClassNotFoundException {
Object obj = null;
try (ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bis)) { obj = ois.readObject();
}
return obj;
}
}
package com.g2.order.server.vo; /**
* CommonConst
*/
public class CommonConst { public static final String PREFIX = "g2:";
public static final String SETTING_PREFIX = PREFIX + "setting:";
/**
* JSON_KEY
*/
public static final String SETTING_JSON_KEY = SETTING_PREFIX + "json:"; /**
* LIST_KEY
*/
public static final String SETTING_LIST_KEY = SETTING_PREFIX + "list:"; /**
* MAP_KEY
*/
public static final String SETTING_MAP_KEY = SETTING_PREFIX + "map:";
}
6.备注
这只是一个实现上的demo,如果要用到生产,可能还需要做以下改进
1.切面代码里写死了JedisCluster,这里要修改成一个接口 来支持单机/哨兵/集群 等
2.不支持毫秒级的存储(因为jedisCluster不支持...)
3.当没有获取缓存值时,应当根据key来加分布式锁,否则容易造成同样的处理多次执行
redis缓存切面实现(支持缓存key的spel表达式)的更多相关文章
- 使用AOP 实现Redis缓存注解,支持SPEL
公司项目对Redis使用比较多,因为之前没有做AOP,所以缓存逻辑和业务逻辑交织在一起,维护比较艰难所以最近实现了针对于Redis的@Cacheable,把缓存的对象依照类别分别存放到redis的Ha ...
- Redis整合Spring结合使用缓存实例(三)
一.Redis介绍 什么是Redis? redis是一个key-value存储系统.和Memcached类似,它支持存储的value类型相对更多,包括string(字符串).list(链表).set( ...
- Redis整合Spring结合使用缓存实例
林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 摘要:本文介绍了如何在Spring中配置redis,并通过Spring中AOP的思想,将缓存的 ...
- Redis整合Spring结合使用缓存实例(转)
林炳文Evankaka原创作品.转载请注明出处http://blog.csdn.net/evankaka 摘要:本文介绍了如何在Spring中配置redis,并通过Spring中AOP的思想,将缓存的 ...
- Redis学习总结(3)——Redis整合Spring结合使用缓存实例
摘要:本文介绍了如何在Spring中配置redis,并通过Spring中AOP的思想,将缓存的方法切入到有需要进入缓存的类或方法前面. 一.Redis介绍 什么是Redis? redis是一个key- ...
- 使用Redis做MyBatis的二级缓存
使用Redis做MyBatis的二级缓存 通常为了减轻数据库的压力,我们会引入缓存.在Dao查询数据库之前,先去缓存中找是否有要找的数据,如果有则用缓存中的数据即可,就不用查询数据库了. 如果没有才去 ...
- 利用Azure Redis Cache构建百万量级缓存读写
Redis是一个非常流行的基于内存的,低延迟,高吞吐量的key/value数据存储,被广泛用于数据库缓存,session的管理,热数据高速访问,甚至作为数据库方式提高应用程序可扩展性,吞吐量,和实施处 ...
- SpringCache与redis集成,优雅的缓存解决方案
缓存可以说是加速服务响应速度的一种非常有效并且简单的方式.在缓存领域,有很多知名的框架,如EhCache .Guava.HazelCast等.Redis作为key-value型数据库,由于他的这一特性 ...
- redis结合自定义注解实现基于方法的注解缓存,及托底缓存的实现
本次分享如何使用redis结合自定义注解实现基于方法的注解缓存,及托底缓存的实现思路 现在的互联网公司大多数都是以Redis作为缓存,使用缓存的优点就不赘述了,写这篇文章的目的就是想帮助同学们如 ...
随机推荐
- css--图片整合(精灵图)
图片整合(精灵图) 精灵图的优点: 减少图片的字节 减少了网页的http请求,从而大大的提高了页面的性能 解决了网页设计师在图片命名上的困扰,只需对一张集合的图片上命名就可以了,不需要对每一个小元素进 ...
- 利用docker制作一个带有redis软件的镜像,供其他人使用
1. 宿主机在etc/apt/下创建一个haha的文件夹 2.宿主机将haha文件夹映射到容器的虚拟系统中etc/apt/ 3. 此时,可以在宿主机和容器虚拟机中同步创建和删除文件 4. 将宿主机中的 ...
- Centos添加硬盘分区
1. 查看硬盘信息 fdish -l 此处/dev/sdb为新添加硬盘 2. 格式化为ext4硬盘格式 mkfs.ext4 /dev/sdb 亦可使用其他格式 硬盘空间大于2T时,MBR分区无法识别更 ...
- 关于DNS
一.什么是DNS DNS 是域名系统 (Domain Name System) 的缩写,它是由解析器和域名服务器组成的.域名服务器是指保存有该网络中所有主机的域名和对应IP地址,并具有将域名转换为IP ...
- asp.net文件断点上传
HTML部分 <%@PageLanguage="C#"AutoEventWireup="true"CodeBehind="index.aspx. ...
- linux nginx+php源码安装
PHP安装 1)下载 wget http://cn2.php.net/distributions/php-5.6.30.tar.gz 2)解压 tar –xf php-5.6.30 3)进入目录 cd ...
- 学习日记4、datagrid多行删除
1.前台展现单选框datagrid代码 $('#List').datagrid({ url: '@Url.Action("GetList")', width: $(window). ...
- 用三目运算,与if判断 函数调用 达到相同判定作用
三目运算符: 操作数1 ? 操作数2 : 操作数3 (操作数1位bool类型,操作数2和操作数3为两个相同的任何类型) 返回结果:如果操作数1判定结果为真,则将操作数2作为返回结果如果操作 ...
- Python 测评工具
开源--Python测评工具 Github仓库 本次实验作业的测评工具仅使用Python语言编写. 程序思路是基于文本的快速匹配. 编译test.py运行 1.GUI界面 GUI界面使用了PyQt5完 ...
- Step2 - How to: Implement a Windows Communication Foundation Service Contract
This is the second of six tasks required to create a basic Windows Communication Foundation (WCF) se ...