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;

}

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;

        }

    }

}

/**

	 * 根据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);

	}