1    新增三个注解支持类，其实是拷贝出来的spring的类

package per.yan.ding.util.el;

 

import org.aspectj.lang.JoinPoint;

import org.aspectj.lang.reflect.MethodSignature;

import org.springframework.cache.interceptor.SimpleKeyGenerator;

import org.springframework.context.expression.AnnotatedElementKey;

import org.springframework.expression.EvaluationContext;

import org.springframework.util.StringUtils;

 

import java.lang.reflect.Method;

 

/**

 * @author gaoyan

 * @date 2019/1/14 17:41

 */

public class AspectSupportUtils {

    private static ExpressionEvaluator evaluator = new ExpressionEvaluator();

 

    public static Object getKeyValue(JoinPoint joinPoint, String keyExpression) {

        return getKeyValue(joinPoint.getTarget(), joinPoint.getArgs(), joinPoint.getTarget().getClass(),

                ((MethodSignature) joinPoint.getSignature()).getMethod(), keyExpression);

    }

 

    private static Object getKeyValue(Object object, Object[] args, Class clazz, Method method,

                                      String keyExpression) {

        if (StringUtils.hasText(keyExpression)) {

            EvaluationContext evaluationContext = evaluator.createEvaluationContext(object, clazz, method, args);

            AnnotatedElementKey methodKey = new AnnotatedElementKey(method, clazz);

            return evaluator.key(keyExpression, methodKey, evaluationContext);

        }

        return SimpleKeyGenerator.generateKey(args);

    }

}

package per.yan.ding.util.el;

 

import org.springframework.aop.support.AopUtils;

import org.springframework.context.expression.AnnotatedElementKey;

import org.springframework.context.expression.CachedExpressionEvaluator;

import org.springframework.context.expression.MethodBasedEvaluationContext;

import org.springframework.core.DefaultParameterNameDiscoverer;

import org.springframework.core.ParameterNameDiscoverer;

import org.springframework.expression.EvaluationContext;

import org.springframework.expression.Expression;

 

import java.lang.reflect.Method;

import java.util.Map;

import java.util.concurrent.ConcurrentHashMap;

 

/**

 * @author gaoyan

 * @date 2019/1/14 17:42

 */

public class ExpressionEvaluator extends CachedExpressionEvaluator {

    private final ParameterNameDiscoverer paramNameDiscoverer = new DefaultParameterNameDiscoverer();

 

    private final Map conditionCache = new ConcurrentHashMap<>(64);

 

    private final Map targetMethodCache = new ConcurrentHashMap<>(64);

 

    public EvaluationContext createEvaluationContext(Object object, Class targetClass, Method method,

                                                     Object[] args) {

        Method targetMethod = getTargetMethod(targetClass, method);

        ExpressionRootObject root = new ExpressionRootObject(object, args);

        return new MethodBasedEvaluationContext(root, targetMethod, args, this.paramNameDiscoverer);

    }

 

    public Object key(String conditionExpression, AnnotatedElementKey elementKey, EvaluationContext evalContext) {

        return get[removed]this.conditionCache, elementKey, conditionExpression).getValue(evalContext);

    }

 

    private Method getTargetMethod(Class targetClass, Method method) {

        AnnotatedElementKey methodKey = new AnnotatedElementKey(method, targetClass);

        Method targetMethod = this.targetMethodCache.get(methodKey);

        if (targetMethod == null) {

            targetMethod = AopUtils.getMostSpecificMethod(method, targetClass);

            if (targetMethod == null) {

                targetMethod = method;

            }

            this.targetMethodCache.put(methodKey, targetMethod);

        }

        return targetMethod;

    }

}

package per.yan.ding.util.el;

 

/**

 * @author gaoyan

 * @date 2019/1/14 17:42

 */

public class ExpressionRootObject {

    private final Object object;

 

    private final Object[] args;

 

    public ExpressionRootObject(Object object, Object[] args) {

        this.object = object;

        this.args = args;

    }

 

    public Object getobject() {

        return object;

    }

 

    public Object[] getArgs() {

        return args;

    }

}

2    增加自定义注解，以及在自定义注解的切面解析类中使用

package per.yan.ding.aspect;

 

import java.lang.annotation.*;

 

/**

 * 日志记录  注解

 * @author gaoyan

 * @date 2019/1/15 10:02

 */

@Documented

@Retention(RetentionPolicy.RUNTIME)

@Target(ElementType.METHOD)

public @interface Log {

 

    String orderNoKey();

 

    String createdByKey() default "System";

}

package per.yan.ding.aspect;

 

import lombok.extern.slf4j.Slf4j;

import org.aspectj.lang.JoinPoint;

import org.aspectj.lang.annotation.AfterReturning;

import org.aspectj.lang.annotation.Aspect;

import org.aspectj.lang.annotation.Pointcut;

import org.aspectj.lang.reflect.MethodSignature;

import org.springframework.stereotype.Component;

import per.yan.ding.model.vo.DataResponse;

import per.yan.ding.util.el.AspectSupportUtils;

 

import java.lang.reflect.Method;

 

/**

 * @author gaoyan

 * @date 2019/1/15 10:05

 */

@Slf4j

@Aspect

@Component

public class LogAspect {

 

    public static final String USER_SYSTEM = "System";

 

    public static final int SUCCESS_CODE = 200;

 

    @Pointcut("@annotation(per.yan.ding.aspect.Log)")

    public void doPerform() {

 

    }

 

    @AfterReturning(pointcut = "doPerform()", returning = "result")

    public void determine(JoinPoint jp, Object result) {

        if (result instanceof DataResponse) {

            DataResponse response = (DataResponse) result;

            if (response.getResultCode() == SUCCESS_CODE) {

                MethodSignature signature = (MethodSignature) jp.getSignature();

                if (null != signature) {

                    Method method = signature.getMethod();

                    if (null != method && method.isAnnotationPresent(Log.class)) {

                        Log log = method.getAnnotation(Log.class);

                        String orderNoKey = log.orderNoKey();

                        String createdByKey = log.createdByKey();

                        //使用spring EL表达式获取参数中的值

                        String orderNo = (String) AspectSupportUtils.getKeyValue(jp, orderNoKey);

                        Integer createdBy;

                        if (USER_SYSTEM.equals(createdByKey)) {

                            createdBy = 0;

                        } else {

                            createdBy = (Integer) AspectSupportUtils.getKeyValue(jp, createdByKey);

                        }

                        /// TODO: 2019/3/29 调用记录日志的service记录日志

 

                    }

                }

            }

        }

    }

}

自定义DistributeExceptionHandler注解，该注解接收一个参数attachmentId。

该注解用在方法上，使用该注解作为切点，实现标注该注解的方法抛异常后的统一处理。

/**

 * @Author: Lijian

 * @Date: 2019-09-06 09:26

 */

@Target(ElementType.METHOD)

@Retention(RetentionPolicy.RUNTIME)

public @interface DistributeExceptionHandler {

    String attachmentId();

}

使用方法：

@DistributeExceptionHandler(attachmentId = "#test.id")

public void test(Test test){

    

}

Aspect代码

拦截DistributeExceptionHandler注解作为切点

使用@AfterThrowing处理异常情况