import net.bytebuddy.asm.Advice; //导入依赖的package包/类
@Advice.OnMethodEnter(inline = false)
public static void monitorStart(@ParameterNames String parameterNames, @Advice.AllArguments Object[] args,
								@RequestName String requestName, @Advice.Origin("#t") String className,
								@Advice.Origin("#m") String methodName, @Advice.This(optional = true) Object thiz) {
	final String[] paramNames = parameterNames.split(",");
	Map<String, Object> params = new LinkedHashMap<String, Object>();
	for (int i = 0; i < args.length; i++) {
		params.put(paramNames[i], args[i]);
	}

	final MonitoredMethodRequest monitoredRequest = new MonitoredMethodRequest(Stagemonitor.getConfiguration(), requestName, null, params);
	final TracingPlugin tracingPlugin = Stagemonitor.getPlugin(TracingPlugin.class);
	tracingPlugin.getRequestMonitor().monitorStart(monitoredRequest);
	final Span span = TracingPlugin.getCurrentSpan();
	if (requestName == null) {
		span.setOperationName(getBusinessTransationName(thiz != null ? thiz.getClass().getName() : className, methodName));
	}
	span.setTag(MetricsSpanEventListener.ENABLE_TRACKING_METRICS_TAG, true);
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
@Override
public DynamicType.Builder<?> transform(
        final DynamicType.Builder<?> builder,
        final TypeDescription typeDescription,
        final ClassLoader classLoader,
        final JavaModule module) {

    final AsmVisitorWrapper methodsVisitor =
            Advice.to(EnterAdvice.class, ExitAdviceMethods.class)
                    .on(ElementMatchers.isAnnotatedWith(CollectMetrics.class)
                            .and(ElementMatchers.isMethod()));

    final AsmVisitorWrapper constructorsVisitor =
            Advice.to(EnterAdvice.class, ExitAdviceConstructors.class)
                    .on(ElementMatchers.isAnnotatedWith(CollectMetrics.class)
                            .and(ElementMatchers.isConstructor()));

    return builder.visit(methodsVisitor).visit(constructorsVisitor);
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
public static void install() {
    ByteBuddyAgent.install();

    ClassLoader targetClassLoader = File.class.getClassLoader();

    // interceptor class must be injected to the same classloader as the target class that is intercepted
    new ByteBuddy().redefine(CountFileSystemOperations.class)
            .make()
            .load(targetClassLoader,
                    ClassReloadingStrategy.fromInstalledAgent());

    new ByteBuddy().redefine(DirectoryFileTree.class)
            .visit(new AsmVisitorWrapper.ForDeclaredMethods().writerFlags(ClassWriter.COMPUTE_FRAMES)
                    .method(ElementMatchers.named("length"), Advice.to(CountFileSystemOperations.LengthMethod.class))
                    .method(ElementMatchers.named("isFile"), Advice.to(CountFileSystemOperations.IsFileMethod.class))
                    .method(ElementMatchers.named("isDirectory"), Advice.to(CountFileSystemOperations.IsDirectoryMethod.class))
                    .method(ElementMatchers.named("lastModified"), Advice.to(CountFileSystemOperations.LastModifiedMethod.class))
                    .method(ElementMatchers.named("exists"), Advice.to(CountFileSystemOperations.ExistsMethod.class))

            )
            .make()
            .load(targetClassLoader,
                    ClassReloadingStrategy.fromInstalledAgent());
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
public static void install() {
    ByteBuddyAgent.install();

    ClassLoader targetClassLoader = DirectoryFileTree.class.getClassLoader();

    // interceptor class must be injected to the same classloader as the target class that is intercepted
    new ByteBuddy().redefine(CountDirectoryScans.class)
            .make()
            .load(targetClassLoader,
                    ClassReloadingStrategy.fromInstalledAgent());

    new ByteBuddy().redefine(DirectoryFileTree.class)
            .visit(new AsmVisitorWrapper.ForDeclaredMethods().writerFlags(ClassWriter.COMPUTE_FRAMES).method(ElementMatchers.named("visitFrom"), Advice.to(CountDirectoryScans.class)))
            .make()
            .load(targetClassLoader,
                    ClassReloadingStrategy.fromInstalledAgent());
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
/**
 * Creates a new advice transformer.
 *
 * @param advice           The configured advice to use.
 * @param exceptionHandler The exception handler to use.
 * @param assigner         The assigner to use.
 * @param classFileLocator The class file locator to use.
 * @param poolStrategy     The pool strategy to use for looking up an advice.
 * @param locationStrategy The location strategy to use for class loaders when resolving advice classes.
 * @param entries          The advice entries to apply.
 */
protected ForAdvice(Advice.WithCustomMapping advice,
                    StackManipulation exceptionHandler,
                    Assigner assigner,
                    ClassFileLocator classFileLocator,
                    PoolStrategy poolStrategy,
                    LocationStrategy locationStrategy,
                    List<Entry> entries) {
    this.advice = advice;
    this.exceptionHandler = exceptionHandler;
    this.assigner = assigner;
    this.classFileLocator = classFileLocator;
    this.poolStrategy = poolStrategy;
    this.locationStrategy = locationStrategy;
    this.entries = entries;
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
/**
 * This code might be executed in the context of the bootstrap class loader. That's why we have to make sure we only
 * call code which is visible. For example, we can't use slf4j or directly reference stagemonitor classes
 */
@Advice.OnMethodEnter
private static void addHandlers(@Advice.Argument(value = 0, readOnly = false) List<Handler> handlerChain, @Advice.This Binding binding) {
	final java.util.logging.Logger logger = java.util.logging.Logger.getLogger("org.stagemonitor.tracing.soap.SoapHandlerTransformer");
	final List<Handler<?>> stagemonitorHandlers = Dispatcher.get("org.stagemonitor.tracing.soap.SoapHandlerTransformer");

	if (stagemonitorHandlers != null) {
		logger.fine("Adding SOAPHandlers " + stagemonitorHandlers + " to handlerChain for Binding " + binding);
		if (handlerChain == null) {
			handlerChain = Collections.emptyList();
		}
		// creating a new list as we don't know if handlerChain is immutable or not
		handlerChain = new ArrayList<Handler>(handlerChain);
		for (Handler<?> stagemonitorHandler : stagemonitorHandlers) {
			if (!handlerChain.contains(stagemonitorHandler) &&
					// makes sure we only add the handler to the correct application
					Dispatcher.isVisibleToCurrentContextClassLoader(stagemonitorHandler)) {
				handlerChain.add(stagemonitorHandler);
			}
		}
		logger.fine("Handler Chain: " + handlerChain);
	} else {
		logger.fine("No SOAPHandlers found in Dispatcher for Binding " + binding);
	}
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
/**
 * Returns a copy of {@link ParameterTypesExample} which will be instrumented and loaded from a temporary class loader.
 */
public static <T> T instrument(Class<? extends T> classToBeInstrumented, SortedSet<HookMetadata> hookMetadata) throws Exception {
    Map<String, SortedSet<HookMetadata.MethodSignature>> instruments = getInstruments(hookMetadata);
    Set<HookMetadata.MethodSignature> instrumentedMethods = instruments.get(classToBeInstrumented.getName());
    // For examples of byte buddy tests, see net.bytebuddy.asm.AdviceTest in the byte buddy source code.
    return new ByteBuddy()
            .redefine(classToBeInstrumented)
            .visit(Advice.to(PromagentAdvice.class).on(Promagent.matchAnyMethodIn(instrumentedMethods)))
            .make()
            .load(Instrumentor.class.getClassLoader(), ClassLoadingStrategy.Default.CHILD_FIRST)
            .getLoaded()
            .newInstance();
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
@Advice.OnMethodEnter
public static void intercept(@Advice.BoxedArguments Object[] allArguments,
		@Advice.Origin Method method) {
	Logger logger = LoggerFactory.getLogger(method.getDeclaringClass());
	logger.info("Method {} of class {} called", method.getName(), method
			.getDeclaringClass().getSimpleName());

	for (Object argument : allArguments) {
		logger.info("Method {}, parameter type {}, value={}",
				method.getName(), argument.getClass().getSimpleName(),
				argument.toString());
	}
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
private static AgentBuilder createAgent(String className, String methodName) {
	return new AgentBuilder.Default().disableClassFormatChanges()
			.with(AgentBuilder.RedefinitionStrategy.RETRANSFORMATION)
			.type(named(className))
			.transform(new AgentBuilder.Transformer() {
				@Override
				public DynamicType.Builder<?> transform(
						DynamicType.Builder<?> builder,
						TypeDescription typeDescription,
						ClassLoader classLoader) {
					return builder.visit(Advice.to(LoggingAdvice.class).on(
							named(methodName)));
				}
			});
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
private static Class<? extends Page> create(Class<? extends Page> pageType) {

        String className = pageType.getCanonicalName() + "$$Impl";
        ClassLoader classLoader = pageType.getClassLoader();

        InvocationHandler identifyUsingHandler = new IdentifyUsingInvocationHandler();

        Builder<BasePage> pageTypeBuilder = new ByteBuddy()//
            .with(ClassFileVersion.JAVA_V8)
            .subclass(BasePage.class, ConstructorStrategy.Default.IMITATE_SUPER_CLASS)
            .implement(pageType)
            .name(className);

        if (ClasspathUtils.KOTLIN_MODULE_LOADED) {
            pageTypeBuilder = addKotlinImplementations(pageTypeBuilder, pageType);
        }

        pageTypeBuilder = pageTypeBuilder//
            .method(isDefaultMethod())//
            .intercept(Advice.to(ActionAdvice.class)//
                .wrap(DefaultMethodCall.prioritize(pageType)));

        pageTypeBuilder = pageTypeBuilder//
            .method(isAbstract().and(isAnnotatedWith(IdentifyUsing.class)).and(takesArguments(0)))
            .intercept(InvocationHandlerAdapter.of(identifyUsingHandler));

        return pageTypeBuilder.make().load(classLoader).getLoaded();

    }
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
@Advice.OnMethodEnter
public static void action(@Advice.This OffersBrowserGetter browserGetter, @Advice.Origin Method method) {
    new ActionAdviceImpl(browserGetter, method).execute();
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
@Advice.OnMethodExit
public static void onMethodExit(@Advice.This PageFragment pageFragment, @Advice.Origin Method method) {
    try {
        EventProducerImpl impl = THREAD_LOCAL.get();
        if (impl != null) {
            impl.onMethodExit();
        }
    } finally {
        THREAD_LOCAL.remove();

    }
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
private static Class<? extends PageFragment> create(Class<? extends PageFragment> pageFragmentType) {

        String className = pageFragmentType.getCanonicalName() + "$$Impl";
        ClassLoader classLoader = pageFragmentType.getClassLoader();

        InvocationHandler identifyUsingHandler = new IdentifyUsingInvocationHandler();
        InvocationHandler attributeHandler = new AttributeInvocationHandler();

        Builder<BasePageFragment> pageFragmentTypeBuilder = new ByteBuddy()//
            .with(ClassFileVersion.JAVA_V8)
            .subclass(BasePageFragment.class, ConstructorStrategy.Default.IMITATE_SUPER_CLASS)
            .implement(pageFragmentType)
            .name(className);

        if (ClasspathUtils.KOTLIN_MODULE_LOADED) {
            pageFragmentTypeBuilder = addKotlinImplementations(pageFragmentTypeBuilder, pageFragmentType);
        }

        pageFragmentTypeBuilder = pageFragmentTypeBuilder//
            .method(isDefaultMethod())//
            .intercept(Advice.to(ActionAdvice.class)//
                .wrap(Advice.to(MarkingAdvice.class)//
                    .wrap(Advice.to(EventProducerAdvice.class)//
                        .wrap(DefaultMethodCall.prioritize(pageFragmentType)))));

        pageFragmentTypeBuilder = pageFragmentTypeBuilder//
            .method(isAbstract().and(isAnnotatedWith(IdentifyUsing.class)).and(takesArguments(0)))
            .intercept(InvocationHandlerAdapter.of(identifyUsingHandler));

        pageFragmentTypeBuilder = pageFragmentTypeBuilder//
            .method(isAbstract().and(isAnnotatedWith(Attribute.class)).and(takesArguments(0)))
            .intercept(Advice.to(MarkingAdvice.class)//
                .wrap(InvocationHandlerAdapter.of(attributeHandler)));

        return pageFragmentTypeBuilder.make().load(classLoader).getLoaded();

    }
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
@Override
public DynamicType.Builder<?> transform(
    DynamicType.Builder<?> builder,
    TypeDescription typeDescription,
    ClassLoader classLoader,
    JavaModule module) {
  return builder.visit(Advice.to(GetContent.class).on(named("getContent")));
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
@Override
public DynamicType.Builder<?> transform(
    DynamicType.Builder<?> builder,
    TypeDescription typeDescription,
    ClassLoader classLoader,
    JavaModule module) {
  return builder
      .visit(Advice.to(Start.class).on(named("start")))
      .visit(Advice.to(Run.class).on(named("run")));
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
@Override
public DynamicType.Builder<?> transform(
    DynamicType.Builder<?> builder,
    TypeDescription typeDescription,
    ClassLoader classLoader,
    JavaModule module) {
  return builder.visit(Advice.to(Execute.class).on(named("execute")));
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
@Advice.OnMethodEnter
public synchronized static void interceptVisitFrom(@Advice.Argument(1) File fileOrDirectory) {
    File key = fileOrDirectory.getAbsoluteFile();
    Integer count = COUNTS.get(key);
    COUNTS.put(key, count != null ? count + 1 : 1);

    if (TRACK_LOCATIONS) {
        List<Exception> locations = LOCATIONS.get(key);
        if (locations == null) {
            locations = new ArrayList<Exception>();
            LOCATIONS.put(key, locations);
        }
        locations.add(new Exception());
    }
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
@Advice.OnMethodEnter
public static void onStatusMessage(
    final StatusMessageFlyweight msg,
    final UnsafeBuffer buffer,
    final int length,
    final InetSocketAddress srcAddress)
{
    LOGGER.logFrameIn(buffer, 0, length, srcAddress);
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
@Advice.OnMethodEnter
public static void onNakMessage(
    final NakFlyweight msg,
    final UnsafeBuffer buffer,
    final int length,
    final InetSocketAddress srcAddress)
{
    LOGGER.logFrameIn(buffer, 0, length, srcAddress);
}
 

import net.bytebuddy.asm.Advice; //导入依赖的package包/类
@Advice.OnMethodEnter
public static void onRttMeasurement(
    final RttMeasurementFlyweight msg,
    final UnsafeBuffer buffer,
    final int length,
    final InetSocketAddress srcAddress)
{
    LOGGER.logFrameIn(buffer, 0, length, srcAddress);
}