Redis缓存 自定义注解+aspect+反射技术实现

2024-09-08 01:32
文章标签 实现 技术 自定义 redis 注解 缓存 反射 aspect

本文主要是介绍Redis缓存 自定义注解+aspect+反射技术实现，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

    最近再给云随笔后台增加redis模块,突然发现spring-boot-starter-data-redis模块很不人性化,实现不了通用的方式,(当然,你也可以自己写个通用的CacheUtil来实现通用的方式),但由于本人非常的爱装逼,就在这里不讲解那种傻瓜式操作了,这里只讲干货,干到你不可置信的干货).

例如:这里我使用了它其中的RedisTemplate ,发现存到redis中后,数据是乱码,看了底层才知道,它里面的序列化机制是jdk,为了修改它其中的序列化机制,就自定义redisTempate.
 

@Configuration
public class MyRedisConfig {/**自定义redistemplate*/@Beanpublic 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 // 将某个缓存管理器作为默认的@Beanpublic 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 .创建aspect类 (在这里要多最一句:切面=切入点+通知/增强)
 

package com.orhonit.yunsuibi.common.aop;import java.lang.reflect.Method;
import java.util.concurrent.TimeUnit;import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
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 com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.github.pagehelper.StringUtil;
import com.orhonit.yunsuibi.common.annotation.Cacheable;
import com.orhonit.yunsuibi.common.utils.CacheUtil;/*** 切面=通知+切入点* * @author cyf* @date 2018/11/30 上午10:16:01*/
@Component
@Aspect
public class CacheableAop {}

 2 .创建自定义注解

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;  //默认值是以分钟为单位}

 

3.开始写aspect中的切入点和通知

package com.orhonit.yunsuibi.common.aop;import java.lang.reflect.Method;
import java.util.concurrent.TimeUnit;import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
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 com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.github.pagehelper.StringUtil;
import com.orhonit.yunsuibi.common.annotation.Cacheable;
import com.orhonit.yunsuibi.common.utils.CacheUtil;/*** 切面=通知+切入点* * @author cyf* @date 2018/11/30 上午10:16:01*/
@Component
@Aspect
public class CacheableAop {//切入点:方法上带有@Cacheable注解的方法@Pointcut(value = "@annotation(com.orhonit.yunsuibi.common.annotation.Cacheable)")public void pointCut() {}//这里通知选用环绕通知,由于首先要判断缓存中是否存在,存在则返回,不存在则放过查询数据库,查询完数据库就要放入缓存中,所以其他四种都不合适@Around(value = "pointCut()")public Object cache(ProceedingJoinPoint joinPoint) throws Throwable {return null;}}

 

4.写一个RedisUitl,用于给aspect用

 

package com.orhonit.yunsuibi.common.utils;import java.io.UnsupportedEncodingException;
import java.lang.reflect.Method;
import java.util.concurrent.TimeUnit;import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.connection.DefaultStringRedisConnection;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;import com.alibaba.fastjson.JSON;
import com.orhonit.yunsuibi.common.annotation.Cacheable;import cn.hutool.core.io.IoUtil;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;/*** * ClassName    RedisUtil* Package	    com.orhonit.yunsuibi.common.utils* Description  缓存工具类,采用序列化对象的方式,之前是fastjson ,发现也是转换不了实际类型-,-** @author 		cyf* @date		2018/11/20 下午11:04:32*/
@Component
public class RedisUtil {JedisPool jedisPool = new JedisPool();/*** 获取缓存中的数据* * @param key* @return* @throws UnsupportedEncodingException*/public Object getCacheByKey(String key) {// 查询Jedis jedis = jedisPool.getResource();byte[] result = jedis.get(key.getBytes());// 如果查询没有为空if (null == result) {return null;}// 查询到了，反序列化return SerializeUtil.unSerialize(result);}/***  删除缓存中的数据* @param key*/public void delCacheByKey(String key) {Jedis jedis = jedisPool.getResource();jedis.del(key);}/*** 将数据保存到缓存中的数据* @param key* @return*/public boolean setCache(String key, Object obj, int expireTime, TimeUnit unit) {// 序列化byte[] bytes = SerializeUtil.serialize(obj);// 存入redisJedis jedis = jedisPool.getResource();String success = jedis.set(key.getBytes(), bytes);if ("OK".equals(success)) {System.out.println("数据成功保存到redis...");}return true;}}

 

4.此时此刻,万事俱备,只欠东风了 ,开始写主要逻辑

package com.orhonit.yunsuibi.common.aop;import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
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 com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.orhonit.yunsuibi.common.annotation.Cacheable;
import com.orhonit.yunsuibi.common.parser.DefaultResultParser;
import com.orhonit.yunsuibi.common.utils.CacheKeyUtil;
import com.orhonit.yunsuibi.common.utils.RedisUtil;import lombok.extern.slf4j.Slf4j;/*** 切面=通知+切入点* * @author cyf* @date 2018/11/30 上午10:16:01*/
@Component
@Aspect
@Slf4j
public class CacheableAop {@Autowiredprivate CacheKeyUtil keyUtil;@Autowiredprivate RedisUtil redisUtil ;private ConcurrentHashMap<String, DefaultResultParser> parserMap = new ConcurrentHashMap<String, DefaultResultParser>();@Pointcut(value = "@annotation(com.orhonit.yunsuibi.common.annotation.Cacheable)")public void getCache() {}@Around(value = "getCache()")public Object cache(ProceedingJoinPoint joinPoint) throws Throwable {log.debug("@Cacheable 注解:拦截开始");//获取方法签名MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();//通过反射得到方法Method method = methodSignature.getMethod();//获取注解Cacheable cacheable = method.getAnnotation(Cacheable.class);// 首先查询缓存,key默认使用第一个查询参数String cacheKey = keyUtil.getCacheableKey(joinPoint);Object proceed = null;Object result=null;if (StringUtils.isNotBlank(cacheKey)) {// 查询缓存Class returnType = method.getReturnType();Object value = redisUtil.getCacheByKey(cacheKey);if (null != value) {return result = value;}proceed = joinPoint.proceed();// 查询到的数据库数据保存到redislog.debug("@Cacheable 注解:redis数据保存成功");redisUtil.setCache(cacheKey, proceed, cacheable.expireTime(), cacheable.unit());}return proceed;}}

此时此刻,我就要恭喜你了,你将又成为一个大牛! 只需要在你要缓存的方法上加上@Cacheable就可以实现自定义注解实现通用缓存 -.-

/*** 通过账号查找用户信息* @param usercode * @return*/@Cacheable()public SysUser selectUserByUserCode(String usercode) {return userMapper.selectUserByUserCode(usercode);}

好了 ,到此为止,本节内容讲解完毕.讲的不好还请谅解,等云随笔后台管理完事后,云随笔前后台,以及代码开源共享!

云随笔:www.yunsuibi.com 欢迎大家来支持

不好意思 ,补充一个 ,发现少了一个序列化工具和获取缓存key的工具类

package com.orhonit.yunsuibi.common.utils;import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;/*** * ClassName    SerializeUtil* Package	    com.orhonit.yunsuibi.common.utils* Description  序列化反序列化工具** @author 		cyf* @date		2018/11/21 上午11:19:09*/
public class SerializeUtil {/*** * 序列化*/public static byte[] serialize(Object obj) {ObjectOutputStream oos = null;ByteArrayOutputStream baos = null;try {// 序列化baos = new ByteArrayOutputStream();oos = new ObjectOutputStream(baos);oos.writeObject(obj);byte[] byteArray = baos.toByteArray();return byteArray;} catch (IOException e) {e.printStackTrace();}return null;}/*** * 反序列化* * @param bytes* @return*/public static Object unSerialize(byte[] bytes) {ByteArrayInputStream bais = null;try {// 反序列化为对象bais = new ByteArrayInputStream(bytes);ObjectInputStream ois = new ObjectInputStream(bais);return ois.readObject();} catch (Exception e) {e.printStackTrace();}return null;}
}

package com.orhonit.yunsuibi.common.utils;import java.lang.reflect.Method;
import org.apache.commons.lang3.StringUtils;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.reflect.MethodSignature;
import org.springframework.stereotype.Component;
import com.orhonit.yunsuibi.common.annotation.Cacheable;
import com.orhonit.yunsuibi.common.annotation.CacheableDel;
/*** * ClassName    CacheKeyUtil* Package	    com.orhonit.yunsuibi.common.utils* Description  获取缓存keyUtil** @author 		cyf* @date		2018/12/21 上午11:22:32*/
@Component
public class CacheKeyUtil {/*** 获取要缓存的key 默认值为查询条件的第一个参数 可以通过key属性指定key* * @param joinPoint* @return*/public String getCacheableKey(ProceedingJoinPoint joinPoint) {MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();Method method = methodSignature.getMethod();Cacheable cacheable = method.getAnnotation(Cacheable.class);String key = cacheable.key();String catalog = cacheable.catalog();String cacheKey="";if(StringUtils.isNotBlank(catalog)) {cacheKey+=catalog+":";}if (StringUtils.isNotBlank(key)) {return cacheKey+=key;}Object[] args = joinPoint.getArgs();return cacheKey+=args[0];}/*** 获取要删除的key 默认值为查询条件的第一个参数 可以通过key属性指定key* * @param joinPoint* @return*/public String getCacheDelKey(ProceedingJoinPoint joinPoint) {MethodSignature methodSignature = (MethodSignature) joinPoint.getSignature();Method method = methodSignature.getMethod();CacheableDel cacheable = method.getAnnotation(CacheableDel.class);String key = cacheable.key();if (StringUtils.isNotBlank(key)) {return key;}Object[] args = joinPoint.getArgs();return (String) args[0];}
}

 

 

 

这篇关于Redis缓存 自定义注解+aspect+反射技术实现的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1146728。

相关文章

C++中unordered_set哈希集合的实现

C++中unordered_set哈希集合的实现

《C++中unordered_set哈希集合的实现》std::unordered_set是C++标准库中的无序关联容器,基于哈希表实现,具有元素唯一性和无序性特点,本文就来详细的介绍一下unorder... 目录一、概述二、头文件与命名空间三、常用方法与示例1. 构造与析构2. 迭代器与遍历3. 容量相关4
阅读更多...
C++中悬垂引用(Dangling Reference) 的实现

C++中悬垂引用(Dangling Reference) 的实现

《C++中悬垂引用(DanglingReference)的实现》C++中的悬垂引用指引用绑定的对象被销毁后引用仍存在的情况,会导致访问无效内存,下面就来详细的介绍一下产生的原因以及如何避免,感兴趣... 目录悬垂引用的产生原因1. 引用绑定到局部变量，变量超出作用域后销毁2. 引用绑定到动态分配的对象，对象
阅读更多...
SpringBoot基于注解实现数据库字段回填的完整方案

SpringBoot基于注解实现数据库字段回填的完整方案

《SpringBoot基于注解实现数据库字段回填的完整方案》这篇文章主要为大家详细介绍了SpringBoot如何基于注解实现数据库字段回填的相关方法,文中的示例代码讲解详细,感兴趣的小伙伴可以了解... 目录数据库表pom.XMLRelationFieldRelationFieldMapping基础的一些代
阅读更多...
Java HashMap的底层实现原理深度解析

Java HashMap的底层实现原理深度解析

《JavaHashMap的底层实现原理深度解析》HashMap基于数组+链表+红黑树结构,通过哈希算法和扩容机制优化性能,负载因子与树化阈值平衡效率,是Java开发必备的高效数据结构,本文给大家介绍... 目录一、概述：HashMap的宏观结构二、核心数据结构解析1. 数组（桶数组）2. 链表节点（Node
阅读更多...
Java AOP面向切面编程的概念和实现方式

Java AOP面向切面编程的概念和实现方式

《JavaAOP面向切面编程的概念和实现方式》AOP是面向切面编程,通过动态代理将横切关注点（如日志、事务）与核心业务逻辑分离,提升代码复用性和可维护性,本文给大家介绍JavaAOP面向切面编程的概... 目录一、AOP 是什么？二、AOP 的核心概念与实现方式核心概念实现方式三、Spring AOP 的关
阅读更多...
Python实现字典转字符串的五种方法

Python实现字典转字符串的五种方法

《Python实现字典转字符串的五种方法》本文介绍了在Python中如何将字典数据结构转换为字符串格式的多种方法,首先可以通过内置的str()函数进行简单转换;其次利用ison.dumps()函数能够... 目录1、使用json模块的dumps方法：2、使用str方法：3、使用循环和字符串拼接：4、使用字符
阅读更多...
Redis 基本数据类型和使用详解

Redis 基本数据类型和使用详解

《Redis基本数据类型和使用详解》String是Redis最基本的数据类型,一个键对应一个值,它的功能十分强大,可以存储字符串、整数、浮点数等多种数据格式,本文给大家介绍Redis基本数据类型和... 目录一、Redis 入门介绍二、Redis 的五大基本数据类型2.1 String 类型2.2 Hash
阅读更多...
MyBatis延迟加载与多级缓存全解析

MyBatis延迟加载与多级缓存全解析

《MyBatis延迟加载与多级缓存全解析》文章介绍MyBatis的延迟加载与多级缓存机制,延迟加载按需加载关联数据提升性能,一级缓存会话级默认开启,二级缓存工厂级支持跨会话共享,增删改操作会清空对应缓... 目录MyBATis延迟加载策略一对多示例一对多示例MyBatis框架的缓存一级缓存二级缓存MyBat
阅读更多...
Redis中Hash从使用过程到原理说明

Redis中Hash从使用过程到原理说明

《Redis中Hash从使用过程到原理说明》RedisHash结构用于存储字段-值对,适合对象数据,支持HSET、HGET等命令,采用ziplist或hashtable编码,通过渐进式rehash优化... 目录一、开篇：Hash就像超市的货架二、Hash的基本使用1. 常用命令示例2. Java操作示例三
阅读更多...
Redis中Set结构使用过程与原理说明

Redis中Set结构使用过程与原理说明

《Redis中Set结构使用过程与原理说明》本文解析了RedisSet数据结构,涵盖其基本操作（如添加、查找）、集合运算（交并差）、底层实现（intset与hashtable自动切换机制）、典型应用场... 目录开篇：从购物车到Redis Set一、Redis Set的基本操作1.1 编程常用命令1.2 集
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2