利用JAVA的AOP运行时注解实现请求VO的复杂组装

背景

上一篇介绍了关于JAVA的AOP编译时注解的开发经验，因此，这里则接着来讲讲AOP运行时注解，摘取的是利用运行时注解实现微服务对请求对象（VO）中的指定字段特殊处理的统一封装，典型场景就是SpringCloud Gateway对用户请求经过认证、鉴权、路由等处理之后，将必要信息添加到消息头中，转发到相应的微服务。

设计要求

仅就本文讨论的运行时注解而言，业务开发者在编写服务接口时，主要考虑的几点是：

从业务角度出发，定义完整的VO，省去各个接口实现中的VO拼接处理；
重要数据（如归属关系、角色权限等）防假冒。

代码

1. 注解定义

1）AuthInjected注解

/**
 * Auth
 * 运行时注解，用于Controller成员方法的参数
 */
@Target({ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
public @interface AuthInjected {
}

2）AuthField注解

/**
 * AuthField
 * 运行时注解，用于VO类的成员属性
 */
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface AuthField {
    /**
     * header
     * Auth头的键
     */
    String header();

    /**
     * rewrite
     * 如果原始请求中已赋值，是否强制重写为Auth头的值。
     * 用于阻止用户请求中的假冒数据。
     */
    boolean rewrite() default false;
}

2. 运行时注解的处理实现

@Component
@Aspect
public class AuthAspect {

    @Autowired(required = false)
    private HttpServletRequest request;

    @Pointcut(value = "execution(* *.*(.., @AuthInjected (*), ..))")
    private void annoParam() {
    }

    @Around(value = "annoParam()")
    public Object around(ProceedingJoinPoint jp) throws Throwable {
        // 获取实际方法
        Signature sign = jp.getSignature();
        Method meth = ((MethodSignature) sign).getMethod();
        Method realMethod = jp.getTarget().getClass().getDeclaredMethod(sign.getName(), meth.getParameterTypes());
        // 检查参数注解
        Object[] args = jp.getArgs();
        int i = 0;
        Annotation[][] paramAnnotations = realMethod.getParameterAnnotations();
        for (Annotation[] annotations : paramAnnotations) {
            for (Annotation annotation : annotations) {
                if (annotation.annotationType().getSimpleName().equals("AuthInjected")) {
                    Object arg = args[i];
                    // 检查参数对象的属性
                    for (Field field: arg.getClass().getDeclaredFields()) {
                        AuthField authField = field.getAnnotation(AuthField.class);
                        if (authField == null) {
                            continue;
                        }
                        // 获取消息头键值
                        String strValue = request.getHeader(authField.header());
                        if (strValue == null) {
                            continue;
                        }
                        PropertyDescriptor pd = new PropertyDescriptor(field.getName(), arg.getClass());
                        Method writeMethod = pd.getWriteMethod();
                        // 检查是否要求强制重写
                        if (!authField.rewrite()) {
                            Method readMethod = pd.getReadMethod();
                            Object value = readMethod.invoke(arg);
                            if (value != null) {
                                continue;
                            }
                        }
                        Object value;
                        Class<?> cls = field.getType();
                        if (cls.isAssignableFrom(String.class)) {
                            value = strValue;
                        } else if (cls.isAssignableFrom(Long.class)) {
                            value = Long.valueOf(strValue);
                        } else if (cls.isAssignableFrom(Integer.class)) {
                            value = Integer.valueOf(strValue);
                        } else if (cls.isAssignableFrom(Double.class)) {
                            value = Double.valueOf(strValue);
                        } else if (cls.isAssignableFrom(Float.class)) {
                            value = Float.valueOf(strValue);
                        } else if (cls.isAssignableFrom(Boolean.class)) {
                            value = Boolean.valueOf(strValue);
                        } else {
                            value = null;
                        }
                        writeMethod.invoke(arg, value);
                    }
                    break;
                }
            }
            i = i + 1;
        }
        return jp.proceed();
    }

}

wrtieMethod.invoke之前的值类型转换，不是今天要讨论的重点，所以只是简单粗暴地写了一堆if-else。实际项目中，可以采用策略模式+工厂模式进行优化。

3. VO定义（以UserVo为例）

@Data
public class UserVo {
    @AuthField(header = "x-auth-userid", rewrite = true)
    private Long id;
    @AuthField(header = "x-auth-role", rewrite = true)
    private Long role;

    private String name;
}

为了阻止用户请求中的假冒数据，Gateway应该清除用户请求中的所有x-auth-*头，通过rewrite=true阻止URL参数或body中的假冒数据。

4. 接口实现（示例）

    @GetMapping("/getUserName")
    public String getUserName(@AuthInjected UserVo userVo){
        return userVo.getName();
    }

结束语

要用好运行时注解，关键点的是搞清楚切入点（Pointcut）和通知（Advice）。切入点表达式还有很多类型，通常根据注解的目标类型来决定，具体表达式的写法则根据注解的使用场景来编写。选择什么通知，则是根据要在什么时间点、以及要做什么来决定的。一般来说，Around较为常见一些。

最后，也真心欢迎交流，一起提高。