skywalking插件工作原理剖析
1. 官方插件二次开发
前面在介绍
skywalking-agent目录时，提到了它有一个插件目录，并支持动态的开发插件。其实skywalking默认已经提供大部分框架的插件了，一般情况下不需要额外开发新的插件，可以直接改造已有的插件，使其适配自己的业务。下面介绍如何二次开发SpringMVC插件以采集业务参数。
（1）下载插件源码
在skywalking 8.7.0及以前的版本，插件的源码是直接放在skywalking主项目中的。在8.7.0以后的版本，把插件移出去了。（这一点好坑，我在skywalking最新版本里找了好久没找到插件的源码）。
下面分析的源码来自于skywalking 8.7.0版本。
-
插件源码位置：skywalking/apm-sniffer/apm-sdk-plugin（下面有个spring-plugins目录，里面就是spring相关的插件）
由于我的项目中用的SpringMVC是5.x的版本，因此主要关注下图中标记的两个目录。
顺便提一句skywalking 8.7.0以后版本的源码：
- URL：https://github.com/apache/skywalking-java
- 插件源码位置：skywalking-java/apm-sniffer/apm-sdk-plugin
（2）由SpringMVC插件窥探整个框架
① SpringMVC插件模块一览
一眼看过去，眼前一黑。仔细看就会发现，这里面的类主要分两大类，以Instrumentation和Interceptor结尾。Interceptor结尾的一般是拦截器，熟悉java agent技术的同学一般会知道Instrumentation，这个其实就是agent技术中的核心类，它可以加载Class文件，甚至可以修改Class文件。
我们发现有两个类名比较熟悉：ControllerInstrumentation和RestControllerInstrumentation，Controller和RestController就是SpringMVC中常用的两个注解，本项目中使用的是RestController注解，就以此类为入口吧。
这里不对java agent对额外的说明了，想要看懂skywalking框架，必须要先了解java agent。
② RestControllerInstrumentation类源码
public class RestControllerInstrumentation extends AbstractControllerInstrumentation {
// 这玩意就是RestController注解
public static final String ENHANCE_ANNOTATION = "org.springframework.web.bind.annotation.RestController";
@Override
protected String[] getEnhanceAnnotations() {
return new String[] {ENHANCE_ANNOTATION};
}
}
可以发现，ENHANCE_ANNOTATION这个属性的值就是SpringMVC中那个注解类。enhance是增强的意思，很好理解，这里就是要增强RestController注解的功能。看下getEnhanceAnnotations()方法在哪里被调用了。
③ AbstractControllerInstrumentation类源码
AbstractControllerInstrumentation类是RestControllerInstrumentation的父类，在enhanceClass()方法中调用了getEnhanceAnnotations()方法。这样就串起来了，这里实际上就是增强了被RestController注解修饰的类的功能。那么到底是怎么增强的呢？
public abstract class AbstractControllerInstrumentation extends AbstractSpring5Instrumentation {
@Override
public ConstructorInterceptPoint[] getConstructorsInterceptPoints() {// 忽略}
@Override
public InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() {
// 这里声明了方法切入点，返回的是一个数组，说明可以有多个切入点
return new InstanceMethodsInterceptPoint[] {
new DeclaredInstanceMethodsInterceptPoint() {
@Override
public ElementMatcher<MethodDescription> getMethodsMatcher() {
// 这里是被RequestMapping注解的方法作为一个切入点
return byMethodInheritanceAnnotationMatcher(named("org.springframework.web.bind.annotation.RequestMapping"));
}
@Override
public String getMethodsInterceptor() {
// 这里是此切入点的拦截器
return Constants.REQUEST_MAPPING_METHOD_INTERCEPTOR;
}
@Override
public boolean isOverrideArgs() {
return false;
}
},
new DeclaredInstanceMethodsInterceptPoint() {
@Override
public ElementMatcher<MethodDescription> getMethodsMatcher() {
// 这里是被GetMapping、PostMapping等注解的方法作为一个切入点
return byMethodInheritanceAnnotationMatcher(named("org.springframework.web.bind.annotation.GetMapping"))
.or(byMethodInheritanceAnnotationMatcher(named("org.springframework.web.bind.annotation.PostMapping")))
.or(byMethodInheritanceAnnotationMatcher(named("org.springframework.web.bind.annotation.PutMapping")))
.or(byMethodInheritanceAnnotationMatcher(named("org.springframework.web.bind.annotation.DeleteMapping")))
.or(byMethodInheritanceAnnotationMatcher(named("org.springframework.web.bind.annotation.PatchMapping")));
}
@Override
public String getMethodsInterceptor() {
// 这里是此切入点的拦截器
return Constants.REST_MAPPING_METHOD_INTERCEPTOR;
}
@Override
public boolean isOverrideArgs() {
return false;
}
}
};
}
@Override
protected ClassMatch enhanceClass() {
// 这里是是增强类的功能
return ClassAnnotationMatch.byClassAnnotationMatch(getEnhanceAnnotations());
}
protected abstract String[] getEnhanceAnnotations();
}
public class Constants {
public static final String REQUEST_MAPPING_METHOD_INTERCEPTOR = "org.apache.skywalking.apm.plugin.spring.mvc.commons.interceptor.RequestMappingMethodInterceptor";
public static final String REST_MAPPING_METHOD_INTERCEPTOR = "org.apache.skywalking.apm.plugin.spring.mvc.commons.interceptor.RestMappingMethodInterceptor";
}
在getInstanceMethodsInterceptPoints()方法中，可以看到很多熟悉的注解，比如PostMapping。结合一下方法名，可以大胆的推测，这里其实就是定义对象实例方法的拦截切入点。再看下getMethodsInterceptor()方法中使用的两个常量，以REST_MAPPING_METHOD_INTERCEPTOR为例，它的值就是个类名：RestMappingMethodInterceptor，那这个类肯定就是负责增强功能的拦截器。进入这个拦截器瞧瞧。
④ RestMappingMethodInterceptor类源码
// 这里省略了大量的代码
public class RestMappingMethodInterceptor extends AbstractMethodInterceptor {
@Override
public String getRequestURL(Method method) {
// 这里是从注解中解析请求url
return ParsePathUtil.recursiveParseMethodAnnotation(method, m -> {
String requestURL = null;
GetMapping getMapping = AnnotationUtils.getAnnotation(m, GetMapping.class);
if (getMapping != null) {
if (getMapping.value().length > 0) {
requestURL = getMapping.value()[0];
} else if (getMapping.path().length > 0) {
requestURL = getMapping.path()[0];
}
}
return requestURL;
});
}
@Override
public String getAcceptedMethodTypes(Method method) {
// 这里是从注解中解析请求类型
return ParsePathUtil.recursiveParseMethodAnnotation(method, m -> {
if (AnnotationUtils.getAnnotation(m, GetMapping.class) != null) {
return "{GET}";
} else {
return null;
}
});
}
}
这个类里的两个方法都是工具方法，仅仅解析了请求url和类型。其他的功能实现肯定在它的父类AbstractMethodInterceptor里。
⑤ AbstractMethodInterceptor类源码
// 这里省略了大量的代码，只保留了核心的部分
public abstract class AbstractMethodInterceptor implements InstanceMethodsAroundInterceptor {
public abstract String getRequestURL(Method method);
public abstract String getAcceptedMethodTypes(Method method);
@Override
public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
MethodInterceptResult result) throws Throwable {
// 这是在被切入的方法执行前，要执行的逻辑
Object request = ContextManager.getRuntimeContext().get(REQUEST_KEY_IN_RUNTIME_CONTEXT);
if (request != null) {
StackDepth stackDepth = (StackDepth) ContextManager.getRuntimeContext().get(CONTROLLER_METHOD_STACK_DEPTH);
if (stackDepth == null) {
final ContextCarrier contextCarrier = new ContextCarrier();
// 如果请求类是继承自servlet-api提供的HttpServletRequest类，则走此方法
if (IN_SERVLET_CONTAINER && HttpServletRequest.class.isAssignableFrom(request.getClass())) {
final HttpServletRequest httpServletRequest = (HttpServletRequest) request;
// AbstractSpan是skywalking中日志的一个载体，用于采集数据
AbstractSpan span = ContextManager.createEntrySpan(operationName, contextCarrier);
// 采集请求URL
Tags.URL.set(span, httpServletRequest.getRequestURL().toString());
// 采集请求的类型，如GET、POST
Tags.HTTP.METHOD.set(span, httpServletRequest.getMethod());
// 标记是SpringMVC的日志
span.setComponent(ComponentsDefine.SPRING_MVC_ANNOTATION);
// 标记是HTTP请求
SpanLayer.asHttp(span);
if (SpringMVCPluginConfig.Plugin.SpringMVC.COLLECT_HTTP_PARAMS) {
// 采集请求参数
RequestUtil.collectHttpParam(httpServletRequest, span);
}
if (!CollectionUtil.isEmpty(SpringMVCPluginConfig.Plugin.Http.INCLUDE_HTTP_HEADERS)) {
// 采集请求头
RequestUtil.collectHttpHeaders(httpServletRequest, span);
}
} else {
throw new IllegalStateException("this line should not be reached");
}
stackDepth = new StackDepth();
ContextManager.getRuntimeContext().put(CONTROLLER_METHOD_STACK_DEPTH, stackDepth);
}
stackDepth.increment();
}
}
@Override
public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
Object ret) throws Throwable {
// 这是在被切入的方法执行后，要执行的逻辑
}
}
这个类中就是增强的功能，可以看出它能在被切入的方法之前和之后增强功能，在被请求注解类（如PostMapping）注解的方法执行前，它可以采集到请求的url、请求头、请求内容等等。那么在方法执行后，它肯定也可以采集到响应内容。
⑥ 小结
看到这里，SpringMVC插件采集的原理基本上可以猜到了，就是实现了拦截器，拦截了被注解的请求接口方法，并在方法执行前后采集数据。
且先不管这个拦截器到底是怎么工作的，看到这里，基本上已经明了该如何采集自定义的业务数据了，就是直接修改AbstractMethodInterceptor源码即可。
（3）业务请求参数采集
① 默认的请求参数采集
if (SpringMVCPluginConfig.Plugin.SpringMVC.COLLECT_HTTP_PARAMS) {
// 采集请求参数
RequestUtil.collectHttpParam(serverHttpRequest, span);
}
看到采集参数的条件是COLLECT_HTTP_PARAMS，点进去看，好像是个配置类，默认是关闭的，那可以先把它打开。
public class SpringMVCPluginConfig {
public static class Plugin {
@PluginConfig(root = SpringMVCPluginConfig.class)
public static class SpringMVC {
// 是否采集请求参数的开关，默认是关闭的
public static boolean COLLECT_HTTP_PARAMS = false;
}
}
}
去skywalking-agent/config/agent.config配置文件中搜一下，果然找到了：
# 采集SpringMVC请求参数的开关
plugin.springmvc.collect_http_params=${SW_PLUGIN_SPRINGMVC_COLLECT_HTTP_PARAMS:false}
然后再看采集的方法RequestUtil.collectHttpParam(serverHttpRequest, span)：
public class RequestUtil {
public static void collectHttpParam(HttpServletRequest request, AbstractSpan span) {
// 获取请求参数
final Map<String, String[]> parameterMap = request.getParameterMap();
if (parameterMap != null && !parameterMap.isEmpty()) {
String tagValue = CollectionUtil.toString(parameterMap);
tagValue = SpringMVCPluginConfig.Plugin.Http.HTTP_PARAMS_LENGTH_THRESHOLD > 0 ?
StringUtil.cut(tagValue, SpringMVCPluginConfig.Plugin.Http.HTTP_PARAMS_LENGTH_THRESHOLD) : tagValue;
// 将请求参数写入日志http.params字段中
Tags.HTTP.PARAMS.set(span, tagValue);
}
}
}
可以看到，获取请求参数是用的request.getParameterMap()方法，如果你的接口使用的表单方式提交，那么恭喜，参数可以被采集起来。如果使用application/json协议提交参数，不好意思，它采集不到。我的项目里都是后者，因此要额外开发。
② 自定义业务参数采集
使用application/json协议提交的参数，是不方便从request中直接解析出来的。而这里的Object[] allArguments是切入点方法的入参，刚好就是请求参数，因此这里就直接利用其解析请求参数。
if (SpringMVCPluginConfig.Plugin.SpringMVC.COLLECT_HTTP_PARAMS) {
if (!StringUtils.isEmpty(httpServletRequest.getContentType())
&& httpServletRequest.getContentType().contains(MediaType.APPLICATION_JSON_VALUE)) {
// 采集使用application/json协议提交的参数
recordJsonReqLog(allArguments, span, httpServletRequest.getHeader("X_TRACEID"));
} else {
RequestUtil.collectHttpParam(httpServletRequest, span);
}
}
// 记录业务参数的方法
private void recordJsonReqLog(Object[] allArguments, AbstractSpan span, String traceId) {
// 记录业务的调用链ID
if (!StringUtils.isEmpty(traceId)) {
span.tag(new StringTag("traceId"), traceId);
}
if (allArguments != null && allArguments.length > 0) {
// 记录请求参数
String param = GSON.toJson(allArguments[0]);
span.tag(new StringTag("http.req"), param);
try {
// 解析请求参数
JsonObject jsonObject = GSON.fromJson(param, JsonObject.class);
JsonObject data = jsonObject.getAsJsonObject("data");
if (data == null) {
// 如果没有data参数，直接解析外层参数
data = jsonObject;
}
// 记录业务参数
Optional.ofNullable(data.get("account")).ifPresent(jsonElement
-> span.tag(new StringTag("account"), jsonElement.getAsString()));
Optional.ofNullable(data.get("userId")).ifPresent(jsonElement
-> span.tag(new StringTag("userId"), jsonElement.getAsString()));
Optional.ofNullable(data.get("deviceId")).ifPresent(jsonElement
-> span.tag(new StringTag("deviceId"), jsonElement.getAsString()));
} catch (JsonSyntaxException e) {
}
}
}
采集响应参数的思路和上面一样，这里不做介绍了。
（4）使用插件
上面修改的是AbstractMethodInterceptor类，这个类所在模块为apm-springmvc-annotation-commons，所以直接使用maven命令打包，将生成的产物apm-springmvc-annotation-commons-8.7.0.jar拷贝到skywalking-agent/plugins目录下，然后重新构建项目并部署，即可生效。
（5）小结
看到这里，基本上我们已经学会skywalking的一些高级用法了，可以做一些简单的插件二次开发，足以应对项目中大部分业务数据的采集。其他的插件和SpringMVC插件类似，代码的结构基本上差不多。
2. 插件原理剖析
上面的SpringMVC插件源码，我们跟到拦截器
Interceptor，就停止了，那么拦截器到底是如何加载的呢？值得好好研究研究。（不得不说，skywalkig的源码写得是真的很复杂，但是确实很牛B。）在研究之前，我要先介绍一下Byte Buddy。
（1）Byte Buddy介绍
runtime code generation for the Java virtual machine
上面这段话摘自github上该项目的简介，翻译过来就是针对JVM虚拟机的运行时代码生成。这不就是动态代理么？话不多说，先上一段代码：
// agent探针类
public class ToStringAgent {
// 探针入口
public static void premain(String arguments, Instrumentation instrumentation) {
// AgentBuilder是Byte Buddy中的一个构建器
new AgentBuilder.Default()
// 拦截被ToString注解的类
.type(isAnnotatedWith(ToString.class))
// 被拦截的类要增强的功能
.transform(new AgentBuilder.Transformer() {
// DynamicType.Builder是Byte Buddy中用于生成代码的一个重要的构建器
@Override
public DynamicType.Builder transform(DynamicType.Builder builder,
TypeDescription typeDescription,
ClassLoader classloader) {
// 拦截名称为toString的方法
return builder.method(ElementMatchers.named("toString"))
// 使用ToStringInterceptor拦截器增强toString方法的功能
.intercept(MethodDelegation.to(ToStringInterceptor.class));
}
}).installOn(instrumentation);
}
}
// 拦截器
public class ToStringInterceptor {
// RuntimeType是Byte Buddy中应用于拦截器的注解，被它注解的方法就是运行时拦截器要执行的目标方法
@RuntimeType
// Origin注解的就是被代理的目标方法，AllArguments注解的是被代理的目标方法的参数，SuperCall注解的是被代理方法的调用器
public static Object intercept(@Origin Method method, @AllArguments Object[] args, @SuperCall Callable<?> callable)
throws Exception {
System.out.println("被代理的方法执行前，执行了拦截器");
try {
// 执行被代理的方法
return callable.call();
} finally {
System.out.println("被代理的方法执行后，执行了拦截器");
}
}
}
这段代码，要使用java agent技术来应用到项目中。它实现的功能就是，拦截项目中被ToString注解的类中的toString()方法，拦截器可以拿到目标方法执行时的所有信息，包括方法的入参，并且在目标方法执行前后，执行一段额外的逻辑。
看这实现的功能是不是有点眼熟，这不就是Lombok中注解实现的功能么？
（2）skywalking插件执行原理
在1-2节中，我们跟源码跟到了AbstractMethodInterceptor类，继续从这个类入手。
// 这里省略了大量的代码，只保留了核心的部分
public abstract class AbstractMethodInterceptor implements InstanceMethodsAroundInterceptor {
@Override
public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
MethodInterceptResult result) throws Throwable {
// 这是在被切入的方法执行前，要执行的逻辑
}
@Override
public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
Object ret) throws Throwable {
// 这是在被切入的方法执行后，要执行的逻辑
}
}
① beforeMethod()方法在哪里调用的？
这里有好几个类都调用了beforeMethod()方法，这里我直接揭晓答案了，SpringMVC的拦截器走的是InstMethodsInter。下面那个带OverrideArgs的类，和1-2节中AbstractControllerInstrumentation类中构建拦截器切入点中的isOverrideArgs()方法应该有关，由于SpringMVC拦截器该方法返回的是false，因此不看这个类。
② 核心拦截器InstMethodsInter
public class InstMethodsInter {
private static final ILog LOGGER = LogManager.getLogger(InstMethodsInter.class);
private InstanceMethodsAroundInterceptor interceptor;
// 构造方法
public InstMethodsInter(String instanceMethodsAroundInterceptorClassName, ClassLoader classLoader) {
try {
// 使用类加载器加载拦截器到JVM中。这里要加载的原因是，插件拦截器都在独立的jar包，不在agent主程序里
interceptor = InterceptorInstanceLoader.load(instanceMethodsAroundInterceptorClassName, classLoader);
} catch (Throwable t) {
throw new PluginException("Can't create InstanceMethodsAroundInterceptor.", t);
}
}
// 拦截器的主方法，看到RuntimeType、AllArguments这些注解没，都是Byte Buddy里的
@RuntimeType
public Object intercept(@This Object obj, @AllArguments Object[] allArguments, @SuperCall Callable<?> zuper,
@Origin Method method) throws Throwable {
EnhancedInstance targetObject = (EnhancedInstance) obj;
MethodInterceptResult result = new MethodInterceptResult();
try {
// 拦截器在代理方法执行前执行beforeMethod方法
interceptor.beforeMethod(targetObject, method, allArguments, method.getParameterTypes(), result);
} catch (Throwable t) {
LOGGER.error(t, "class[{}] before method[{}] intercept failure", obj.getClass(), method.getName());
}
// 接收被代理的方法执行的结果
Object ret = null;
try {
if (!result.isContinue()) {
ret = result._ret();
} else {
// 执行被代理的方法
ret = zuper.call();
}
} catch (Throwable t) {
try {
// 拦截器捕获被代理的方法的异常
interceptor.handleMethodException(targetObject, method, allArguments, method.getParameterTypes(), t);
} catch (Throwable t2) {
LOGGER.error(t2, "class[{}] handle method[{}] exception failure", obj.getClass(), method.getName());
}
throw t;
} finally {
try {
// 拦截器在代理方法执行后执行afterMethod方法
ret = interceptor.afterMethod(targetObject, method, allArguments, method.getParameterTypes(), ret);
} catch (Throwable t) {
LOGGER.error(t, "class[{}] after method[{}] intercept failure", obj.getClass(), method.getName());
}
}
return ret;
}
}
看到@RuntimeType注解就松了一口气了，这就是Byte Buddy中拦截器的写法。
③ 核心拦截器在哪里用的？
直接点击InstMethodsInter类，看它在哪里用到了：
// 这里仅保留了核心代码
public abstract class ClassEnhancePluginDefine extends AbstractClassEnhancePluginDefine {
private static final ILog LOGGER = LogManager.getLogger(ClassEnhancePluginDefine.class);
// 增强类实例的核心方法
protected DynamicType.Builder<?> enhanceInstance(TypeDescription typeDescription,
DynamicType.Builder<?> newClassBuilder, ClassLoader classLoader,
EnhanceContext context) throws PluginException {
// 获取实例类方法拦截切入点
InstanceMethodsInterceptPoint[] instanceMethodsInterceptPoints = getInstanceMethodsInterceptPoints();
boolean existedMethodsInterceptPoints = false;
if (instanceMethodsInterceptPoints != null && instanceMethodsInterceptPoints.length > 0) {
existedMethodsInterceptPoints = true;
}
if (existedConstructorInterceptPoint) {
// 增强构造方法
}
if (existedMethodsInterceptPoints) {
// 增强实例类方法
for (InstanceMethodsInterceptPoint instanceMethodsInterceptPoint : instanceMethodsInterceptPoints) {
// 判断是否属于要拦截的目标方法的条件
ElementMatcher.Junction<MethodDescription> junction = not(isStatic())
// getMethodsMatcher()在上面1-2节也提到了
.and(instanceMethodsInterceptPoint.getMethodsMatcher());
// 这里就是Byte Buddy中构建方法拦截器的核心写法。
newClassBuilder = newClassBuilder.method(junction)
// 设置拦截器
.intercept(MethodDelegation.withDefaultConfiguration()
.to(new InstMethodsInter(interceptor, classLoader)));
}
}
return newClassBuilder;
}
}
这个类中可以看出，它将拦截器与被拦截的类编织到一起了。继续跟踪enhanceInstance()方法在哪里调用，一路找过去，最终到了Transformer类。
④ SkyWalkingAgent探针的入口
最终跟到了SkyWalkingAgent.Transformer类，看到这里，基本上就明白了：
public class SkyWalkingAgent {
private static ILog LOGGER = LogManager.getLogger(SkyWalkingAgent.class);
// Agent探针的入口
public static void premain(String agentArgs, Instrumentation instrumentation) throws PluginException {
// 加载插件
final PluginFinder pluginFinder = new PluginFinder(new PluginBootstrap().loadPlugins());
// Byte Buddy的构建器
AgentBuilder agentBuilder = new AgentBuilder...;
// type()判断是否需要由插件拦截
agentBuilder.type(pluginFinder.buildMatch())
// 这里就是设置拦截器
.transform(new Transformer(pluginFinder))
.with(AgentBuilder.RedefinitionStrategy.RETRANSFORMATION)
.with(new RedefinitionListener())
.with(new Listener())
.installOn(instrumentation);
}
// Byte Buddy的拦截器
private static class Transformer implements AgentBuilder.Transformer {
@Override
public DynamicType.Builder<?> transform(final DynamicType.Builder<?> builder,
final TypeDescription typeDescription,
final ClassLoader classLoader,
final JavaModule module) {
LoadedLibraryCollector.registerURLClassLoader(classLoader);
// 取出插件
List<AbstractClassEnhancePluginDefine> pluginDefines = pluginFinder.find(typeDescription);
if (pluginDefines.size() > 0) {
// Byte Buddy中用于生成代码的一个重要的构建器
DynamicType.Builder<?> newBuilder = builder;
EnhanceContext context = new EnhanceContext();
// 遍历插件
for (AbstractClassEnhancePluginDefine define : pluginDefines) {
// 在这里加载插件中的拦截器，最终调用了上面提到的ClassEnhancePluginDefine.enhanceInstance()方法
DynamicType.Builder<?> possibleNewBuilder = define.define(
typeDescription, newBuilder, classLoader, context);
if (possibleNewBuilder != null) {
newBuilder = possibleNewBuilder;
}
}
return newBuilder;
}
return builder;
}
}
}
在skywalking探针的入口方法中，就已经加载了所有插件的拦截器，并将拦截器和需要拦截的方法关联到了一起，剩下的功能，就交给Byte Buddy了。
（3）小结
看到这里，skywalking探针工作的原理，就已经清楚了。skywalking是利用了java agent和Byte Buddy两项技术，来实现无侵入式的拦截。如果不了解这两项技术，直接看源码会一脸懵B。
