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

publicinterfaceInstanceMethodsAroundInterceptor {
// 方法执行前置扩展点voidbeforeMethod(EnhancedInstanceobjInst, Methodmethod, Object[] allArguments, Class<?>[] argumentsTypes,
MethodInterceptResultresult) throwsThrowable;
// 方法执行后置扩展点ObjectafterMethod(EnhancedInstanceobjInst, Methodmethod, Object[] allArguments, Class<?>[] argumentsTypes,
Objectret) throwsThrowable;
// 方法抛出异常时扩展点voidhandleMethodException(EnhancedInstanceobjInst, Methodmethod, Object[] allArguments,
Class<?>[] argumentsTypes, Throwablet);
}

publicstaticvoidpremain(StringagentArgs, Instrumentationinstrumentation) throwsPluginException {
// 1. 加载所有的Skywalking插件 // 插件实现了Skywalking接口规范，包括需要增强哪个类、需要怎么增强这两个要素finalPluginFinder=newPluginFinder(newPluginBootstrap().loadPlugins());
// 2. 构建ByteBuddy// ByteBuddy提供了流式的API来指定ByteBuddy类库的行为（用于各种配置）finalByteBuddybyteBuddy=newByteBuddy().with(TypeValidation.of(Config.Agent.IS_OPEN_DEBUGGING_CLASS));
// 3. 构建AgentBuilder实例，需要忽略的类AgentBuilderagentBuilder=newAgentBuilder.Default(byteBuddy).ignore(
nameStartsWith("net.bytebuddy.")
        .or(nameStartsWith("org.slf4j."))
        .or(nameStartsWith("org.groovy."))
        .or(nameContains("javassist"))
        .or(nameContains(".asm."))
        .or(nameContains(".reflectasm."))
        .or(nameStartsWith("sun.reflect"))
        .or(nameStartsWith("org.apache.skywalking.")
            .and(not(nameStartsWith("org.apache.skywalking.apm.toolkit."))))
// 忽略Java中的【Synthetic】// Synthetic指所有存在于字节码文件中，但是不存在于源代码中的【构造】，即JVM帮我们生产的东西// 比如内部类指向外部类实例的this$0字段；外部类访问内部类的私有变量时JDK帮我们生产的方法等等// JDK11后引入了NBAC机制，引入了新的嵌套类组织方式，不再生成Synthetic方法        .or(ElementMatchers.isSynthetic()));
// 4. 处理JDK9的module特性，解决跨模块类访问的问题// 5. 将AgentBuilder插桩在Instrumentation上agentBuilder// 根据插件的内容构建需要增强类的匹配器        .type(pluginFinder.buildMatch())
// Transformer就是字节码增强逻辑的主要入口        .transform(newTransformer(pluginFinder))
// Retransform模式：保留被修改的字节码// Redifine模式：覆盖被修改的字节码        .with(AgentBuilder.RedefinitionStrategy.RETRANSFORMATION)
// 一些监听器        .with(newRedefinitionListener())
        .with(newListener())
// 将AgentBuilder插桩在JVM提供的Instrumentation上        .installOn(instrumentation);
}

privatestaticclassTransformerimplementsAgentBuilder.Transformer {
privatePluginFinderpluginFinder;
Transformer(PluginFinderpluginFinder) {
this.pluginFinder=pluginFinder;
    }
/*** 这个方法在类加载的过程中会由JVM调用（Byte Buddy做了封装）* @param builder          原始类的字节码构建器* @param typeDescription  类描述信息* @param classLoader      这个类的类加载器* @param module           jdk9中模块信息* @return                 修改后的类的字节码构建器*/@OverridepublicDynamicType.Builder<?>transform(finalDynamicType.Builder<?>builder,
finalTypeDescriptiontypeDescription,
finalClassLoaderclassLoader,
finalJavaModulemodule) {
LoadedLibraryCollector.registerURLClassLoader(classLoader);
// 根据类信息找到针对这个类进行字节码增强的插件，可能有多个List<AbstractClassEnhancePluginDefine>pluginDefines=pluginFinder.find(typeDescription);
if (pluginDefines.size() >0) {
DynamicType.Builder<?>newBuilder=builder;
EnhanceContextcontext=newEnhanceContext();
for (AbstractClassEnhancePluginDefinedefine : pluginDefines) {
// 调用插件的define方法得到新的字节码DynamicType.Builder<?>possibleNewBuilder=define.define(
typeDescription, newBuilder, classLoader, context);
if (possibleNewBuilder!=null) {
newBuilder=possibleNewBuilder;
                }
            }
// 返回增强后的字节码给JVM，完成字节码增强returnnewBuilder;
        }
returnbuilder;
    }
}

publicabstractclassAbstractClassEnhancePluginDefine {
publicDynamicType.Builder<?>define(TypeDescriptiontypeDescription, DynamicType.Builder<?>builder,
ClassLoaderclassLoader, EnhanceContextcontext) throwsPluginException {
// witness机制WitnessFinderfinder=WitnessFinder.INSTANCE;
//通过类加载器找witness类，没有就直接返回，不进行字节码的改造String[] witnessClasses=witnessClasses();
if (witnessClasses!=null) {
for (StringwitnessClass : witnessClasses) {
if (!finder.exist(witnessClass, classLoader)) {
returnnull;
                }
            }
        }
//通过类加载器找witness方法，没有就直接返回，不进行字节码的改造List<WitnessMethod>witnessMethods=witnessMethods();
if (!CollectionUtil.isEmpty(witnessMethods)) {
for (WitnessMethodwitnessMethod : witnessMethods) {
if (!finder.exist(witnessMethod, classLoader)) {
returnnull;
                }
            }
        }
// enhance开始修改字节码DynamicType.Builder<?>newClassBuilder=this.enhance(typeDescription, builder, classLoader, context);
// 修改完成，返回新的字节码context.initializationStageCompleted();
returnnewClassBuilder;
    }
protectedDynamicType.Builder<?>enhance(TypeDescriptiontypeDescription, DynamicType.Builder<?>newClassBuilder,
ClassLoaderclassLoader, EnhanceContextcontext) throwsPluginException {
// 增强静态方法newClassBuilder=this.enhanceClass(typeDescription, newClassBuilder, classLoader);
// 增强实例方法& 构造方法newClassBuilder=this.enhanceInstance(typeDescription, newClassBuilder, classLoader, context);
returnnewClassBuilder;
    }
}       

publicabstractclassClassEnhancePluginDefineextendsAbstractClassEnhancePluginDefine {
protectedDynamicType.Builder<?>enhanceInstance(TypeDescriptiontypeDescription,
DynamicType.Builder<?>newClassBuilder, ClassLoaderclassLoader,
EnhanceContextcontext) throwsPluginException {
// 获取插件定义的构造方法拦截点ConstructorInterceptPointConstructorInterceptPoint[] constructorInterceptPoints=getConstructorsInterceptPoints();
// 获取插件定义的实例方法拦截点InstanceMethodsInterceptPointInstanceMethodsInterceptPoint[] instanceMethodsInterceptPoints=getInstanceMethodsInterceptPoints();
StringenhanceOriginClassName=typeDescription.getTypeName();
// 非空校验booleanexistedConstructorInterceptPoint=false;
if (constructorInterceptPoints!=null&&constructorInterceptPoints.length>0) {
existedConstructorInterceptPoint=true;
        }
booleanexistedMethodsInterceptPoints=false;
if (instanceMethodsInterceptPoints!=null&&instanceMethodsInterceptPoints.length>0) {
existedMethodsInterceptPoints=true;
        }
if (!existedConstructorInterceptPoint&&!existedMethodsInterceptPoints) {
returnnewClassBuilder;
        }
// 这里就是之前提到的让类实现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 (ConstructorInterceptPointconstructorInterceptPoint : 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(newConstructorInter(constructorInterceptPoint                                                                                             .getConstructorInterceptor(), classLoader))));
                }
            }
        }
// 实例方法增强if (existedMethodsInterceptPoints) {
for (InstanceMethodsInterceptPointinstanceMethodsInterceptPoint : instanceMethodsInterceptPoints) {
// 找到插件自定义的实例方法拦截器InstanceMethodsAroundInterceptorStringinterceptor=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(newInstMethodsInterWithOverrideArgs(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(newInstMethodsInter(interceptor, classLoader)));
                    }
                }
            }
        }
returnnewClassBuilder;
    }
}        

publicclassInstMethodsInter {
privatestaticfinalILogLOGGER=LogManager.getLogger(InstMethodsInter.class);
// 用户在插件中定义的实例方法拦截器privateInstanceMethodsAroundInterceptorinterceptor;
publicInstMethodsInter(StringinstanceMethodsAroundInterceptorClassName, ClassLoaderclassLoader) {
try {
// 加载用户在插件中定义的实例方法拦截器interceptor=InterceptorInstanceLoader.load(instanceMethodsAroundInterceptorClassName, classLoader);
        } catch (Throwablet) {
thrownewPluginException("Can't create InstanceMethodsAroundInterceptor.", t);
        }
    }
/*** 当执行被增强方法时，会执行该intercept方法** @param obj          实例对象（this）* @param allArguments 方法入参* @param method       参数描述* @param zuper        原方法调用的句柄*  @param method       被增强后的方法的引用 * @return             方法返回值*/@RuntimeTypepublicObjectintercept(@ThisObjectobj, @AllArgumentsObject[] allArguments, @SuperCallCallable<?>zuper,
@OriginMethodmethod) throwsThrowable {
EnhancedInstancetargetObject= (EnhancedInstance) obj;
MethodInterceptResultresult=newMethodInterceptResult();
try {
// 拦截器前置逻辑interceptor.beforeMethod(targetObject, method, allArguments, method.getParameterTypes(), result);
        } catch (Throwablet) {
LOGGER.error(t, "class[{}] before method[{}] intercept failure", obj.getClass(), method.getName());
        }
Objectret=null;
try {
// 是否中断方法执行if (!result.isContinue()) {
ret=result._ret();
            } else {
// 执行原方法ret=zuper.call();
// 为什么不能走method.invoke？因为method已经是被增强后方法，调用就死循环了！// 可以回到之前的字节码文件查看原因，看一下该intercept执行的时机            }
        } catch (Throwablet) {
try {
// 拦截器异常时逻辑interceptor.handleMethodException(targetObject, method, allArguments, method.getParameterTypes(), t);
            } catch (Throwablet2) {
LOGGER.error(t2, "class[{}] handle method[{}] exception failure", obj.getClass(), method.getName());
            }
throwt;
        } finally {
try {
// 拦截器后置逻辑ret=interceptor.afterMethod(targetObject, method, allArguments, method.getParameterTypes(), ret);
            } catch (Throwablet) {
LOGGER.error(t, "class[{}] after method[{}] intercept failure", obj.getClass(), method.getName());
            }
        }
returnret;
    }
}

// 提供原子下标的类publicclassAtomicRangeInteger {
// JDK提供的原子数组privateAtomicIntegerArrayvalues;
// 固定值15privatestaticfinalintVALUE_OFFSET=15;
// 数组开始下标，固定为0privateintstartValue;
// 数组最后一个元素的下标，固定为数组的最大长度-1privateintendValue;
publicAtomicRangeInteger(intstartValue, intmaxValue) {
// 创建一个长度为31的原子数组this.values=newAtomicIntegerArray(31);
// 将第15位设置为初始值0this.values.set(VALUE_OFFSET, startValue);
this.startValue=startValue;
this.endValue=maxValue-1;
    }
// 核心方法，获取数组的下一个下标publicfinalintgetAndIncrement() {
intnext;
do {
// 原子递增next=this.values.incrementAndGet(VALUE_OFFSET);
// 如果超过了数组范围，CAS重制到0if (next>endValue&&this.values.compareAndSet(VALUE_OFFSET, next, startValue)) {
returnendValue;
            }
        } while (next>endValue);
returnnext-1;
    }
}

publicclassAtomicRangeInteger {
privateAtomicIntegervalue;
privateintstartValue;
privateintendValue;
publicAtomicRangeInteger(intstartValue, intmaxValue) {
this.value=newAtomicInteger(startValue);
this.startValue=startValue;
this.endValue=maxValue-1;
    }
publicfinalintgetAndIncrement() {
intcurrent;
intnext;
do {
// 获取当前下标current=this.value.get();
// 如果超过最大范围则从0开始next=current>=this.endValue?this.startValue : current+1;
// CAS更新下标，失败则循环重试        } while (!this.value.compareAndSet(current, next));
returncurrent;
    }
}    

publicclassAtomicRangeIntegerextendsNumberimplementsSerializable {
// 用原子整型替代V1版本的原子数组privateAtomicIntegervalue;
privateintstartValue;
privateintendValue;
publicAtomicRangeInteger(intstartValue, intmaxValue) {
this.value=newAtomicInteger(startValue);
this.startValue=startValue;
this.endValue=maxValue-1;
    }
publicfinalintgetAndIncrement() {
intnext;
do {
next=this.value.incrementAndGet();
if (next>endValue&&this.value.compareAndSet(next, startValue)) {
returnendValue;
            }
        }
while (next>endValue);
returnnext-1;
    }
}

publicclassAtomicRangeInteger {
privateAtomicLongvalue;
privateintmask;
publicAtomicRangeInteger(intstartValue, intmaxValue) {
this.value=newAtomicLong(startValue);
this.mask=maxValue-1;
    }
publicfinalintgetAndIncrement() {
return (int)(value.incrementAndGet() %mask);
    }
}