用Spring Aop 实现注解Dao层的自动Spring Redis缓存

            package
             com.ns.annotation;


            import
             java.lang.annotation.Documented;

            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;

            /**
            
 * 只能注解dao里面对应的get方法,传递的参数作为hashkey,返回的值作为value
 * 
            @author
             Han
 
            */
            
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented

            public @interface Cached {
    /**
     * redis key
     * @return*/
    String key();
    /**
     * 过期时间，默认为0即永不过期
     * @return*/long timeout() default 0L;
    /**
     * 时间单位，默认为秒
     * @return*/
    TimeUnit timeunit() default TimeUnit.SECONDS;

}

            package
             com.ns.redis.aop;


            import
             java.lang.reflect.Method;

            import
             java.util.HashMap;

            import
             java.util.LinkedHashMap;

            import
             java.util.Map;


            import
             org.apache.commons.collections.MapUtils;

            import
             org.apache.commons.lang.ArrayUtils;

            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.dao.DataAccessException;

            import
             org.springframework.data.redis.connection.RedisConnection;

            import
             org.springframework.data.redis.core.RedisCallback;

            import
             org.springframework.data.redis.serializer.JdkSerializationRedisSerializer;

            import
             org.springframework.data.redis.serializer.RedisSerializer;

            import
             org.springframework.stereotype.Component;

            import
             org.springframework.util.Assert;


            import
             com.ns.annotation.Cached;

            import
             com.ns.redis.dao.base.BaseRedisDao;

            /**
            
 * 对dao的getbean的缓存处理
 * 
            @author
             Han
 
            */
            
@Aspect
@Component

            public
            class AutoRedisCached extends BaseRedisDao<String, Object>{
    
    /*
     * 约束任意包下的包含Dao的类的任意方法，并且被cached注解
     */
    @Pointcut("execution(* *..*Dao*.*(*,..) && @annotation(com.ns.annotation.Cached))")
    privatevoid cacheMethod(){}
    
    @Around("cacheMethod()")
    public Object doArround(ProceedingJoinPoint pjp) throws Throwable{
        Object[] args = pjp.getArgs();
        //定义序列化器final RedisSerializer<String> keySerializer = getKeySerializer();
        final RedisSerializer<Object> hashValueSerializer = getHashValueSerializer();
        final RedisSerializer<Object> hashKeySerializer = getHashKeySerializer();
        
        //序列化参数，作为hashkeybyte [] hashkeyBytesTmp = null;
        if(args.length == 1){
            hashkeyBytesTmp = hashKeySerializer.serialize(args[0]);
        }else{
            hashkeyBytesTmp = newbyte[0];
            for(Object arg : args){
                hashkeyBytesTmp = ArrayUtils.addAll(hashkeyBytesTmp, hashKeySerializer.serialize(arg));
            }
        }
        
        finalbyte [] hashkeyBytes = hashkeyBytesTmp;
        
        MethodSignature methodSignature = (MethodSignature) pjp.getSignature();
        Method method = methodSignature.getMethod();
        final Cached cacheinfo = method.getAnnotation(Cached.class);
        Object obj= null;
        
        obj = execute(new RedisCallback<Object>() {
            @Override
            public Object doInRedis(RedisConnection connection) throws DataAccessException {
                byte [] tmp = connection.hGet(keySerializer.serialize(cacheinfo.key()), hashkeyBytes);
                return hashValueSerializer.deserialize(tmp);
            }
        });
        if(obj == null){
            final Object objReturn = pjp.proceed();
            if(objReturn != null){
                execute(new RedisCallback<Boolean>() {
                    @Override
                    public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                        return connection.hSet(keySerializer.serialize(cacheinfo.key()), hashkeyBytes,hashValueSerializer.serialize(objReturn));
                    }
                });
                
                if(cacheinfo.timeout()>0){
                    expire(cacheinfo.key(), cacheinfo.timeout(), cacheinfo.timeunit());
                }
            }
            obj = objReturn;
        }
        //从dao获取return obj;
    }
}