一文看懂分布式链路监控系统

- 0  - 0.1    - 0.1.1    - 0.1.2      - 0.1.2.1  - 0.2    - 0.2.1  - 0.3    - 0.3.1      - 0.3.1.1    - 0.3.2

java -javaagent:/path/agent.jar=key1=value1,key2=value2 -jar myJar.jar

mv.visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");mv.visitLdcInsn("begin of sayhello().");mv.visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);

public interface InstanceMethodsAroundInterceptor {    // 方法执行前置扩展点    void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,                      MethodInterceptResult result) throws Throwable;
    // 方法执行后置扩展点    Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,                       Object ret) throws Throwable;
    // 方法抛出异常时扩展点    void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments,                               Class<?>[] argumentsTypes, Throwable t);}

private static class Transformer implements AgentBuilder.Transformer {  private PluginFinder pluginFinder;
  Transformer(PluginFinder pluginFinder) {    this.pluginFinder = pluginFinder;  }
  /**   * 这个方法在类加载的过程中会由JVM调用（Byte Buddy做了封装）   * @param builder       原始类的字节码构建器   * @param typeDescription  类描述信息   * @param classLoader      这个类的类加载器    * @param module         jdk9中模块信息    * @return           修改后的类的字节码构建器     */  @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) {      DynamicType.Builder<?> newBuilder = builder;      EnhanceContext context = new EnhanceContext();      for (AbstractClassEnhancePluginDefine define : pluginDefines) {        // 调用插件的define方法得到新的字节码        DynamicType.Builder<?> possibleNewBuilder = define.define(          typeDescription, newBuilder, classLoader, context);        if (possibleNewBuilder != null) {          newBuilder = possibleNewBuilder;        }      }      // 返回增强后的字节码给JVM，完成字节码增强      return newBuilder;    }    return builder;  }}

public abstract class AbstractClassEnhancePluginDefine {  public DynamicType.Builder<?> define(TypeDescription typeDescription, DynamicType.Builder<?> builder,                     ClassLoader classLoader, EnhanceContext context) throws PluginException {    // witness机制    WitnessFinder finder = WitnessFinder.INSTANCE;
    //通过类加载器找witness类，没有就直接返回，不进行字节码的改造    String[] witnessClasses = witnessClasses();    if (witnessClasses != null) {      for (String witnessClass : witnessClasses) {        if (!finder.exist(witnessClass, classLoader)) {          return null;        }      }    }
    //通过类加载器找witness方法，没有就直接返回，不进行字节码的改造    List<WitnessMethod> witnessMethods = witnessMethods();    if (!CollectionUtil.isEmpty(witnessMethods)) {      for (WitnessMethod witnessMethod : witnessMethods) {        if (!finder.exist(witnessMethod, classLoader)) {          return null;        }      }    }
    // enhance开始修改字节码    DynamicType.Builder<?> newClassBuilder = this.enhance(typeDescription, builder, classLoader, context);
    // 修改完成，返回新的字节码    context.initializationStageCompleted();    return newClassBuilder;  }
  protected DynamicType.Builder<?> enhance(TypeDescription typeDescription, DynamicType.Builder<?> newClassBuilder,                       ClassLoader classLoader, EnhanceContext context) throws PluginException {    // 增强静态方法    newClassBuilder = this.enhanceClass(typeDescription, newClassBuilder, classLoader);    // 增强实例方法& 构造方法    newClassBuilder = this.enhanceInstance(typeDescription, newClassBuilder, classLoader, context);    return newClassBuilder;  }}       

public abstract class ClassEnhancePluginDefine extends AbstractClassEnhancePluginDefine {  protected DynamicType.Builder<?> enhanceInstance(TypeDescription typeDescription,                           DynamicType.Builder<?> newClassBuilder, ClassLoader classLoader,                           EnhanceContext context) throws PluginException {    // 获取插件定义的构造方法拦截点ConstructorInterceptPoint    ConstructorInterceptPoint[] constructorInterceptPoints = getConstructorsInterceptPoints();    // 获取插件定义的实例方法拦截点InstanceMethodsInterceptPoint    InstanceMethodsInterceptPoint[] instanceMethodsInterceptPoints = getInstanceMethodsInterceptPoints();    String enhanceOriginClassName = typeDescription.getTypeName();    // 非空校验    boolean existedConstructorInterceptPoint = false;    if (constructorInterceptPoints != null && constructorInterceptPoints.length > 0) {      existedConstructorInterceptPoint = true;    }    boolean existedMethodsInterceptPoints = false;    if (instanceMethodsInterceptPoints != null && instanceMethodsInterceptPoints.length > 0) {      existedMethodsInterceptPoints = true;    }    if (!existedConstructorInterceptPoint && !existedMethodsInterceptPoints) {      return newClassBuilder;    }
    // 这里就是之前提到的让类实现EnhancedInstance接口，并添加_$EnhancedClassField_ws字段    if (!typeDescription.isAssignableTo(EnhancedInstance.class)) {      if (!context.isObjectExtended()) {        // Object类型、private volatie修饰符、提供方法进行访问        newClassBuilder = newClassBuilder.defineField(          "_$EnhancedClassField_ws", Object.class, ACC_PRIVATE | ACC_VOLATILE)          .implement(EnhancedInstance.class)          .intercept(FieldAccessor.ofField("_$EnhancedClassField_ws"));        context.extendObjectCompleted();      }    }
    // 构造方法增强    if (existedConstructorInterceptPoint) {      for (ConstructorInterceptPoint constructorInterceptPoint : constructorInterceptPoints) {        // jdk核心类        if (isBootstrapInstrumentation()) {          newClassBuilder = newClassBuilder.constructor(constructorInterceptPoint.getConstructorMatcher())            .intercept(SuperMethodCall.INSTANCE.andThen(MethodDelegation.withDefaultConfiguration()                                  .to(BootstrapInstrumentBoost                                  .forInternalDelegateClass(constructorInterceptPoint                                                // 非jdk核心类                                                                                                         .getConstructorInterceptor()))));             } else {          // 找到对应的构造方法，并通过插件自定义的InstanceConstructorInterceptor进行增强          newClassBuilder = newClassBuilder.constructor(constructorInterceptPoint.getConstructorMatcher())            .intercept(SuperMethodCall.INSTANCE.andThen(MethodDelegation.withDefaultConfiguration()                                  .to(new ConstructorInter(constructorInterceptPoint                                               .getConstructorInterceptor(), classLoader))));        }      }    }
    // 实例方法增强    if (existedMethodsInterceptPoints) {      for (InstanceMethodsInterceptPoint instanceMethodsInterceptPoint : instanceMethodsInterceptPoints) {        // 找到插件自定义的实例方法拦截器InstanceMethodsAroundInterceptor        String interceptor = instanceMethodsInterceptPoint.getMethodsInterceptor();        // 这里在插件自定义的匹配条件上加了一个【不为静态方法】的条件        ElementMatcher.Junction<MethodDescription> junction = not(isStatic()).and(instanceMethodsInterceptPoint.getMethodsMatcher());
        // 需要重写入参        if (instanceMethodsInterceptPoint.isOverrideArgs()) {          // jdk核心类          if (isBootstrapInstrumentation()) {            newClassBuilder = newClassBuilder.method(junction)              .intercept(MethodDelegation.withDefaultConfiguration()                     .withBinders(Morph.Binder.install(OverrideCallable.class))                     .to(BootstrapInstrumentBoost.forInternalDelegateClass(interceptor)));            // 非jdk核心类           } else {              newClassBuilder = newClassBuilder.method(junction)                .intercept(MethodDelegation.withDefaultConfiguration()                       .withBinders(Morph.Binder.install(OverrideCallable.class))                       .to(new InstMethodsInterWithOverrideArgs(interceptor, classLoader)));          }        // 不需要重写入参        } else {          // jdk核心类              if (isBootstrapInstrumentation()) {              newClassBuilder = newClassBuilder.method(junction)                .intercept(MethodDelegation.withDefaultConfiguration()                       .to(BootstrapInstrumentBoost.forInternalDelegateClass(interceptor)));          // 非jdk核心类                                                                             } else {            // 找到对应的实例方法，并通过插件自定义的InstanceMethodsAroundInterceptor进行增强            newClassBuilder = newClassBuilder.method(junction)                .intercept(MethodDelegation.withDefaultConfiguration()                       .to(new InstMethodsInter(interceptor, classLoader)));          }        }      }    }
    return newClassBuilder;  }}        

public class InstMethodsInter {    private static final ILog LOGGER = LogManager.getLogger(InstMethodsInter.class);
    // 用户在插件中定义的实例方法拦截器    private InstanceMethodsAroundInterceptor interceptor;
    public InstMethodsInter(String instanceMethodsAroundInterceptorClassName, ClassLoader classLoader) {        try {            // 加载用户在插件中定义的实例方法拦截器            interceptor = InterceptorInstanceLoader.load(instanceMethodsAroundInterceptorClassName, classLoader);        } catch (Throwable t) {            throw new PluginException("Can't create InstanceMethodsAroundInterceptor.", t);        }    }
    /**     * 当执行被增强方法时，会执行该intercept方法     *     * @param obj          实例对象（this）     * @param allArguments 方法入参     * @param method       参数描述     * @param zuper        原方法调用的句柄    *  @param method       被增强后的方法的引用      * @return             方法返回值     */    @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 {            // 拦截器前置逻辑            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();                // 为什么不能走method.invoke？因为method已经是被增强后方法，调用就死循环了！                // 可以回到之前的字节码文件查看原因，看一下该intercept执行的时机            }        } 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 {                // 拦截器后置逻辑                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;    }}

// 提供原子下标的类public class AtomicRangeInteger {    // JDK提供的原子数组    private AtomicIntegerArray values;
    // 固定值15    private static final int VALUE_OFFSET = 15;
    // 数组开始下标，固定为0    private int startValue;
    // 数组最后一个元素的下标，固定为数组的最大长度-1    private int endValue;
    public AtomicRangeInteger(int startValue, int maxValue) {        // 创建一个长度为31的原子数组        this.values = new AtomicIntegerArray(31);        // 将第15位设置为初始值0        this.values.set(VALUE_OFFSET, startValue);        this.startValue = startValue;        this.endValue = maxValue - 1;    }
    // 核心方法，获取数组的下一个下标    public final int getAndIncrement() {        int next;        do {            // 原子递增            next = this.values.incrementAndGet(VALUE_OFFSET);            // 如果超过了数组范围，CAS重制到0            if (next > endValue && this.values.compareAndSet(VALUE_OFFSET, next, startValue)) {                return endValue;            }        } while (next > endValue);        return next - 1;    }}

public class AtomicRangeInteger {
    private AtomicInteger value;    private int startValue;    private int endValue;
    public AtomicRangeInteger(int startValue, int maxValue) {        this.value = new AtomicInteger(startValue);        this.startValue = startValue;        this.endValue = maxValue - 1;    }
    public final int getAndIncrement() {        int current;        int next;        do {            // 获取当前下标            current = this.value.get();            // 如果超过最大范围则从0开始            next = current >= this.endValue ? this.startValue : current + 1;            // CAS更新下标，失败则循环重试        } while (!this.value.compareAndSet(current, next));
        return current;    }}    

public class AtomicRangeInteger extends Number implements Serializable {    // 用原子整型替代V1版本的原子数组    private AtomicInteger value;    private int startValue;    private int endValue;
    public AtomicRangeInteger(int startValue, int maxValue) {        this.value = new AtomicInteger(startValue);        this.startValue = startValue;        this.endValue = maxValue - 1;    }
    public final int getAndIncrement() {        int next;        do {            next = this.value.incrementAndGet();            if (next > endValue && this.value.compareAndSet(next, startValue)) {                return endValue;            }        }        while (next > endValue);        return next - 1;    }}

public class AtomicRangeInteger {
    private AtomicLong value;    private int mask;
    public AtomicRangeInteger(int startValue, int maxValue) {        this.value = new AtomicLong(startValue);        this.mask = maxValue - 1;    }
    public final int getAndIncrement() {        return (int)(value.incrementAndGet() % mask);    }}