Java Web知识Spring.Net架构

spEL表达式—让注解更加灵活（项目埋点实战）

2021-04-14  本文已影响0人  小胖学编程

1. 需求背景

需求背景：需要对用户的某些行为进行统计，故在对应的接口上进行埋点。

埋点：当用户点击某个功能时，收集关键数据存储到第三方平台或者数据库中。

一个埋点事件可能在多处被触发（调用多个接口时，均触发一个事件）

2. 设计方案

为了不侵入业务代码，故采用Spring AOP注解的方式完成埋点操作。

在开发过程中遇到的问题：

2.1 模块依赖问题

由于项目采用的多模块的开发方式。

image.png

模块依赖关系如上图所示。

  1. 埋点注解可以用在web模块，service1，2，3模块。
  2. 埋点逻辑中组装关键数据需要查询数据库或者调用feign接口。

最终方案：埋点注解、Aspect类和handler（埋点事件处理器）定义在config模块，handler所有子类定义在service1模块中。

在项目启动后，多个模块的SpringBean均在一个Spring容器中，通过ApplicationContextAware（动态获取容器中Bean）来动态获取容器中的Bean。

2.2 复杂的业务逻辑

一个埋点事件可能在多处被触发（调用多个接口时，均触发一个事件），但是不同的接口请求入参不同，响应结果对象也不同。若在Aspect仅仅将请求对象和响应对象传递到Handler中，同一个Handler无法进行公共处理。

最终方案：采用spEL表达式，在注解中组装参数。

3. 项目实战

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface BuryingPoint {

    /**
     * 事件处理器
     */
    String eventHandler();

    /**
     * 事件名
     */
    String eventName();

    /**
     * 触发事件后，传递到aspect类的参数。
     * <p>
     * 格式:#{spEL}表达式
     * 例如：#{#requestVo.name} 获取请求对象requestVo中的name字段的值；
     * #{#root.name}  获取响应对象name字段的值
     * #{{name:#requestVo.name,age:#root.age,type:'字符串'}}  组装map对象
     */
    String remark() default "";
}

/**
 * 事件处理器
 */
public interface EventHandler {

    void eventHandler(BuryingPointDto scBuryingPointDto);
}

@Data
public class BuryingPointDto {
    /**
     * 请求的ip地址
     */
    private String ipAddress;

    /**
     * 请求头信息
     */
    private Map<String, String> headers;

    /**
     * 事件名称
     */
    private String EventName;

    /**
     * 请求的uri地址
     */
    private String uri;

    private Object remark;

}

@Component
@Slf4j
@Aspect
public class BuryingPointAspect {

    //定义解析器
    private static final SpelExpressionParser PARSER = new SpelExpressionParser();

    private static final TemplateParserContext PARSER_CONTEXT = new TemplateParserContext();


    private static final LocalVariableTableParameterNameDiscoverer localVariableTable = new LocalVariableTableParameterNameDiscoverer();
    /**
     * 定义线程池。
     * 拒绝策略：直接拒绝，不抛出异常
     */
    private static final Executor executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(),
            Runtime.getRuntime().availableProcessors() * 2, 60, TimeUnit.SECONDS,
            new LinkedBlockingQueue<>(500), new ThreadPoolExecutor.DiscardPolicy());

    @Pointcut("@annotation(com.tellme.spel.BuryingPoint)")
    public void permission() {
    }

    @Around(value = "permission();")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        BuryingPointDto scBuryingPointDto = new BuryingPointDto();
        Signature signature = joinPoint.getSignature();
        //参数值
        Object[] args = joinPoint.getArgs();
        MethodSignature methodSignature = (MethodSignature) signature;
        Object target = joinPoint.getTarget();
        //获取到当前执行的方法
        Method method = target.getClass().getDeclaredMethod(methodSignature.getName(), methodSignature.getParameterTypes());
        //获取注解信息
        BuryingPoint buryingPoint = method.getAnnotation(BuryingPoint.class);

        ServletRequestAttributes sra = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();

        scBuryingPointDto.setEventName(buryingPoint.eventName());
        HttpServletRequest request;
        if (sra != null) {
            request = sra.getRequest();
            //获取请求的ip地址
            String ipAddress = getIpAddress(request);
            //获取请求头信息
            Map<String, String> requestHeaders = getRequestHeaders(request);
            scBuryingPointDto.setUri(request.getRequestURI());
            scBuryingPointDto.setIpAddress(ipAddress);
            scBuryingPointDto.setHeaders(requestHeaders);
        }


        Object proceed = joinPoint.proceed();

        try {
            //获取上下文对象
            StandardEvaluationContext evaluationContext = getEvaluationContext(args, method, proceed);
            //判断参数是否为EL表示式
            String remark = buryingPoint.remark();
            if (StringUtils.isNotBlank(remark)) {
                //解析为EL表达式
                if (remark.startsWith(PARSER_CONTEXT.getExpressionPrefix()) && remark.endsWith(PARSER_CONTEXT.getExpressionSuffix())) {
                    scBuryingPointDto.setRemark(PARSER.parseExpression(remark, PARSER_CONTEXT)
                            .getValue(evaluationContext, Object.class));
                } else {
                    //作为普通参数
                    scBuryingPointDto.setRemark(remark);
                }
            }

            String eventHandlerBeanName = buryingPoint.eventHandler();
            Object bean = SpringUtils.getBean(eventHandlerBeanName);
            //判断bean是否是Hander的子类
            if (bean instanceof EventHandler) {
                //触发事件
                executor.execute(() -> {
                    ((EventHandler) bean).eventHandler(scBuryingPointDto);
                });
            } else {
                log.warn("eventHandlerBeanName is not instanceof SCBuryingPointEventHandler , This eventHandlerBeanName is {}", eventHandlerBeanName);
            }

            //数据转换
        } catch (Exception e) {
            log.error("", e);
        }
        return proceed;
    }


    /**
     * 填充spEL的评估上下文对象
     *
     * @param args   代理方法的请求参数
     * @param method 目标方法
     * @param result 结果对象
     * @return 填充请求参数的上下文对象
     */
    private StandardEvaluationContext getEvaluationContext(Object[] args, Method method, Object result) {
        //获取参数名
        String[] parameterNames = localVariableTable.getParameterNames(method);
        StandardEvaluationContext context = new StandardEvaluationContext();
        //填充spEL的上下文对象
        if (parameterNames != null) {
            //获取参数信息
            //对象信息
            for (int i = 0; i < parameterNames.length; i++) {
                context.setVariable(parameterNames[i], args[i]);
            }
        }
        //填充根对象
        context.setRootObject(result);
        return context;
    }

    /**
     * 获取请求ip地址
     *
     * @param request 请求对象
     * @return 请求者的ip地址
     */
    public static String getIpAddress(HttpServletRequest request) {
        String ipAddress = request.getHeader("x-forwarded-for");
        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
            ipAddress = request.getHeader("Proxy-Client-IP");
        }
        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
            ipAddress = request.getHeader("WL-Proxy-Client-IP");
        }
        if (ipAddress == null || ipAddress.length() == 0 || "unknown".equalsIgnoreCase(ipAddress)) {
            ipAddress = request.getRemoteAddr();
            if ("127.0.0.1".equals(ipAddress) || "0:0:0:0:0:0:0:1".equals(ipAddress)) {
                // 根据网卡取本机配置的IP
                try {
                    ipAddress = InetAddress.getLocalHost().getHostAddress();
                } catch (UnknownHostException e) {
                    log.error("buriedPoint getIpAddr error ", e);
                }
            }
        }
        // 对于通过多个代理的情况，第一个IP为客户端真实IP,多个IP按照','分割
        // "***.***.***.***".length()
        if (ipAddress != null && ipAddress.length() > 15) {
            // = 15
            if (ipAddress.indexOf(",") > 0) {
                ipAddress = ipAddress.substring(0, ipAddress.indexOf(","));
            }
        }
        return ipAddress;
    }

    /**
     * 获取请求中的请求头信息
     *
     * @param request 请求对象
     * @return 请求头信息
     */
    public static Map<String, String> getRequestHeaders(HttpServletRequest request) {
        Map<String, String> headers = new HashMap<>();
        Enumeration headerNames = request.getHeaderNames();
        while (headerNames.hasMoreElements()) {
            String key = (String) headerNames.nextElement();
            String value = request.getHeader(key);
            headers.put(key, value);
        }
        return headers;
    }

}

4. spEL表达式可以传入的值

格式: remark="#{spEL}" 或者 remark="字符串"
例如：

  1. remark="#{#requestVo.name}" 获取请求对象requestVo中的name字段的值；
  2. remark="#{#root.name}" 获取响应对象name字段的值
  3. remark="#{{name:#requestVo.name,age:#root.age,type:'字符串'}}" 组装map对象，handler中可以强转map对象。
  4. remark="字符串" 后端直接获取字符串。
  5. 解决引用链上出现空指针异常，可以使用如下的方式：remark = "#{#root?.data?.itemAndAnswer?.get(0)?.name}"

在注解中使用spEL表达式，将分散在response或者request的对象的数据合并为一个map或者转换为其他类型（String、Long），在handler中进行强转获取到具体的参数。由此使得handler可以处理公共逻辑。

推荐阅读

spEL—基础语法+注解中动态调用Bean方法

上一篇下一篇

猜你喜欢

热点阅读