import net.bytebuddy.dynamic.scaffold.InstrumentedType; //导入依赖的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.InstrumentedType; //导入依赖的package包/类
@Override
public InstrumentedType prepare(InstrumentedType instrumentedType) {
  // Remember the field description of the instrumented type.
  delegateField =
      instrumentedType
          .getSuperClass() // always DoFnInvokerBase
          .getDeclaredFields()
          .filter(ElementMatchers.named(FN_DELEGATE_FIELD_NAME))
          .getOnly();
  // Delegating the method call doesn't require any changes to the instrumented type.
  return instrumentedType;
}
 

import net.bytebuddy.dynamic.scaffold.InstrumentedType; //导入依赖的package包/类
@Override
public InstrumentedType prepare(InstrumentedType instrumentedType) {
  // Remember the field description of the instrumented type.
  // Kind of a hack to set the protected value, because the instrumentedType
  // is only available to prepare, while we need this information in
  // beforeDelegation
  delegateField =
      instrumentedType
          .getDeclaredFields() // the delegate is declared on the OnTimerInvoker
          .filter(ElementMatchers.named(FN_DELEGATE_FIELD_NAME))
          .getOnly();
  // Delegating the method call doesn't require any changes to the instrumented type.
  return instrumentedType;
}
 

import net.bytebuddy.dynamic.scaffold.InstrumentedType; //导入依赖的package包/类
/**
 * Configures Byte Buddy to use the specified factory for creating {@link InstrumentedType}s. Doing so, more efficient
 * representations can be chosen when only certain operations are required. By default, all operations are supported.
 *
 * @param instrumentedTypeFactory The factory to use when creating instrumented types.
 * @return A new Byte Buddy instance that uses the supplied factory for creating instrumented types.
 */
public ByteBuddy with(InstrumentedType.Factory instrumentedTypeFactory) {
    return new ByteBuddy(classFileVersion,
            namingStrategy,
            auxiliaryTypeNamingStrategy,
            annotationValueFilterFactory,
            annotationRetention,
            implementationContextFactory,
            methodGraphCompiler,
            instrumentedTypeFactory,
            typeValidation,
            ignoredMethods);
}
 

import net.bytebuddy.dynamic.scaffold.InstrumentedType; //导入依赖的package包/类
@Override
public InstrumentedType prepare(InstrumentedType instrumentedType) {
    for (String value : values) {
        instrumentedType = instrumentedType.withField(new FieldDescription.Token(value,
                ENUM_FIELD_MODIFIERS | Opcodes.ACC_ENUM,
                TargetType.DESCRIPTION.asGenericType()));
    }
    return instrumentedType
            .withField(new FieldDescription.Token(ENUM_VALUES,
                    ENUM_FIELD_MODIFIERS | Opcodes.ACC_SYNTHETIC,
                    TypeDescription.ArrayProjection.of(TargetType.DESCRIPTION).asGenericType()))
            .withInitializer(new InitializationAppender(values));
}
 

import net.bytebuddy.dynamic.scaffold.InstrumentedType; //导入依赖的package包/类
@Override
public InstrumentedType prepare(InstrumentedType instrumentedType) {
    return instrumentedType
            .withField(new FieldDescription.Token(fieldName,
                    Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_VOLATILE | Opcodes.ACC_SYNTHETIC,
                    INVOCATION_HANDLER_TYPE))
            .withInitializer(new LoadedTypeInitializer.ForStaticField(fieldName, invocationHandler));
}
 

import net.bytebuddy.dynamic.scaffold.InstrumentedType; //导入依赖的package包/类
@Override
public InstrumentedType prepare(InstrumentedType instrumentedType) {
    for (Implementation implementation : implementations) {
        instrumentedType = implementation.prepare(instrumentedType);
    }
    return instrumentedType;
}
 

import net.bytebuddy.dynamic.scaffold.InstrumentedType; //导入依赖的package包/类
@Override
public InstrumentedType prepare(InstrumentedType instrumentedType) {
    return instrumentedType
            .withField(new FieldDescription.Token(fieldName,
                    Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_VOLATILE | Opcodes.ACC_SYNTHETIC,
                    fieldType))
            .withInitializer(new LoadedTypeInitializer.ForStaticField(fieldName, target));
}
 

import net.bytebuddy.dynamic.scaffold.InstrumentedType; //导入依赖的package包/类
@Override
public InstrumentedType prepare(InstrumentedType instrumentedType) {
    for (ArgumentLoader.Factory argumentLoader : argumentLoaders) {
        instrumentedType = argumentLoader.prepare(instrumentedType);
    }
    return targetHandler.prepare(instrumentedType);
}
 

import net.bytebuddy.dynamic.scaffold.InstrumentedType; //导入依赖的package包/类
@Override
public InstrumentedType prepare(InstrumentedType instrumentedType) {
    return instrumentedType
            .withField(new FieldDescription.Token(fieldName,
                    Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_VOLATILE | Opcodes.ACC_SYNTHETIC,
                    fieldType))
            .withInitializer(new LoadedTypeInitializer.ForStaticField(fieldName, value));
}
 

import net.bytebuddy.dynamic.scaffold.InstrumentedType; //导入依赖的package包/类
@Override
public InstrumentedType prepare(InstrumentedType instrumentedType) {
    return instrumentedType
            .withField(new FieldDescription.Token(name,
                    Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_VOLATILE | Opcodes.ACC_SYNTHETIC,
                    fieldType.asGenericType()))
            .withInitializer(new LoadedTypeInitializer.ForStaticField(name, value));
}
 

import net.bytebuddy.dynamic.scaffold.InstrumentedType; //导入依赖的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.InstrumentedType; //导入依赖的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.InstrumentedType; //导入依赖的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.InstrumentedType; //导入依赖的package包/类
@Test
@SuppressWarnings("unchecked")
public void testRedefineFrozen() throws Exception {
    when(byteBuddy.with(InstrumentedType.Factory.Default.FROZEN)).thenReturn(byteBuddy);
    when(byteBuddy.redefine(typeDescription, classFileLocator)).thenReturn((DynamicType.Builder) dynamicTypeBuilder);
    when(dynamicTypeBuilder.ignoreAlso(LatentMatcher.ForSelfDeclaredMethod.NOT_DECLARED)).thenReturn((DynamicType.Builder) dynamicTypeBuilder);
    assertThat(AgentBuilder.TypeStrategy.Default.REDEFINE_FROZEN.builder(typeDescription, byteBuddy, classFileLocator, methodNameTransformer),
            is((DynamicType.Builder) dynamicTypeBuilder));
    verify(byteBuddy).with(InstrumentedType.Factory.Default.FROZEN);
    verify(byteBuddy).redefine(typeDescription, classFileLocator);
    verifyNoMoreInteractions(byteBuddy);
    verify(dynamicTypeBuilder).ignoreAlso(LatentMatcher.ForSelfDeclaredMethod.NOT_DECLARED);
    verifyNoMoreInteractions(dynamicTypeBuilder);
}
 

import net.bytebuddy.dynamic.scaffold.InstrumentedType; //导入依赖的package包/类
@Override
public InstrumentedType prepare(InstrumentedType instrumentedType) {
    return instrumentedType.withField(new FieldDescription.Token(FOO,
            MODIFIERS,
            TypeDescription.Generic.OBJECT,
            Collections.singletonList(AnnotationDescription.Builder.ofType(SampleAnnotation.class).define(FOO, BAR).build())));
}
 

import net.bytebuddy.dynamic.scaffold.InstrumentedType; //导入依赖的package包/类
@Override
public InstrumentedType prepare(InstrumentedType p1) {
	return p1;
}
 

import net.bytebuddy.dynamic.scaffold.InstrumentedType; //导入依赖的package包/类
@Override
public InstrumentedType prepare(InstrumentedType instrumentedType) {
  return instrumentedType;
}
 

import net.bytebuddy.dynamic.scaffold.InstrumentedType; //导入依赖的package包/类
@Override
public final InstrumentedType prepare(InstrumentedType instrumentedType) {
    return instrumentedType;
}
 

import net.bytebuddy.dynamic.scaffold.InstrumentedType; //导入依赖的package包/类
public InstrumentedType prepare(InstrumentedType instrumentedType) {
  return instrumentedType;
}