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

- 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);
    }
}