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);
	}
	

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

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