注解+AOP实现redis遍历缓存

1.注解

package com.yun.smart.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;

@Target(ElementType.METHOD)  
@Retention(RetentionPolicy.RUNTIME)  
public @interface CacheAnnotation {

	 /**
     * 缓存key值
     * @return
     */
    String key();
     
    /**
     * 缓存时长
     * @return
     */
    long timeToLive();
    
    /**
     * 对象类型
     * @return
     */
    Class<?> clazz();
     
    /**
     * 缓存时长单位，默认分
     * @return
     */
    TimeUnit timeUnit() default TimeUnit.MINUTES;
    
}

　　

2.AOP

package com.yun.smart.aspect;

import java.util.concurrent.TimeUnit;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.yun.smart.annotation.CacheAnnotation;
import com.yun.smart.redis.RedisService;

@Component
@Aspect
public class CacheAspect {

	private static Logger LOGGER = LoggerFactory.getLogger(CacheAspect.class);
	 
	@Autowired
	private RedisService redisService;
     
    @Around("within(com.yun.smart.cache.service.*) && @annotation(cacheAnnotation)")
    public Object doAround(ProceedingJoinPoint pJoinPoint, CacheAnnotation cacheAnnotation) throws Throwable {
        String key = cacheAnnotation.key();
        TimeUnit timeUnit = cacheAnnotation.timeUnit();
        long timeToLive = cacheAnnotation.timeToLive();
        Class<?> clazz = cacheAnnotation.clazz();
        
        //获取参数
        Object[] args = pJoinPoint.getArgs();
        if (args[0] == null) return null;
         
        key = key.concat(args[0].toString());
        Object obj = redisService.get(key, clazz);
        
        if (obj == null) {
            Object result = pJoinPoint.proceed();
            if (result == null) {
                LOGGER.warn("[{}]无命中。", key);
                return null;
            }
            
            redisService.put(key, result, timeToLive, timeUnit);
            LOGGER.debug("从数据库命中:{}", result);
            return result;
        } else {
            LOGGER.debug("从缓存命中:{}", obj);
            return obj;
        }
         
    }

    
}

　　

　3.使用

/**
	 * 根据openId查询用户信息
	 * @param openId
	 * @return
	 */
	@CacheAnnotation(key=CacheConstant.USER, clazz=UserInfo.class, timeToLive=24, timeUnit=TimeUnit.HOURS)
	public UserInfo getUserInfoById(Long userInfoId) {
		return userInfoService.selectById(userInfoId);
	}