spring aop aspect + annotation实现缓存命中判断

    最近看到了一种使用aop和注解的方式实现缓存命中判断的实现方式，觉得非常不错。借鉴过来，进行分享。

    1、引入spring和aspect相关依赖

<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
    <version>1.8.6</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
   <version>1.8.6</version>
</dependency>
<dependency>
    <groupId>aopalliance</groupId>
    <artifactId>aopalliance</artifactId>
    <version>1.0</version>
</dependency>

2、创建Cache注解类，用于标识需要添加缓存的方法。

@Documented
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Cache {
    //缓存时间，默认60秒
    int expire() default 60;

    //缓存实体类型
    Class<?> clazz();

    //缓存中存放的具体类型
    CacheType cacheType();

}

3、创建CacheType类，标识缓存的类型，目前仅有Object和List两种，其他的可以根据项目的需求自己添加。

public enum CacheType {
    OBJECT,
    LIST,
    ;
}

4、创建Cache切面类，用于解析Cache注解，实现缓存命中判断。

public class CacheAspect {

    private Logger logger = LoggerFactory.getLogger(CacheAspect.class);

    public Object doAround(ProceedingJoinPoint pjp) throws Throwable {
        MethodSignature ms = (MethodSignature)pjp.getSignature();
        Method method = ms.getMethod();
        Cache annotation = method.getAnnotation(Cache.class);

        //获取注解信息
        int expire = annotation.expire();
        Class<?> clazz = annotation.clazz();
        CacheType cacheType = annotation.cacheType();

        //获取类名、方法名、参数名
        String className = pjp.getTarget().getClass().getSimpleName();
        String methodName = pjp.getSignature().getName();
        Object[] args = pjp.getArgs();
        StringBuffer sb = new StringBuffer();
        for(Object arg : args) {
            if(arg != null) {
                sb.append("_").append(arg.toString());
            }
        }
        //用类名、方法名、参数名作为缓存的key
        String cacheKey = className.concat("_").concat(methodName).concat(sb.toString());
        Object obj = CacheUtils.getFromCache(cacheKey, clazz, cacheType);
        //命中缓存，直接返回信息
        if(obj != null) {
            logger.info("cache hit for key:"+cacheKey);
            return CallResult.success(obj);
        } else {
            //未命中缓存，查询结果，并放到缓存中
            CallResult result = (CallResult)pjp.proceed();
            if(result.isSuccess()) {
                logger.info("put to cache for key:"+cacheKey);
                CacheUtils.put2Cache(cacheKey, result.getResultObject(), expire);
            }
            return result;
        }
    }
}

5、缓存添加、获取实现类，该例子仅使用内存作为缓存，在实际的项目中，可能会使用redis、memcache等缓存。

public class CacheUtils {

    private static Logger logger = LoggerFactory.getLogger(CacheUtils.class);

    private static ConcurrentHashMap<String, String> map = new ConcurrentHashMap<String, String>();

    public static void put2Cache(String key, Object result, int expire) {
        String str = JSON.toJSONString(result);
        map.put(key, str);
    }

    public static Object getFromCache(String key, Class clazz, CacheType cacheType) {
        try {
            String result = map.get(key);
            if(StringUtils.isNotBlank(result)) {
                if(CacheType.LIST.equals(cacheType)) {
                    List list = JSON.parseObject(result, List.class);
                    List retList = new ArrayList();
                    for(Object obj : list) {
                        retList.add(JSON.parseObject(obj.toString(), clazz));
                    }
                    return retList;
                } else {
                    return JSON.parseObject(result, clazz);
                }
            }
        } catch (Exception e) {
            logger.error("getFromCache exception",e);
        }
        return null;
    }
}

6、spring配置文件：

<aop:aspectj-autoproxy proxy-target-class="true" />

<bean id="cacheService" class="com.demo.lizhy.service.impl.CacheServiceImpl" />

<bean id="cacheAspect" class="com.demo.lizhy.service.aspect.CacheAspect" />
<aop:config>
    <aop:aspect ref="cacheAspect">
        <aop:around method="<strong>doAround</strong>" pointcut="@annotation(com.demo.lizhy.service.aspect.Cache)" />
    </aop:aspect>
</aop:config>

<aop:aspectj-autoproxy />有一个proxy-target-class属性，默认为false，表示使用jdk动态代理织入增强，当配为<aop:aspectj-autoproxy  poxy-target-class="true"/>时，表示使用CGLib动态代理技术织入增强。不过即使proxy-target-class设置为false，如果目标类没有声明接口，则spring将自动使用CGLib动态代理。

7、实际使用：CacheService

public class CacheServiceImpl implements CacheService {
    private Logger logger = LoggerFactory.getLogger(CacheServiceImpl.class);
    @Override
    @Cache(expire = 100, clazz = String.class, cacheType = CacheType.OBJECT)
    public CallResult<String> getCacheInfo(String name) {
        logger.info("search from db=========");
        return CallResult.success(name);
    }
}

注意：

JoinPoint：提供访问当前被通知方法的目标对象、代理对象、方法参数等数据：

ProceedingJoinPoint：用于环绕通知，使用proceed()方法来执行目标方法：