public native String intern();

public native String enhance_intern();

public String intern(){
  enhance_intern();
}

public class Premain {
    // premain 方法，在 Java 代理的预初始化阶段被调用
    public static void premain(String args, Instrumentation inst) {
        // 调用 recoverMain 方法进行相关操作
        recoverMain(inst);
    }

    // agentmain 方法，在 Java 代理的启动阶段被调用
    public static void agentmain(String args, Instrumentation inst) {
        // 调用 recoverMain 方法进行相关操作
        recoverMain(inst);
    }

    // recoverMain 方法，用于执行恢复主流程的操作
    public static void recoverMain(Instrumentation inst) {
        // 输出 inst 是否支持本地方法前缀
        System.out.println(inst.isNativeMethodPrefixSupported());
        // 创建 NativeWrappingClassFileTransformer 类的对象
        NativeWrappingClassFileTransformer transformer = new NativeWrappingClassFileTransformer();
        // 向 inst 添加转换器，并设置为可以重转换
        inst.addTransformer(transformer,true);
        // 为 inst 设置本地方法前缀
        inst.setNativeMethodPrefix(transformer, NativeWrappingClassFileTransformer.PREFIX);
    }
}

class NativeWrappingClassFileTransformer implements ClassFileTransformer {

    // 定义一个表示 BlockHound 运行时类型的 Type 对象
    static final Type BLOCK_HOUND_RUNTIME_TYPE = Type.getType("Lreactor/blockhound/BlockHoundRuntime;");
    // 定义本地方法的前缀字符串
    static final String PREFIX = "$$BlockHound$$_";

    // 构造函数
    NativeWrappingClassFileTransformer() {
    }

    /**
     * 实现 ClassFileTransformer 接口的 transform 方法
     *
     * @param loader          类加载器
     * @param className       类名
     * @param classBeingRedefined 正在被重定义的类
     * @param protectionDomain 保护域
     * @param classfileBuffer 类文件缓冲区
     * @return 转换后的字节数组，如果不进行转换则返回 null
     */
    @Override
    public byte[] transform(
            ClassLoader loader,
            String className,
            Class<?> classBeingRedefined,
            ProtectionDomain protectionDomain,
            byte[] classfileBuffer
    ) {
//        if (!className.startsWith("java/net/")) {
//            return null;
//        }

        // 创建 ClassReader 对象来读取类文件缓冲区
        ClassReader cr = new ClassReader(classfileBuffer);
        // 创建 ClassWriter 对象用于写入转换后的类
        ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_MAXS);

        try {
            // 接受 NativeWrappingClassVisitor 进行类的访问和转换
            cr.accept(new NativeWrappingClassVisitor(cw, className), 0);

            // 获取转换后的字节数组
            classfileBuffer = cw.toByteArray();
        } catch (Throwable e) {
            // 打印异常堆栈跟踪
            e.printStackTrace();
            // 抛出异常
            throw e;
        }

        // 返回转换后的类文件字节数组
        return classfileBuffer;
    }

    // 内部静态类 NativeWrappingClassVisitor，继承自 ClassVisitor
    static class NativeWrappingClassVisitor extends ClassVisitor {

        // 存储类名
        private final String className;

        // 构造函数
        NativeWrappingClassVisitor(ClassVisitor cw, String internalClassName) {
            // 调用父类构造函数
            super(ASM7, cw);
            // 初始化类名
            this.className = internalClassName;
        }

        /**
         * 重写 visitMethod 方法，处理方法访问
         *
         * @param access          方法的访问标志
         * @param name            方法名
         * @param descriptor      方法描述符
         * @param signature       方法签名
         * @param exceptions      方法抛出的异常
         * @return 方法访问器
         */
        @Override
        public MethodVisitor visitMethod(int access,
                                         String name,
                                         String descriptor,
                                         String signature,
                                         String[] exceptions) {
            // 如果方法不是本地方法
            if ((access & ACC_NATIVE) == 0) {
                // 调用父类的 visitMethod 方法
                return super.visitMethod(access, name, descriptor, signature, exceptions);
            }

            // 访问修改后的本地方法
            super.visitMethod(
                    ACC_NATIVE | ACC_PRIVATE | ACC_FINAL | (access & ACC_STATIC),
                    PREFIX + name,
                    descriptor,
                    signature,
                    exceptions
            );

            // 访问原始的非本地方法
            MethodVisitor delegatingMethodVisitor = super.visitMethod(
                    access & ~ACC_NATIVE, name, descriptor, signature, exceptions);
            delegatingMethodVisitor.visitCode();

            // 返回自定义的方法访问器
            return new MethodVisitor(ASM7, delegatingMethodVisitor) {

                @Override
                public void visitEnd() {

                    // 添加打印语句打印方法名
                    visitFieldInsn(GETSTATIC, "java/lang/System", "out", "Ljava/io/PrintStream;");
                    visitLdcInsn("Method called: " + className + "." + name);
                    visitMethodInsn(INVOKEVIRTUAL, "java/io/PrintStream", "println", "(Ljava/lang/String;)V", false);


                    Type returnType = Type.getReturnType(descriptor);
                    Type[] argumentTypes = Type.getArgumentTypes(descriptor);
                    boolean isStatic = (access & ACC_STATIC)!= 0;
                    if (!isStatic) {
                        visitVarInsn(ALOAD, 0);
                    }
                    int index = isStatic? 0 : 1;
                    for (Type argumentType : argumentTypes) {
                        visitVarInsn(argumentType.getOpcode(ILOAD), index);
                        index += argumentType.getSize();
                    }

                    visitMethodInsn(
                            isStatic? INVOKESTATIC : INVOKESPECIAL,
                            className,
                            PREFIX + name,
                            descriptor,
                            false
                    );

                    visitInsn(returnType.getOpcode(IRETURN));
                    visitMaxs(0, 0);
                    super.visitEnd();
                }
            };
        }

    }
}

@Trace
public User methodYouWantToTrace(String param1, String param2) {
    // ActiveSpan.setOperationName("Customize your own operation name, if this is an entry span, this would be an endpoint name");
    // ...
}

public static AbstractSpan createEntrySpan(String endpointName, ContextCarrier carrier)
public static AbstractSpan createLocalSpan(String endpointName)
public static AbstractSpan createExitSpan(String endpointName, ContextCarrier carrier, String remotePeer)

public class Main {
    public static void main(String[] args) {
        AbstractSpan mySpan = ContextManager.createEntrySpan("mySpan");
        Runnable runnable = () -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            // 3. Propagate the span to any other thread.
            // 4. Once the above steps are all set, call #asyncFinish in any thread.
            mySpan.asyncFinish();


        };
        // 1. Call #prepareForAsync in the original context.
        mySpan.prepareForAsync();
        new Thread(runnable).start();
        // 2. Run ContextManager#stopSpan in the original context when your job in the current thread is complete.
        ContextManager.stopSpan();
    }
}

public class Main2 {

    public static void main(String[] args) {
        AbstractSpan mySpan = ContextManager.createExitSpan("parent", "childThread");

        Runnable runnable = () -> {
            try {
                TimeUnit.SECONDS.sleep(1);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        };
        new Thread(new RunnableWrapper(runnable)).start();
        ContextManager.stopSpan(mySpan);
    }

    static class RunnableWrapper implements Runnable, EnhancedInstance {

        private Object skyWalkingDynamicField;
        private Runnable runnable;

        public RunnableWrapper(Runnable runnable) {
            if (ContextManager.isActive()) {
                setSkyWalkingDynamicField(ContextManager.capture());
            }
            this.runnable = runnable;
        }

        @Override
        public void run() {
            AbstractSpan span = ContextManager.createLocalSpan("runnable.run");
            span.setComponent(ComponentsDefine.JDK_THREADING);

            final Object storedField = getSkyWalkingDynamicField();
            if (storedField != null) {
                final ContextSnapshot contextSnapshot = (ContextSnapshot) storedField;
                ContextManager.continued(contextSnapshot);
            }
            try {
                runnable.run();
            } finally {
                ContextManager.stopSpan();
            }
        }

        @Override
        public Object getSkyWalkingDynamicField() {
            return skyWalkingDynamicField;
        }

        @Override
        public void setSkyWalkingDynamicField(Object value) {
            this.skyWalkingDynamicField = value;
        }
    }

}

@Override
public ContextSnapshot capture() {
    ContextSnapshot snapshot = new ContextSnapshot(
        segment.getTraceSegmentId(),  // segmentId
        activeSpan().getSpanId(),     // spanId
        getPrimaryTraceId(),          // traceId
        primaryEndpoint.getName(),    // parentEndpoint
        this.correlationContext,     
        this.extensionContext
    );
    return snapshot;
}

/**
 * Continue the context from the given snapshot of parent thread.
 *
 * @param snapshot from {@link #capture()} in the parent thread. Ref to {@link AbstractTracerContext#continued(ContextSnapshot)}
 */
@Override
public void continued(ContextSnapshot snapshot) {
    if (snapshot.isValid()) {
        TraceSegmentRef segmentRef = new TraceSegmentRef(snapshot);
        this.segment.ref(segmentRef);
        this.activeSpan().ref(segmentRef);
        this.segment.relatedGlobalTrace(snapshot.getTraceId());
        this.correlationContext.continued(snapshot);
        this.extensionContext.continued(snapshot);
        this.extensionContext.handle(this.activeSpan());
    }
}

class MemoryDatabase {
  public List<String> load(String info) {
    return Arrays.asList(info + ": foo", info + ": bar");
  }
}

class LoggerInterceptor {
  public static List<String> log(@SuperCall Callable<List<String>> zuper) // SuperCall 注解用于表示 zuper 是原始方法的调用.
      throws Exception {
    System.out.println("Calling database");
    try {
      return zuper.call();
    } finally {
      System.out.println("Returned from database");
    }
  }
}

MemoryDatabase loggingDatabase = new ByteBuddy()
  .subclass(MemoryDatabase.class) // 被增强的类继承于 MemoryDatabase 类
  .method(named("load")) // 被增强的方法名为 load
  .intercept(MethodDelegation.to(LoggerInterceptor.class)) // 增强方式是将方法调用代理到 LoggerInterceptor
  .make() // 构造出上述配置产生的类的字节码
  .load(getClass().getClassLoader()) // 将上述配置产生的类用过 getClass().getClassLoader() 加载到 jvm 中
  .getLoaded() // 获取已经加载的 Class 类对象
  .newInstance(); // 通过默认构造函数构造新的对象.

public class SofaRpcConsumerInstrumentation extends ClassInstanceMethodsEnhancePluginDefine {

    private static final String ENHANCE_CLASS = "com.alipay.sofa.rpc.filter.ConsumerInvoker";
    private static final String INTERCEPT_CLASS = "org.apache.skywalking.apm.plugin.sofarpc.SofaRpcConsumerInterceptor";

    @Override
    protected ClassMatch enhanceClass() {
        return NameMatch.byName(ENHANCE_CLASS);
    }

    @Override
    public ConstructorInterceptPoint[] getConstructorsInterceptPoints() {
        return null;
    }

    @Override
    public InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() {
        return new InstanceMethodsInterceptPoint[] {
            new InstanceMethodsInterceptPoint() {
                @Override
                public ElementMatcher<MethodDescription> getMethodsMatcher() {
                    return named("invoke");
                }

                @Override
                public String getMethodsInterceptor() {
                    return INTERCEPT_CLASS;
                }

                @Override
                public boolean isOverrideArgs() {
                    return false;
                }
            }
        };
    }
}

public class SofaRpcConsumerInterceptor implements InstanceMethodsAroundInterceptor {

    public static final String SKYWALKING_PREFIX = "skywalking.";

    @Override
    public void beforeMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
                             MethodInterceptResult result) throws Throwable {
        // 省略一些代码
        final ContextCarrier contextCarrier = new ContextCarrier();
        final String operationName = generateOperationName(providerInfo, sofaRequest);
        AbstractSpan span = ContextManager.createExitSpan(operationName, contextCarrier, host + ":" + port);
        span.setComponent(ComponentsDefine.SOFARPC);
        SpanLayer.asRPCFramework(span);
    }

    @Override
    public Object afterMethod(EnhancedInstance objInst, Method method, Object[] allArguments, Class<?>[] argumentsTypes,
                              Object ret) throws Throwable {
        SofaResponse result = (SofaResponse) ret;
        if (result != null && result.isError()) {
            dealException((Throwable) result.getAppResponse());
        }

        ContextManager.stopSpan();
        return ret;
    }

    @Override
    public void handleMethodException(EnhancedInstance objInst, Method method, Object[] allArguments,
                                      Class<?>[] argumentsTypes, Throwable t) {
        dealException(t);
    }
}

public class InstMethodsInter {
    private static final ILog LOGGER = LogManager.getLogger(InstMethodsInter.class);

    /**
     * An {@link InstanceMethodsAroundInterceptor} This name should only stay in {@link String}, the real {@link Class}
     * type will trigger classloader failure. If you want to know more, please check on books about Classloader or
     * Classloader appointment mechanism.
     */
    private InstanceMethodsAroundInterceptor interceptor;

    /**
     * @param instanceMethodsAroundInterceptorClassName class full name.
     */
    public InstMethodsInter(String instanceMethodsAroundInterceptorClassName, ClassLoader classLoader) {
        try {
            interceptor = InterceptorInstanceLoader.load(instanceMethodsAroundInterceptorClassName, classLoader);
        } catch (Throwable t) {
            throw new PluginException("Can't create InstanceMethodsAroundInterceptor.", t);
        }
    }

    /**
     * Intercept the target instance method.
     *
     * @param obj          target class instance.
     * @param allArguments all method arguments
     * @param method       method description.
     * @param zuper        the origin call ref.
     * @return the return value of target instance method.
     * @throws Exception only throw exception because of zuper.call() or unexpected exception in sky-walking ( This is a
     *                   bug, if anything triggers this condition ).
     */
    @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();
            }
        } 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 EchoA {
    public String echo() {
        return "A";
    }
}

public static void main(String[] args) throws Exception {
    // 使用 ByteBuddy 开始构造一个类
    DynamicType.Unloaded<EchoA> newClass = new ByteBuddy()
            .subclass(EchoA.class) // 新的类继承于 EchoA
            .method(ElementMatchers.named("echo")) // 对方法 echo 做增强
            .intercept(FixedValue.value("B")) // 增强内容是返回一个固定值 "B"
            .make(); // 构造这个 class

    Class<?> dynamicType = newClass
            .load(EchoA.class.getClassLoader()) // 使用 EchoA 的类加载器加载这个类
            .getLoaded(); // 获取被加载的类
    EchoA echoA = (EchoA) dynamicType.getDeclaredConstructor().newInstance(); // 使用反射调用构造函数, 构造新的类的实例
    System.out.println(echoA.getClass().getName()); // 打印新类类名
    System.out.println(echoA.echo()); // 调用 echo 方法并打印结果
}

DynamicType.Unloaded<EchoA> newClass = new ByteBuddy()
        .subclass(EchoA.class) // 新的类继承于 EchoA
        .method(ElementMatchers.named("echo")) // 对方法名为 echo 做增强
        .intercept(FixedValue.value("B")) // 增强内容是返回一个固定值 "B"
        .make(); // 构造这个 class

public DynamicType.Unloaded<U> make(TypeResolutionStrategy typeResolutionStrategy, TypePool typePool) {
  return toTypeWriter(typePool).make(typeResolutionStrategy.resolve());
}

protected TypeWriter<T> toTypeWriter(TypePool typePool) {
    MethodRegistry.Compiled methodRegistry = constructorStrategy   // constructorStrategy 规定了如何构造新类的构造函数, ByteBuddy 遵循约定优于配置的原则, constructorStrategy 有一个默认值,这里我们不展开讨论.
            .inject(instrumentedType, this.methodRegistry) // inject 将构造函数如何构造的 handler 插入 methodRegistry,并返回这个 methodRegistry
            .prepare(applyConstructorStrategy(instrumentedType), // prepare 方法会会根据配置 (也就是上文 method 和 intercept 方法), 将改造 echo 方法的 handler 加入 methodRegistry.
            // 具体操作是: 在需要被怎强的类 EchoA 中, 通过 过滤器(ElementMatchers.named("echo")) 找到需要被增强的
            方法 echo , 然后将这个方法和这个方法如何被增强 (返回固定值 value FixedValue.value("B")) 插入到 methodRegistry
                    methodGraphCompiler,
                    typeValidation,
                    visibilityBridgeStrategy,
                    new InstrumentableMatcher(ignoredMethods))
            .compile(SubclassImplementationTarget.Factory.SUPER_CLASS, classFileVersion); // compile 方法会将对应的 handler 对应的 ByteCodeAppender 和 MethodAttributeAppender 和方法对应起来,并缓存起来.

            // 最后将准备好的对象组织成 TypeWriter 返回
    return TypeWriter.Default.<T>forCreation(methodRegistry,
            auxiliaryTypes,
            fieldRegistry.compile(methodRegistry.getInstrumentedType()),
            recordComponentRegistry.compile(methodRegistry.getInstrumentedType()),
            typeAttributeAppender,
            asmVisitorWrapper,
            classFileVersion,
            annotationValueFilterFactory,
            annotationRetention,
            auxiliaryTypeNamingStrategy,
            implementationContextFactory,
            typeValidation,
            classWriterStrategy,
            typePool);
}

// WARNING: the native code knows the name & signature of this method
private void
loadClassAndCallPremain(    String  classname,
                            String  optionsString)
        throws Throwable {

    loadClassAndStartAgent( classname, "premain", optionsString );
}


// WARNING: the native code knows the name & signature of this method
private void
loadClassAndCallAgentmain(  String  classname,
                            String  optionsString)
        throws Throwable {

    loadClassAndStartAgent( classname, "agentmain", optionsString );
}