Redis缓存 自定义注解+aspect+反射技术实现
最近有时间又折腾了一下,之前只能将结果用对象序列化的方式放入redis中,现在改为json字符串,并通过反射拿到原来类型 ,
并且在今天有重构了一下代码,自定义注解中的所有属性都已实现
主要修改了之前使用redisUtil使用jdk对象序列化的方式来缓存,现在改为StringRedistemplate 的方式,细节大家就看下面的
代码吧,祝你们生活愉快哦
最近再给云随笔后台增加redis模块,突然发现spring-boot-starter-data-redis模块很不人性化,实现不了通用的方式,(当然,你也可以自己写个通用的CacheUtil来实现通用的方式),但由于本人非常的爱装逼,就在这里不讲解那种傻瓜式操作了,这里只讲干货,干到你不可置信的干货).
例如:这里我使用了它其中的RedisTemplate ,发现存到redis中后,数据是乱码,看了底层才知道,它里面的序列化机制是jdk,为了修改它其中的序列化机制,就自定义redisTempate.
@Configuration
public class MyRedisConfig {
/**
自定义redistemplate
*/
@Bean
public RedisTemplate<Object, SysUser> userRedisTemplate(RedisConnectionFactory redisConnectionFactory)
throws UnknownHostException {
RedisTemplate<Object, SysUser> template = new RedisTemplate<Object, SysUser>();
template.setConnectionFactory(redisConnectionFactory);
Jackson2JsonRedisSerializer<SysUser> ser = new Jackson2JsonRedisSerializer<SysUser>(SysUser.class);
template.setDefaultSerializer(ser);
return template;
}
// CacheManagerCustomizers可以来定制缓存的一些规则
@Primary // 将某个缓存管理器作为默认的
@Bean
public RedisCacheManager userCacheManager(RedisTemplate<Object, SysUser> userRedisTemplate) {
RedisCacheManager cacheManager = new RedisCacheManager(userRedisTemplate);
// key多了一个前缀
// 使用前缀，默认会将CacheName作为key的前缀
cacheManager.setUsePrefix(true);
return cacheManager;
}
}
此时,又发现了个问题,RedisTemplate的泛型第二个参数竟然不能是object,key,value能放进去却拿不出了,String 转换不了实际类型.
此时我决定用aspectJ+注解+反射的方式来实现通用缓存模块(用的StringRedisTamplate,这样就可以实现通用)
1 .创建自定义注解
package com.orhonit.yunsuibi.common.annotation;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import java.util.concurrent.TimeUnit;
/**
* 自定义注解,对于查询使用缓存的方法加入该注解
*
* @author Chenth
*/
@Retention(RetentionPolicy.RUNTIME)
@Target({ ElementType.METHOD })
public @interface Cacheable {
String name() default ""; //存储前缀
String key() default ""; //要存储的key,默认是查询条件的第一个参数
int expireTime() default 30;//默认30分钟
TimeUnit unit() default TimeUnit.MINUTES; //默认值是以分钟为单位
}
2. 创建aspect类 (在这里要多最一句:切面=切入点+通知/增强)
开始写aspect中的切入点和通知
package com.yunsuibi.common.aop;
import com.alibaba.fastjson.JSONObject;
import com.yunsuibi.common.annotation.Cacheable;
import org.apache.commons.lang.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.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import java.lang.reflect.Method;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.List;
import java.util.concurrent.TimeUnit;
/**
* ClassName RedisAop
* Package com.yunsuibi.common.aop
* Description aop缓存
*
* @author cyf
* @date 2019/4/28 15:41
*/
@Component
@Aspect
public class CacheableAop {
@Autowired
private StringRedisTemplate redisTemplate;
//切入点:方法上带有@Cacheable注解的方法
@Pointcut(value = "@annotation(com.yunsuibi.common.annotation.Cacheable)")
public void pointCut() {
}
//这里通知选用环绕通知,由于首先要判断缓存中是否存在,存在则返回,不存在则放过查询数据库,查询完数据库就要放入缓存中,所以其他四种都不合适
@Around(value = "pointCut()")
public Object cache(ProceedingJoinPoint joinPoint) throws Throwable {
Method method = getMethod(joinPoint);
Cacheable cacheable = method.getAnnotation(Cacheable.class);
String key = cacheable.key();
Object[] args = joinPoint.getArgs();
String prefix = cacheable.name();
String methodName = method.getName();
String cacheKey = getCacheableKey(key, prefix, args,methodName);
Object proceed = null;
String value = getValueInCacheByKey(cacheKey);
if (StringUtils.isNotBlank(value)) {
return getValueActualTypeData(method, value);
} else {
proceed = joinPoint.proceed();
// 查询到的数据库数据保存到redis
String results = JSONObject.toJSONString(proceed);
long expireTime = cacheable.expireTime();
TimeUnit unit = cacheable.unit();
setValueInCache(cacheKey, results, expireTime, unit);
return proceed;
}
}
private void setValueInCache(String cacheKey, String results, long expireTime, TimeUnit timeUnit) {
redisTemplate.opsForValue().set(cacheKey, results, expireTime, timeUnit);
}
private String getValueInCacheByKey(String cacheKey) {
return redisTemplate.opsForValue().get(cacheKey);
}
private Object getValueActualTypeData(Method method, String value) throws ClassNotFoundException {
Class returnActualType = getReturnActualType(method);
if (null != returnActualType) {
return JSONObject.parseArray(value, returnActualType);
}
return null;
}
private Method getMethod(ProceedingJoinPoint joinPoint) {
MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();
return methodSignature.getMethod();
}
private Class getReturnActualType(Method method) throws ClassNotFoundException {
Type genericReturnType = method.getGenericReturnType();
if (genericReturnType instanceof ParameterizedType) {
Type[] actualTypes = ((ParameterizedType) genericReturnType).getActualTypeArguments();
for (Type actualType : actualTypes) {
return Class.forName(actualType.getTypeName());
}
}
return null;
}
/**
* 获取要缓存的key 默认值为查询条件的第一个参数 可以通过key属性指定key
*
* @param key 存储的key
* @param prefix 存储前缀
* @param args 方法入参参数
* @param methodName 方法名称,当方法没有入参时且没有指定key默认使用方法名称作为key
* @return
*/
public String getCacheableKey(String key, String prefix, Object[] args,String methodName) {
String cacheKey = "";
if (StringUtils.isNotBlank(prefix)) {
cacheKey = "/" + prefix + "/";
}
if (StringUtils.isNotBlank(key)) {
return cacheKey += key;
}
if (null != args && 0 < args.length) {
return cacheKey += args[0];
}
return methodName;//方法名称
}
}
此时此刻,我就要恭喜你了,你将又成为一个大牛! 只需要在你要缓存的方法上加上@Cacheable就可以实现自定义注解实现通用缓存 -.-
/**
* 通过账号查找用户信息
* @param usercode
* @return
*/
@Cacheable()
public SysUser selectUserByUserCode(String usercode) {
return userMapper.selectUserByUserCode(usercode);
}
好了 ,到此为止,本节内容讲解完毕.讲的不好还请谅解,等云随笔后台管理完事后,云随笔前后台,以及代码开源共享!