import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private static synchronized <S> Class<S> giveDynamicSubclass(Class<S> superclass) {
    boolean isSystemClass = isSystemClass(superclass.getName());
    String namePrefix = isSystemClass ? "$" : "";
    String name = namePrefix + superclass.getName() + "$$DynamicSubclass";

    Class<S> existsAlready = (Class<S>)classForName(name);
    if (existsAlready != null) {
        return existsAlready;
    }

    Class<?> context = isSystemClass ? Instantiator.class : superclass;
    return (Class<S>)new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .subclass(superclass)
            .name(name)
            .make()
            .load(context.getClassLoader(), ClassLoadingStrategy.Default.INJECTION.with(context.getProtectionDomain()))
            .getLoaded();
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的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.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
/**
 * Creates a new Byte Buddy instance.
 *
 * @param classFileVersion             The class file version to use for types that are not based on an existing class file.
 * @param namingStrategy               The naming strategy to use.
 * @param auxiliaryTypeNamingStrategy  The naming strategy to use for naming auxiliary types.
 * @param annotationValueFilterFactory The annotation value filter factory to use.
 * @param annotationRetention          The annotation retention strategy to use.
 * @param implementationContextFactory The implementation context factory to use.
 * @param methodGraphCompiler          The method graph compiler to use.
 * @param instrumentedTypeFactory      The instrumented type factory to use.
 * @param typeValidation               Determines if a type should be explicitly validated.
 * @param ignoredMethods               A matcher for identifying methods that should be excluded from instrumentation.
 */
protected ByteBuddy(ClassFileVersion classFileVersion,
                    NamingStrategy namingStrategy,
                    AuxiliaryType.NamingStrategy auxiliaryTypeNamingStrategy,
                    AnnotationValueFilter.Factory annotationValueFilterFactory,
                    AnnotationRetention annotationRetention,
                    Implementation.Context.Factory implementationContextFactory,
                    MethodGraph.Compiler methodGraphCompiler,
                    InstrumentedType.Factory instrumentedTypeFactory,
                    TypeValidation typeValidation,
                    LatentMatcher<? super MethodDescription> ignoredMethods) {
    this.classFileVersion = classFileVersion;
    this.namingStrategy = namingStrategy;
    this.auxiliaryTypeNamingStrategy = auxiliaryTypeNamingStrategy;
    this.annotationValueFilterFactory = annotationValueFilterFactory;
    this.annotationRetention = annotationRetention;
    this.implementationContextFactory = implementationContextFactory;
    this.methodGraphCompiler = methodGraphCompiler;
    this.instrumentedTypeFactory = instrumentedTypeFactory;
    this.ignoredMethods = ignoredMethods;
    this.typeValidation = typeValidation;
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的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.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
@Test
public void generatedClassWithGeneratedFieldWithSuppressedWarning() {
    class Super {}
    Class<?> sub = new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .subclass(Super.class)
            .defineField("dynamicField", int.class, Visibility.PRIVATE)
            .make()
            .load(Super.class.getClassLoader(), ClassLoadingStrategy.Default.INJECTION)
            .getLoaded();
    AnnotationAccessor accessor = new AnnotationAccessor(TestSupportedAnnotations.values(), sub, NO_INGORED_ANNOTATIONS, true);
    assertFalse(accessor.fieldHas("dynamicField", FIELD_RUNTIME_RETENTION));
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
/**
 * Creates a new configuration that applies the supplied type validation. By default, explicitly type validation is applied
 * by Byte Buddy but it might be disabled for performance reason or for voluntarily creating illegal types. The Java virtual
 * machine applies its own type validation where some {@link Error} is thrown if a type is invalid, while Byte Buddy throws
 * some {@link RuntimeException}.
 *
 * @param typeValidation The type validation to apply during type creation.
 * @return A new Byte Buddy instance that applies the supplied type validation.
 */
public ByteBuddy with(TypeValidation typeValidation) {
    return new ByteBuddy(classFileVersion,
            namingStrategy,
            auxiliaryTypeNamingStrategy,
            annotationValueFilterFactory,
            annotationRetention,
            implementationContextFactory,
            methodGraphCompiler,
            instrumentedTypeFactory,
            typeValidation,
            ignoredMethods);
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
@Test
public void testNonGenericResolutionIsLazyForSimpleCreationNonFrozen() throws Exception {
    ClassFileLocator classFileLocator = spy(ClassFileLocator.ForClassLoader.ofClassPath());
    new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .with(MethodGraph.Empty.INSTANCE)
            .with(InstrumentedType.Factory.Default.MODIFIABLE)
            .redefine(describe(NonGenericType.class, classFileLocator, new TypePool.CacheProvider.Simple()), classFileLocator)
            .make();
    verify(classFileLocator, times(2)).locate(NonGenericType.class.getName());
    verifyNoMoreInteractions(classFileLocator);
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
@Test
public void testNonGenericResolutionIsLazyForSimpleCreation() throws Exception {
    ClassFileLocator classFileLocator = spy(ClassFileLocator.ForClassLoader.ofClassPath());
    new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .with(MethodGraph.Empty.INSTANCE)
            .with(InstrumentedType.Factory.Default.FROZEN)
            .redefine(describe(NonGenericType.class, classFileLocator, new TypePool.CacheProvider.Simple()), classFileLocator)
            .make();
    verify(classFileLocator, times(2)).locate(NonGenericType.class.getName());
    verifyNoMoreInteractions(classFileLocator);
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
@Test
public void testGenericResolutionIsLazyForSimpleCreation() throws Exception {
    ClassFileLocator classFileLocator = spy(ClassFileLocator.ForClassLoader.ofClassPath());
    new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .with(MethodGraph.Empty.INSTANCE)
            .with(InstrumentedType.Factory.Default.FROZEN)
            .redefine(describe(GenericType.class, classFileLocator, new TypePool.CacheProvider.Simple()), classFileLocator)
            .make();
    verify(classFileLocator, times(2)).locate(GenericType.class.getName());
    verifyNoMoreInteractions(classFileLocator);
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
@Test(expected = IllegalStateException.class)
public void testDelegationToInvisibleFieldTypeThrowsException() throws Exception {
    new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .subclass(Object.class)
            .defineField("foo", Foo.class)
            .method(isToString())
            .intercept(MethodDelegation.toField("foo"))
            .make();
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
/**
 * Performs a benchmark for a trivial class creation using Byte Buddy.
 *
 * @return The created instance, in order to avoid JIT removal.
 */
@Benchmark
public Class<?> benchmarkByteBuddy() {
    return new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .ignore(any())
            .subclass(baseClass)
            .make()
            .load(newClassLoader(), ClassLoadingStrategy.Default.INJECTION)
            .getLoaded();
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
/**
 * Performs a benchmark of an interface implementation using Byte Buddy.
 *
 * @return The created instance, in order to avoid JIT removal.
 * @throws java.lang.Exception If the reflective invocation causes an exception.
 */
@Benchmark
public ExampleInterface benchmarkByteBuddy() throws Exception {
    return new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .ignore(none())
            .subclass(baseClass)
            .method(isDeclaredBy(baseClass)).intercept(StubMethod.INSTANCE)
            .make()
            .load(newClassLoader(), ClassLoadingStrategy.Default.INJECTION)
            .getLoaded()
            .getDeclaredConstructor()
            .newInstance();
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
/**
 * Performs a benchmark of an interface implementation using Byte Buddy. This benchmark uses a type pool to compare against
 * usage of the reflection API.
 *
 * @return The created instance, in order to avoid JIT removal.
 * @throws java.lang.Exception If the reflective invocation causes an exception.
 */
@Benchmark
public ExampleInterface benchmarkByteBuddyWithTypePool() throws Exception {
    return (ExampleInterface) new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .ignore(none())
            .subclass(baseClassDescription)
            .method(isDeclaredBy(baseClassDescription)).intercept(StubMethod.INSTANCE)
            .make()
            .load(newClassLoader(), ClassLoadingStrategy.Default.INJECTION)
            .getLoaded()
            .getDeclaredConstructor()
            .newInstance();
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
/**
 * Performs a benchmark of a class extension using Byte Buddy. This benchmark creates proxy classes for the invocation
 * of super methods which requires the creation of auxiliary classes.
 *
 * @return The created instance, in order to avoid JIT removal.
 * @throws java.lang.Exception If the invocation causes an exception.
 */
@Benchmark
public ExampleClass benchmarkByteBuddyWithProxy() throws Exception {
    return new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .ignore(none())
            .subclass(baseClass)
            .method(isDeclaredBy(baseClass)).intercept(MethodDelegation.to(ByteBuddyProxyInterceptor.class))
            .make()
            .load(newClassLoader(), ClassLoadingStrategy.Default.INJECTION)
            .getLoaded()
            .getDeclaredConstructor()
            .newInstance();
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
/**
 * Performs a benchmark of a class extension using Byte Buddy. This benchmark also uses the annotation-based approach
 * but creates delegation methods which do not require the creation of additional classes. This benchmark reuses a
 * precomputed delegator.
 *
 * @return The created instance, in order to avoid JIT removal.
 * @throws Exception If the invocation causes an exception.
 */
@Benchmark
public ExampleClass benchmarkByteBuddyWithProxyAndReusedDelegator() throws Exception {
    return new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .ignore(none())
            .subclass(baseClass)
            .method(isDeclaredBy(baseClass)).intercept(proxyInterceptor)
            .make()
            .load(newClassLoader(), ClassLoadingStrategy.Default.INJECTION)
            .getLoaded()
            .getDeclaredConstructor()
            .newInstance();
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
/**
 * Performs a benchmark of a class extension using Byte Buddy. This benchmark creates proxy classes for the invocation
 * of super methods which requires the creation of auxiliary classes. This benchmark uses a type pool to compare against
 * usage of the reflection API.
 *
 * @return The created instance, in order to avoid JIT removal.
 * @throws java.lang.Exception If the invocation causes an exception.
 */
@Benchmark
public ExampleClass benchmarkByteBuddyWithProxyWithTypePool() throws Exception {
    return (ExampleClass) new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .ignore(none())
            .subclass(baseClassDescription)
            .method(isDeclaredBy(baseClassDescription)).intercept(MethodDelegation.to(proxyClassDescription))
            .make()
            .load(newClassLoader(), ClassLoadingStrategy.Default.INJECTION)
            .getLoaded()
            .getDeclaredConstructor()
            .newInstance();
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
/**
 * Performs a benchmark of a class extension using Byte Buddy. This benchmark also uses the annotation-based approach
 * but creates delegation methods which do not require the creation of additional classes. This benchmark reuses a
 * precomputed delegator. This benchmark uses a type pool to compare against usage of the reflection API.
 *
 * @return The created instance, in order to avoid JIT removal.
 * @throws Exception If the invocation causes an exception.
 */
@Benchmark
public ExampleClass benchmarkByteBuddyWithProxyAndReusedDelegatorWithTypePool() throws Exception {
    return (ExampleClass) new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .ignore(none())
            .subclass(baseClassDescription)
            .method(isDeclaredBy(baseClassDescription)).intercept(proxyInterceptorDescription)
            .make()
            .load(newClassLoader(), ClassLoadingStrategy.Default.INJECTION)
            .getLoaded()
            .getDeclaredConstructor()
            .newInstance();
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
/**
 * Performs a benchmark of a class extension using Byte Buddy. This benchmark also uses the annotation-based approach
 * but creates delegation methods which do not require the creation of additional classes.
 *
 * @return The created instance, in order to avoid JIT removal.
 * @throws Exception If the invocation causes an exception.
 */
@Benchmark
public ExampleClass benchmarkByteBuddyWithAccessor() throws Exception {
    return new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .ignore(none())
            .subclass(baseClass)
            .method(isDeclaredBy(baseClass)).intercept(MethodDelegation.to(ByteBuddyAccessInterceptor.class))
            .make()
            .load(newClassLoader(), ClassLoadingStrategy.Default.INJECTION)
            .getLoaded()
            .getDeclaredConstructor()
            .newInstance();
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
/**
 * Performs a benchmark of a class extension using Byte Buddy. This benchmark also uses the annotation-based approach
 * but creates delegation methods which do not require the creation of additional classes. This benchmark reuses a
 * precomputed delegator.
 *
 * @return The created instance, in order to avoid JIT removal.
 * @throws Exception If the invocation causes an exception.
 */
@Benchmark
public ExampleClass benchmarkByteBuddyWithAccessorAndReusedDelegator() throws Exception {
    return new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .ignore(none())
            .subclass(baseClass)
            .method(isDeclaredBy(baseClass)).intercept(accessInterceptor)
            .make()
            .load(newClassLoader(), ClassLoadingStrategy.Default.INJECTION)
            .getLoaded()
            .getDeclaredConstructor()
            .newInstance();
}
 

import net.bytebuddy.dynamic.scaffold.TypeValidation; //导入依赖的package包/类
/**
 * Performs a benchmark of a class extension using Byte Buddy. This benchmark also uses the annotation-based approach
 * but creates delegation methods which do not require the creation of additional classes. This benchmark uses a type
 * pool to compare against usage of the reflection API.
 *
 * @return The created instance, in order to avoid JIT removal.
 * @throws Exception If the invocation causes an exception.
 */
@Benchmark
public ExampleClass benchmarkByteBuddyWithAccessorWithTypePool() throws Exception {
    return (ExampleClass) new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .ignore(none())
            .subclass(baseClassDescription)
            .method(isDeclaredBy(baseClassDescription)).intercept(MethodDelegation.to(accessClassDescription))
            .make()
            .load(newClassLoader(), ClassLoadingStrategy.Default.INJECTION)
            .getLoaded()
            .getDeclaredConstructor()
            .newInstance();
}