Java AgentBuilder类代码示例

import net.bytebuddy.agent.builder.AgentBuilder; //导入依赖的package包/类
/**
 * Creates the AgentBuilder that will redefine the System class.
 * @param inst instrumentation instance.
 * @return an agent builder.
 */
private static AgentBuilder createAgentBuilder(Instrumentation inst) {

    // Find me a class called "java.lang.System"
    final ElementMatcher.Junction<NamedElement> systemType = ElementMatchers.named("java.lang.System");

    // And then find a method called setSecurityManager and tell MySystemInterceptor to
    // intercept it (the method binding is smart enough to take it from there)
    final AgentBuilder.Transformer transformer =
            (b, typeDescription) -> b.method(ElementMatchers.named("setSecurityManager"))
                    .intercept(MethodDelegation.to(MySystemInterceptor.class));

    // Disable a bunch of stuff and turn on redefine as the only option
    final ByteBuddy byteBuddy = new ByteBuddy().with(Implementation.Context.Disabled.Factory.INSTANCE);
    final AgentBuilder agentBuilder = new AgentBuilder.Default()
            .withByteBuddy(byteBuddy)
            .withInitializationStrategy(AgentBuilder.InitializationStrategy.NoOp.INSTANCE)
            .withRedefinitionStrategy(AgentBuilder.RedefinitionStrategy.REDEFINITION)
            .withTypeStrategy(AgentBuilder.TypeStrategy.Default.REDEFINE)
            .type(systemType)
            .transform(transformer);

    return agentBuilder;
}
 

import net.bytebuddy.agent.builder.AgentBuilder; //导入依赖的package包/类
private static void transformClasses(Instrumentation instrumentation) {

		new AgentBuilder.Default().withListener(new AgentListener()).type(geTypeMatchers())
				.transform(new Transformer() {

					@Override
					public Builder<?> transform(Builder<?> builder, TypeDescription typeDescription) {

						return builder
								.invokable(isAnnotatedWith(named(INJECT_ANNOTATION))
										.or(isAnnotatedWith(named(AUTOWIRED_ANNOTATION))))
								.intercept(SuperMethodCall.INSTANCE
										.andThen(MethodDelegation.to(InjectionInterceptor.class)));
					}

				}).installOn(instrumentation);
	}
 

import net.bytebuddy.agent.builder.AgentBuilder; //导入依赖的package包/类
public static void removeTransformer()
{
    if (logTransformer != null)
    {
        readerAgentRunner.close();
        instrumentation.removeTransformer(logTransformer);

        final ElementMatcher.Junction<TypeDescription> orClause = nameEndsWith("DriverConductor")
            .or(nameEndsWith("ClientProxy"))
            .or(nameEndsWith("ClientCommandAdapter"))
            .or(nameEndsWith("SenderProxy"))
            .or(nameEndsWith("ReceiverProxy"))
            .or(inheritsAnnotation(EventLog.class));

        final ResettableClassFileTransformer transformer = new AgentBuilder.Default()
            .type(orClause)
            .transform(AgentBuilder.Transformer.NoOp.INSTANCE)
            .installOn(instrumentation);

        instrumentation.removeTransformer(transformer);

        readerAgentRunner = null;
        instrumentation = null;
        logTransformer = null;
    }
}
 

import net.bytebuddy.agent.builder.AgentBuilder; //导入依赖的package包/类
private static synchronized void agent(final boolean shouldRedefine, final Instrumentation instrumentation)
{
    BufferAlignmentAgent.instrumentation = instrumentation;
    // all Int methods, and all String method other than
    // XXXStringWithoutLengthXXX or getStringXXX(int, int)
    final Junction<MethodDescription> intVerifierMatcher = nameContains("Int")
        .or(nameMatches(".*String[^W].*").and(not(ElementMatchers.takesArguments(int.class, int.class))));

    alignmentTransformer = new AgentBuilder.Default(new ByteBuddy().with(TypeValidation.DISABLED))
        .with(LISTENER)
        .disableClassFormatChanges()
        .with(shouldRedefine ?
            AgentBuilder.RedefinitionStrategy.RETRANSFORMATION :
            AgentBuilder.RedefinitionStrategy.DISABLED)
        .type(isSubTypeOf(DirectBuffer.class).and(not(isInterface())))
        .transform((builder, typeDescription, classLoader, module) -> builder
            .visit(to(LongVerifier.class).on(nameContains("Long")))
            .visit(to(DoubleVerifier.class).on(nameContains("Double")))
            .visit(to(IntVerifier.class).on(intVerifierMatcher))
            .visit(to(FloatVerifier.class).on(nameContains("Float")))
            .visit(to(ShortVerifier.class).on(nameContains("Short")))
            .visit(to(CharVerifier.class).on(nameContains("Char"))))
        .installOn(instrumentation);
}
 

import net.bytebuddy.agent.builder.AgentBuilder; //导入依赖的package包/类
private static ClassFileTransformer initByteBuddyClassFileTransformer(AutoEvictingCachingBinaryLocator binaryLocator) {
	AgentBuilder agentBuilder = createAgentBuilder(binaryLocator);
	for (StagemonitorByteBuddyTransformer transformer : getStagemonitorByteBuddyTransformers()) {
		agentBuilder = agentBuilder
				.type(transformer.getMatcher())
				.transform(transformer.getTransformer())
				.asDecorator();
	}

	final long start = System.currentTimeMillis();
	try {
		return agentBuilder.installOn(instrumentation);
	} finally {
		if (corePlugin.isDebugInstrumentation()) {
			logger.info("Installed agent in {} ms", System.currentTimeMillis() - start);
		}
	}
}
 

import net.bytebuddy.agent.builder.AgentBuilder; //导入依赖的package包/类
private static AgentBuilder createAgentBuilder(AutoEvictingCachingBinaryLocator binaryLocator) {
	final ByteBuddy byteBuddy = new ByteBuddy()
			.with(TypeValidation.of(corePlugin.isDebugInstrumentation()))
			.with(MethodGraph.Compiler.ForDeclaredMethods.INSTANCE);
	return new AgentBuilder.Default(byteBuddy)
			.with(AgentBuilder.RedefinitionStrategy.RETRANSFORMATION)
			.with(getListener())
			.with(binaryLocator)
			.ignore(any(), timed("classloader", "reflection", isReflectionClassLoader()))
			.or(any(), timed("classloader", "groovy-call-site", classLoaderWithName("org.codehaus.groovy.runtime.callsite.CallSiteClassLoader")))
			.or(any(), new IsIgnoredClassLoaderElementMatcher())
			.or(timed("type", "global-exclude", nameStartsWith("org.aspectj.")
					.or(nameStartsWith("org.groovy."))
					.or(nameStartsWith("com.p6spy."))
					.or(nameStartsWith("net.bytebuddy."))
					.or(nameStartsWith("org.slf4j.").and(not(nameStartsWith("org.slf4j.impl."))))
					.or(nameContains("javassist"))
					.or(nameContains(".asm."))
					.or(nameStartsWith("org.stagemonitor")
							.and(not(nameContains("Test")
									.or(nameContains("benchmark"))
									.or(nameStartsWith("org.stagemonitor.demo")))))
			))
			.disableClassFormatChanges();
}
 

import net.bytebuddy.agent.builder.AgentBuilder; //导入依赖的package包/类
public static void premain(final String agentArgs,
                               final Instrumentation inst) throws Exception {
        System.out.printf("Starting %s\n",
                MetricsCollectionByteBuddyAgent.class.getSimpleName());

        new AgentBuilder.Default()
                .type(ElementMatchers.any())
                .transform(new MetricsTransformer())
//        .with(AgentBuilder.Listener.StreamWriting.toSystemOut())
                .with(AgentBuilder.TypeStrategy.Default.REDEFINE)
                .installOn(inst);
    }
 

import net.bytebuddy.agent.builder.AgentBuilder; //导入依赖的package包/类
public static void premain(String agentArgs, Instrumentation inst) {
        try {
            PromagentCollectorRegistry registry = new PromagentCollectorRegistry();
            ManagementFactory.getPlatformMBeanServer().registerMBean(new Exporter(registry), new ObjectName("io.promagent:type=exporter"));
            Map<String, String> args = parseCmdline(agentArgs);
            if (args.containsKey("port")) {
                BuiltInServer.run(args.get("host"), args.get("port"), registry);
            }
            ClassLoaderCache classLoaderCache = ClassLoaderCache.getInstance();
            List<Path> hookJars = classLoaderCache.getPerDeploymentJars();
            SortedSet<HookMetadata> hookMetadata = new HookMetadataParser(hookJars).parse();
            MetricsStore metricsStore = new MetricsStore(registry);
            Delegator.init(hookMetadata, metricsStore, classLoaderCache);
            printHookMetadata(hookMetadata);

            AgentBuilder agentBuilder = new AgentBuilder.Default()
                    .with(AgentBuilder.RedefinitionStrategy.REDEFINITION)
                    .with(AgentBuilder.TypeStrategy.Default.REDEFINE);
                    // .with(AgentBuilder.Listener.StreamWriting.toSystemError()); // use this to see exceptions thrown in instrumented code
            agentBuilder = applyHooks(agentBuilder, hookMetadata, classLoaderCache);
            agentBuilder.installOn(inst);

            // TODO -- the following is an experiment supporting collectors directly (in addition to hooks)
//            io.prometheus.client.Collector jmxCollector = (io.prometheus.client.Collector) classLoaderCache.currentClassLoader().loadClass("io.promagent.collectors.JmxCollector").newInstance();
//            registry.registerNoJmx(jmxCollector);

        } catch (Throwable t) {
            t.printStackTrace();
        }
    }
 

import net.bytebuddy.agent.builder.AgentBuilder; //导入依赖的package包/类
/**
 * Add {@link ElementMatcher} for the hooks.
 */
private static AgentBuilder applyHooks(AgentBuilder agentBuilder, SortedSet<HookMetadata> hookMetadata, ClassLoaderCache classLoaderCache) {
    Map<String, SortedSet<MethodSignature>> instruments = getInstruments(hookMetadata);
    for (Map.Entry<String, SortedSet<MethodSignature>> entry : instruments.entrySet()) {
        String instrumentedClassName = entry.getKey();
        Set<MethodSignature> instrumentedMethods = entry.getValue();
        agentBuilder = agentBuilder
                .type(ElementMatchers.hasSuperType(named(instrumentedClassName)))
                .transform(new AgentBuilder.Transformer.ForAdvice()
                        .include(classLoaderCache.currentClassLoader()) // must be able to load PromagentAdvice
                        .advice(matchAnyMethodIn(instrumentedMethods), PromagentAdvice.class.getName())
                );
    }
    return agentBuilder;
}
 

import net.bytebuddy.agent.builder.AgentBuilder; //导入依赖的package包/类
/**
 * 启动入口
 * @param instrumentation
 * @return
 */
public Agent start(Instrumentation instrumentation) {
    new AgentBuilder.Default()
        .type(
            inPlugins().and(not(isInterface()))
        )
        .transform(((builder, typeDescription, classLoader, javaModule) -> {
            ClassDataSource dataSource = pluginManager.find(typeDescription.getName());
            //TODO 大有可为
            return DataSourceMonitorRegister.register(dataSource, builder); //注册监听代码（拦截器）
        }))
        .with(listener())
        .installOn(instrumentation);
    return this;
}
 

import net.bytebuddy.agent.builder.AgentBuilder; //导入依赖的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.agent.builder.AgentBuilder; //导入依赖的package包/类
/**
 * Initializes the OpenCensus Agent for Java.
 *
 * @param agentArgs agent options, passed as a single string by the JVM
 * @param instrumentation the {@link Instrumentation} object provided by the JVM for instrumenting
 *     Java programming language code
 * @throws Exception if initialization of the agent fails
 * @see java.lang.instrument
 */
public static void premain(String agentArgs, Instrumentation instrumentation) throws Exception {
  checkNotNull(instrumentation, "instrumentation");

  logger.fine("Initializing.");

  // The classes in bootstrap.jar, such as ContextManger and ContextStrategy, will be referenced
  // from classes loaded by the bootstrap classloader. Thus, these classes have to be loaded by
  // the bootstrap classloader, too.
  instrumentation.appendToBootstrapClassLoaderSearch(
      new JarFile(Resources.getResourceAsTempFile("bootstrap.jar")));

  checkLoadedByBootstrapClassloader(ContextTrampoline.class);
  checkLoadedByBootstrapClassloader(ContextStrategy.class);

  Settings settings = Settings.load();
  AgentBuilder agentBuilder =
      new AgentBuilder.Default()
          .disableClassFormatChanges()
          .with(AgentBuilder.RedefinitionStrategy.RETRANSFORMATION)
          .with(new AgentBuilderListener())
          .ignore(none());
  for (Instrumenter instrumenter : ServiceLoader.load(Instrumenter.class)) {
    agentBuilder = instrumenter.instrument(agentBuilder, settings);
  }
  agentBuilder.installOn(instrumentation);

  logger.fine("Initialized.");
}
 

import net.bytebuddy.agent.builder.AgentBuilder; //导入依赖的package包/类
@Override
public AgentBuilder instrument(AgentBuilder agentBuilder, Settings settings) {
  checkNotNull(agentBuilder, "agentBuilder");
  checkNotNull(settings, "settings");

  if (!settings.isEnabled("trace.java.net.URL.getContent")) {
    return agentBuilder;
  }

  return agentBuilder.type(named("java.net.URL")).transform(new Transformer());
}
 

import net.bytebuddy.agent.builder.AgentBuilder; //导入依赖的package包/类
@Override
public AgentBuilder instrument(AgentBuilder agentBuilder, Settings settings) {
  checkNotNull(agentBuilder, "agentBuilder");
  checkNotNull(settings, "settings");

  if (!settings.isEnabled("context-propagation.thread")) {
    return agentBuilder;
  }

  return agentBuilder.type(isSubTypeOf(Thread.class)).transform(new Transformer());
}
 

import net.bytebuddy.agent.builder.AgentBuilder; //导入依赖的package包/类
@Override
public AgentBuilder instrument(AgentBuilder agentBuilder, Settings settings) {
  checkNotNull(agentBuilder, "agentBuilder");
  checkNotNull(settings, "settings");

  if (!settings.isEnabled("context-propagation.executor")) {
    return agentBuilder;
  }

  return agentBuilder.type(createMatcher()).transform(new Transformer());
}