java 拦截器中使用反射

package com.awj.mall.restfulapi.common.aop;


import com.awj.mall.restfulapi.common.annotation.DLock;
import com.awj.mall.restfulapi.common.annotation.RLockKey;
import com.awj.mall.restfulapi.common.aop.bean.LockKey;
import com.awj.mall.restfulapi.common.aop.bean.RLockBeanDefinition;
import com.awj.mall.restfulapi.modular.base.result.JsonResult;
import com.awj.mall.restfulapi.modular.base.result.ResultCode;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.reflect.MethodSignature;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

@Aspect
@Component
public class RLockAop {

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


    private static Map<String, RLockBeanDefinition> rLockKeysCacheMap = new ConcurrentHashMap<String, RLockBeanDefinition>();

    @Autowired
    private RedissonClient redissonClient;

    @Around("execution(* com.awj.mall..*(..))&& @annotation(com.awj.mall.restfulapi.common.annotation.DLock)")
    public Object lock(ProceedingJoinPoint point) throws Throwable {
        MethodSignature methodSignature = (MethodSignature) point.getSignature();
        Method method = methodSignature.getMethod();
        String name = getDefinitionName(method);
        RLockBeanDefinition rLockBeanDefinition = getBeanDefinition(name);
        List<LockKey> lockKeys = null;
        DLock dLock = null;
        if (rLockBeanDefinition == null) {
            rLockBeanDefinition = new RLockBeanDefinition();
            dLock = method.getAnnotation(DLock.class);
            rLockBeanDefinition.setdLock(dLock);
            rLockBeanDefinition.setMethodName(name);
            Parameter[] parameters = method.getParameters();
            lockKeys = new LinkedList<LockKey>();
            for (int i = 0; i < parameters.length; i++) {
                LockKey lockKey = new LockKey();
                Parameter parameter = parameters[i];
                RLockKey rLockKey = parameter.getAnnotation(RLockKey.class);
                if (rLockKey != null) {
                    lockKey.setKey(rLockKey.key());
                    lockKey.setPosition(i);
                    lockKeys.add(lockKey);
                }
            }
            if (lockKeys.size() > 0) {
                rLockBeanDefinition.setLockKeys(lockKeys);
            }
            addBeanDefinition(rLockBeanDefinition);
        } else {
            dLock = rLockBeanDefinition.getdLock();
            lockKeys = rLockBeanDefinition.getLockKeys();
        }

        Object[] args = point.getArgs();
        String key = dLock.key();
        if (lockKeys != null && lockKeys.size() > 0) {
            for (LockKey each : lockKeys) {
                key = key.replaceAll("#" + each.getKey(), convertToStr(args[each.getPosition()]));
            }
        }
        Long waitTime = dLock.waitTime();
        TimeUnit timeUnit = dLock.timeUnit();
        System.out.println("lock --> key:"+key);
//        logger.info("lock --> key:"+key);
        RLock rLock = redissonClient.getLock(key);
        try {
            if (rLock.tryLock(waitTime, timeUnit)) {
                return point.proceed();
            }
        } catch (Exception e) {
            logger.error(e.getMessage());
        } finally {
            rLock.unlock();
        }
        return JsonResult.error(ResultCode.SYS_BUSY);
    }


    /**
     * @param obj
     * @return
     */
    public String convertToStr(Object obj) {
        if (obj == null) {
            return "";
        }
//        Assert.notNull(obj,"lockKey is null");
        return obj.toString();
    }


    public String getDefinitionName(Method method) {
        Class clazz = method.getDeclaringClass();
        return clazz.getName() + ":" + method.getName() + "()";
    }





    public void addBeanDefinition(RLockBeanDefinition rLockBeanDefinition ){
        rLockKeysCacheMap.put(rLockBeanDefinition.getMethodName(),rLockBeanDefinition);
    }


    public RLockBeanDefinition getBeanDefinition(String method){
       return rLockKeysCacheMap.get(method);
    }

}