【项目优化】在实际项目中关于代码优化场景及实现

public Json queryUserDetailsByUid(Long userId){
    Object userDetails;
    if (redisService.isKeyExists(CaCheKeyConstant.getCacheUser(userId))){
        userDetails = redisService.get(CaCheKeyConstant.getCacheUser(userId));
    }else{
        userDetails = userMapper.queryUserDetailsByUid(userId);
        redisService.set(CaCheKeyConstant.getCacheUser(userId), userDetails, CaCheKeyExpireTime.defaultTime);
    }
    return Json.newInstance(userDetails);
}

@MyCache(keyPrefix = CaCheKeyConstant.USER_CACHE_ID, key = "userId", expireTime = CaCheKeyExpireTime.defaultTime)
public Json queryUserDetailsByUid(Long userId){
    return Json.newInstance(userMapper.queryUserDetailsByUid(userId));
}

@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface MyCache {
    // 缓存key的前缀
    String keyPrefix();
    // 缓存Key(如：用户ID，没有则传"")
    String key();
    // 过期时间（毫秒）
    long expireTime() default RedisKeyExpireTime.defaultTime;
}

@Aspect
@Component
@Slf4j
public class CacheManageAop {
    @Resource
    private RedisService redisService;
    /**
     * 从缓存获取数据信息
     */
    @Around(value = "@annotation(cacheFind)")
    public Object findCache(ProceedingJoinPoint joinPoint, MyCache cacheFind) throws Throwable{
        //组装缓存key的值
        String  cacheKey=getCacheKey(cacheFind.keyPrefix(),cacheFind.key(),joinPoint);
        //从缓存里获取数据
        Object result= redisService.get(cacheKey);
        //缓存不存在数据则执行对应的业务方法从数据库查询
        if(Objects.isNull(result)) {
            //把数据保存到缓存
            redisService.set(cacheKey,joinPoint.proceed(),cacheFind.expireTime());
        }
        return  result;
    }
    // 获取缓存的Key值
    private String getCacheKey(String keyPrefix,String key, ProceedingJoinPoint joinPoint) throws  ParameterConvertionException {
        String cachekey="";
        try {
            if(StringUtils.isEmpty(key)){
                cachekey= keyPrefix;
            }else{
                //动态获取方法参数，得到缓存的key
                Map map = AopHelper.getMethodParamsJDK8(joinPoint);
                if (CollectionUtils.isEmpty(map) || map.get(key) == null) {
                    cachekey= keyPrefix;
                    log.error("从{}方法找不到{}对应的参数名",joinPoint.getTarget().getClass() + "." + joinPoint.getSignature().getName(),key);
                }else{
                    cachekey=keyPrefix + map.get(key).toString();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return cachekey;
    }
    // 此处代码需提供公共工具类 AopHelper
    public  static Map getMethodParamsJDK8(JoinPoint joinPoint){
        String[] names = ((MethodSignature) joinPoint.getSignature()).getParameterNames();
        Map params =new HashMap();
        if (ArrayUtils.isEmpty(names)) return params;
        Object[] values = joinPoint.getArgs();
        for (int i = 0; i < names.length; i++) {
            params.put(names[i],values[i]);
        }
        return params;
    }
}

@Scheduled(cron = "0 0/2 * * * ?")
public void testTask() {
    if (redisService.isKeyExists(CaCheKeyConstant.MY_TASK)){
        return;
    }
    redisService.set(CaCheKeyConstant.MY_TASK, "", CaCheKeyExpireTime.MY_DATE_TIME);
    log.info("正在执行*******定时任务：{}", DateUtils.getCurrentDateTime());
}

@Inherited
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface TaskLock {
    /**
     * 任务每隔多长时间执行一次(秒)
     */
    long taskRunTime();
}

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
/**
 * 分布式定时任务锁
 */
@Aspect
@Component
@Slf4j
public class TaskLockAop {
    @Resource
    private RedisService redisService;
    @Around(value = "@annotation(taskLock)")
    public Object taskLock(ProceedingJoinPoint joinPoint, TaskLock taskLock) throws Throwable{
        String lockKey="task_lock:projectName:"+joinPoint.getSignature().getName();
        boolean lock =redisService.setNX(lockKey,taskLock.taskRunTime()-1000);
        return  lock?joinPoint.proceed():null;
    }
}


    public boolean setNX(String lockKey,Long expireTime) {
        return (Boolean) redisTemplate.execute((RedisCallback) connection -> {
            boolean isLock= connection.setNX(lockKey.getBytes(),"".getBytes());
            if(isLock){
                expire(lockKey,expireTime,TimeUnit.SECONDS);
            }
            return isLock;
        });
    }

@TaskLock(runTime = 2*60*1000)
@Scheduled(cron = "0 0/2 * * * ?")
public void testTask() {
    log.info("正在执行*******定时任务：{}", DateUtils.getCurrentDateTime());
}