1. 需求背景
需求背景：需要对用户的某些行为进行统计，故在对应的接口上进行埋点。
埋点：当用户点击某个功能时，收集关键数据存储到第三方平台或者数据库中。
一个埋点事件可能在多处被触发（调用多个接口时，均触发一个事件）
2. 设计方案
为了不侵入业务代码，故采用Spring AOP注解的方式完成埋点操作。
在开发过程中遇到的问题：
2.1 模块依赖问题
由于项目采用的多模块的开发方式。
image.png
模块依赖关系如上图所示。
- 埋点注解可以用在web模块，service1，2，3模块。
- 埋点逻辑中组装关键数据需要查询数据库或者调用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="字符串"
例如：
- remark="#{#requestVo.name}" 获取请求对象requestVo中的name字段的值；
- remark="#{#root.name}" 获取响应对象name字段的值
- remark="#{{name:#requestVo.name,age:#root.age,type:'字符串'}}" 组装map对象，handler中可以强转map对象。
- remark="字符串" 后端直接获取字符串。
- 解决引用链上出现空指针异常，可以使用如下的方式：remark = "#{#root?.data?.itemAndAnswer?.get(0)?.name}"
在注解中使用spEL表达式，将分散在response或者request的对象的数据合并为一个map或者转换为其他类型（String、Long），在handler中进行强转获取到具体的参数。由此使得handler可以处理公共逻辑。
网友评论