import net.bytebuddy.dynamic.DynamicType; //导入依赖的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.dynamic.DynamicType; //导入依赖的package包/类
public static <T> Class<?> build(Class<T> origin, String name, MethodInclusion methodInclusion, Object interceptor) {
    DynamicType.Builder<T> builder = new ByteBuddy()
            .subclass(origin).name(proxyClassName(name));
    Class<?> cachedClass = classCache.get(origin);
    if (cachedClass != null) {
        return cachedClass;
    }
    Class<? extends T> proxied = builder
            .method(methodInclusion.getIncludes())
            .intercept(MethodDelegation.to(interceptor))
            .make()
            .load(ProxyClassBuilder.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    classCache.putIfAbsent(origin, proxied);
    return proxied;
}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
/**
 * Build a Swagger API listing JAX-RS endpoint class, binding it to given <code>path</code> using standard JAX-RS
 * {@link Path} annotation.
 * @param classLoader ClassLoader to use to create the class proxy
 * @param apiGroupId API group id
 * @param path Endpoint path
 * @param authSchemes Authenticatiob schemes
 * @param rolesAllowed Optional security roles for endpoint authorization
 * @return The Swagger API listing JAX-RS endpoint class proxy
 */
public static Class<?> buildApiListingEndpoint(ClassLoader classLoader, String apiGroupId, String path,
		String[] authSchemes, String[] rolesAllowed) {
	String configId = (apiGroupId != null && !apiGroupId.trim().equals("")) ? apiGroupId
			: ApiGroupId.DEFAULT_GROUP_ID;
	final ClassLoader cl = (classLoader != null) ? classLoader : ClassUtils.getDefaultClassLoader();
	DynamicType.Builder<SwaggerApiListingResource> builder = new ByteBuddy()
			.subclass(SwaggerApiListingResource.class)
			.annotateType(AnnotationDescription.Builder.ofType(Path.class).define("value", path).build())
			.annotateType(AnnotationDescription.Builder.ofType(ApiGroupId.class).define("value", configId).build());
	if (authSchemes != null && authSchemes.length > 0) {
		if (authSchemes.length == 1 && authSchemes[0] != null && authSchemes[0].trim().equals("*")) {
			builder = builder.annotateType(AnnotationDescription.Builder.ofType(Authenticate.class).build());
		} else {
			builder = builder.annotateType(AnnotationDescription.Builder.ofType(Authenticate.class)
					.defineArray("schemes", authSchemes).build());
		}
	}
	if (rolesAllowed != null && rolesAllowed.length > 0) {
		builder = builder.annotateType(AnnotationDescription.Builder.ofType(RolesAllowed.class)
				.defineArray("value", rolesAllowed).build());
	}
	return builder.make().load(cl, ClassLoadingStrategy.Default.INJECTION).getLoaded();
}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
@Override
public final void check() throws Exception {
    final TypeDescription typeDescription = new TypeDescription.ForLoadedType(clazz);
    final DynamicType.Builder<?> subclass = new ByteBuddy().redefine(clazz);
    final DynamicType.Unloaded<?> make = bt
            .transitionResult(subclass, typeDescription)
            .value()
            .get()
            .make();
    final Class<?> newClazz = make.load(new AnonymousClassLoader()).getLoaded();
    assertThat(
        List.of(newClazz.getDeclaredMethods()).map(Method::getName)
    ).containsOnlyElementsOf(
        methodNames
    );
}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
private static <C> C createMethodIdProxy(final Class<C> interfaceToProxy, final Optional<String> scopeNameOpt)
{
    final List<ConfigDescriptor> configDescList = ConfigSystem.descriptorFactory.buildDescriptors(interfaceToProxy, scopeNameOpt);

    DynamicType.Builder<C> typeBuilder = new ByteBuddy().subclass(interfaceToProxy);
    for (ConfigDescriptor desc : configDescList) {
        typeBuilder = typeBuilder.method(ElementMatchers.is(desc.getMethod())).intercept(InvocationHandlerAdapter.of((Object proxy, Method method1, Object[] args) -> {
            log.trace("BB InvocationHandler identifying method {} proxy {}, argCount {}", method1.getName(), proxy.toString(), args.length);
            lastIdentifiedMethodAndScope.set(new MethodAndScope(method1, scopeNameOpt));
            return defaultForType(desc.getMethod().getReturnType());
        }));
    }

    Class<? extends C> configImpl = typeBuilder.make()
        .load(interfaceToProxy.getClassLoader(), ClassLoadingStrategy.Default.INJECTION)
        .getLoaded();
    try {
        return configImpl.newInstance();
    }
    catch (InstantiationException | IllegalAccessException ex) {
        throw new ConfigException("Failed to instantiate identification implementation of Config {} scope {}",
            interfaceToProxy.getName(), scopeNameOpt.orElse("<empty>"), ex);
    }
}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
private Object createInstanceWithFields(Parameter[] parameters)
{
    DynamicType.Builder<Object> objectBuilder = new ByteBuddy().subclass(Object.class)
            .modifiers(PUBLIC);
    for (Parameter parameter : parameters) {
        objectBuilder = objectBuilder.defineField(parameter.getName(), parameter.getType(), PUBLIC)
                .annotateField(ArrayUtils.add(parameter.getAnnotations(), INJECT_ANNOTATION));
    }
    try {
        Class<?> createdClass = objectBuilder.make()
                .load(getSystemClassLoader(), ClassLoadingStrategy.Default.INJECTION)
                .getLoaded();
        return createdClass
                .getConstructor()
                .newInstance();
    }
    catch (ReflectiveOperationException e) {
        throw new RuntimeException(e);
    }
}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
@Override
public <E> DynamicType.Builder<E> processMethod(final DynamicType.Builder<E> builder, final Method method, final Annotation annotation) {
    final java.lang.reflect.Parameter[] arguments = method.getParameters();

    if (ReflectionUtility.isSetMethod(method))
        if (arguments == null || arguments.length == 0)
            throw new IllegalStateException(method.getName() + " was annotated with @Property but had no arguments.");
        else if (arguments.length == 1)
            return this.setProperty(builder, method, annotation);
        else
            throw new IllegalStateException(method.getName() + " was annotated with @Property but had more than 1 arguments.");
    else if (ReflectionUtility.isGetMethod(method))
        if (arguments == null || arguments.length == 0)
            return this.getProperty(builder, method, annotation);
        else
            throw new IllegalStateException(method.getName() + " was annotated with @Property but had arguments.");
    else if (ReflectionUtility.isRemoveMethod(method))
        if (arguments == null || arguments.length == 0)
            return this.removeProperty(builder, method, annotation);
        else
            throw new IllegalStateException(method.getName() + " was annotated with @Property but had some arguments.");
    else
        throw new IllegalStateException(method.getName() + " was annotated with @Property but did not begin with either of the following keywords: add, get");
}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
@Test
public void testCustomHandlers() {
    MethodHandler custom = Mockito.mock(AbstractMethodHandler.class, Mockito.CALLS_REAL_METHODS);
    Class<? extends Annotation> annotation = Adjacency.class;
    custom = Mockito.when(custom.getAnnotationType()).then(inv -> annotation).getMock();
    custom = Mockito
            .when(custom.processMethod(Mockito.any(), Mockito.any(), Mockito.any()))
            .thenAnswer(inv -> inv.getArgumentAt(0, DynamicType.Builder.class))
            .getMock();
    AbstractAnnotationFrameFactory frameFactory = new AbstractAnnotationFrameFactory(new ReflectionCache(), Collections.singleton(custom)) {
    };
    DelegatingFramedGraph framedGraph = new DelegatingFramedGraph(fg.getBaseGraph(), frameFactory, new PolymorphicTypeResolver());
    framedGraph.addFramedVertex(God.class);
    Mockito.verify(custom, Mockito.atLeast(0)).getAnnotationType();
    Mockito.verify(custom, Mockito.atLeastOnce()).processMethod(Mockito.any(), Mockito.any(), Mockito.any());
}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
@Test
public void testRetrieveFromArray() throws Exception {
    DynamicType.Unloaded<RetrieveFromArray> arr = new ByteBuddy().subclass(RetrieveFromArray.class)
                    .method(ElementMatchers.isDeclaredBy(RetrieveFromArray.class))
                    .intercept(new Implementation.Compound(new LoadReferenceParamImplementation(1),
                                    new RelativeRetrieveArrayImplementation(1),
                                    new ReturnAppenderImplementation(ReturnAppender.ReturnType.INT)))
                    .make();


    Class<?> dynamicType = arr.load(RetrieveFromArray.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
                    .getLoaded();

    RetrieveFromArray test = (RetrieveFromArray) dynamicType.newInstance();
    int result = test.returnVal(0, 1);
    assertEquals(1, result);

}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
@Test
public void inPlaceSet() throws Exception {
    DynamicType.Unloaded<SetValueInPlace> val =
                    new ByteBuddy().subclass(SetValueInPlace.class)
                                    .method(ElementMatchers.isDeclaredBy(SetValueInPlace.class))
                                    .intercept(new StackManipulationImplementation(new StackManipulation.Compound(
                                                    MethodVariableAccess.REFERENCE.loadOffset(1),
                                                    MethodVariableAccess.INTEGER.loadOffset(2),
                                                    MethodVariableAccess.INTEGER.loadOffset(3),
                                                    ArrayStackManipulation.store(), MethodReturn.VOID)))
                                    .make();

    val.saveIn(new File("target"));
    SetValueInPlace dv = val.load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER).getLoaded()
                    .newInstance();
    int[] ret = {2, 4};
    int[] assertion = {1, 4};
    dv.update(ret, 0, 1);
    assertArrayEquals(assertion, ret);
}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
@Test
public void inPlaceDivide() throws Exception {
    DynamicType.Unloaded<SetValueInPlace> val = new ByteBuddy().subclass(SetValueInPlace.class)
                    .method(ElementMatchers.isDeclaredBy(SetValueInPlace.class))
                    .intercept(new StackManipulationImplementation(new StackManipulation.Compound(
                                    MethodVariableAccess.REFERENCE.loadOffset(1),
                                    MethodVariableAccess.INTEGER.loadOffset(2), Duplication.DOUBLE,
                                    ArrayStackManipulation.load(), MethodVariableAccess.INTEGER.loadOffset(3),
                                    OpStackManipulation.div(), ArrayStackManipulation.store(), MethodReturn.VOID)))
                    .make();

    val.saveIn(new File("target"));
    SetValueInPlace dv = val.load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER).getLoaded()
                    .newInstance();
    int[] ret = {2, 4};
    int[] assertion = {1, 4};
    dv.update(ret, 0, 2);
    assertArrayEquals(assertion, ret);
}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
@Test
public void testCreateAndAssign() throws Exception {
    DynamicType.Unloaded<CreateAndAssignArray> arr = new ByteBuddy().subclass(CreateAndAssignArray.class)
                    .method(ElementMatchers.isDeclaredBy(CreateAndAssignArray.class))
                    .intercept(new Implementation.Compound(new IntArrayCreation(5), new DuplicateImplementation(),
                                    new RelativeArrayAssignWithValueImplementation(0, 5),
                                    new ReturnAppenderImplementation(ReturnAppender.ReturnType.REFERENCE)))
                    .make();


    Class<?> dynamicType =
                    arr.load(CreateAndAssignArray.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
                                    .getLoaded();

    CreateAndAssignArray test = (CreateAndAssignArray) dynamicType.newInstance();
    int[] result = test.create();
    assertEquals(5, result[0]);
}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
@Test
public void testCreateInt() throws Exception {
    DynamicType.Unloaded<CreateAndAssignIntArray> arr = new ByteBuddy().subclass(CreateAndAssignIntArray.class)
                    .method(ElementMatchers.isDeclaredBy(CreateAndAssignIntArray.class))
                    .intercept(new Implementation.Compound(new ConstantIntImplementation(1),
                                    new StoreIntImplementation(0), new LoadIntegerImplementation(0),
                                    new ReturnAppenderImplementation(ReturnAppender.ReturnType.INT)))
                    .make();


    Class<?> dynamicType =
                    arr.load(CreateAndAssignIntArray.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
                                    .getLoaded();

    CreateAndAssignIntArray test = (CreateAndAssignIntArray) dynamicType.newInstance();
    int result = test.returnVal();
    assertEquals(1, result);

}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private <Z extends CallTraceable> void testSetter(Class<Z> target, Implementation implementation) throws Exception {
    DynamicType.Loaded<Z> loaded = new ByteBuddy()
            .subclass(target)
            .method(isDeclaredBy(target))
            .intercept(implementation)
            .make()
            .load(target.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER);
    assertThat(loaded.getLoadedAuxiliaryTypes().size(), is(0));
    assertThat(loaded.getLoaded().getDeclaredMethods().length, is(1));
    assertThat(loaded.getLoaded().getDeclaredFields().length, is(0));
    Z instance = loaded.getLoaded().getDeclaredConstructor().newInstance();
    assertThat(instance.getClass(), not(CoreMatchers.<Class<?>>is(target)));
    assertThat(instance, instanceOf(target));
    Method setter = loaded.getLoaded()
            .getDeclaredMethod(SET + Character.toUpperCase(FOO.charAt(0)) + FOO.substring(1), propertyType);
    assertThat(setter.invoke(instance, value), nullValue());
    instance.assertZeroCalls();
    assertFieldValue(target, instance);
}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
@Test
public void testStaticAdapterWithMethodCache() throws Exception {
    Foo foo = new Foo();
    DynamicType.Loaded<Bar> loaded = new ByteBuddy()
            .subclass(Bar.class)
            .method(isDeclaredBy(Bar.class))
            .intercept(InvocationHandlerAdapter.of(foo))
            .make()
            .load(Bar.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER);
    assertThat(loaded.getLoadedAuxiliaryTypes().size(), is(0));
    assertThat(loaded.getLoaded().getDeclaredMethods().length, is(1));
    assertThat(loaded.getLoaded().getDeclaredFields().length, is(2));
    Bar instance = loaded.getLoaded().getDeclaredConstructor().newInstance();
    assertThat(instance.bar(FOO), is((Object) instance));
    assertThat(foo.methods.size(), is(1));
    assertThat(instance.bar(FOO), is((Object) instance));
    assertThat(foo.methods.size(), is(2));
    assertThat(foo.methods.get(0), sameInstance(foo.methods.get(1)));
    instance.assertZeroCalls();
}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
@Test
public void testWithOwnType() throws Exception {
    DynamicType.Loaded<MethodCallWithOwnType> loaded = new ByteBuddy()
            .subclass(MethodCallWithOwnType.class)
            .method(isDeclaredBy(MethodCallWithOwnType.class))
            .intercept(MethodCall.invokeSuper().withOwnType())
            .make()
            .load(MethodCallWithOwnType.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER);
    assertThat(loaded.getLoadedAuxiliaryTypes().size(), is(0));
    assertThat(loaded.getLoaded().getDeclaredMethods().length, is(1));
    assertThat(loaded.getLoaded().getDeclaredMethod(FOO, Class.class), not(nullValue(Method.class)));
    assertThat(loaded.getLoaded().getDeclaredConstructors().length, is(1));
    assertThat(loaded.getLoaded().getDeclaredFields().length, is(0));
    MethodCallWithOwnType instance = loaded.getLoaded().getDeclaredConstructor().newInstance();
    assertThat(instance.getClass(), not(CoreMatchers.<Class<?>>is(MethodCallWithThis.class)));
    assertThat(instance, instanceOf(MethodCallWithOwnType.class));
    assertThat(instance.foo(null), CoreMatchers.<Class<?>>is(loaded.getLoaded()));
}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
@Test
public void testWithArgumentsAsArray() throws Exception {
    DynamicType.Loaded<ArrayConsuming> loaded = new ByteBuddy()
            .subclass(ArrayConsuming.class)
            .method(named(FOO))
            .intercept(MethodCall.invoke(ArrayConsuming.class.getDeclaredMethod(BAR, String[].class)).withArgumentArray())
            .make()
            .load(ArrayConsuming.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER);
    assertThat(loaded.getLoadedAuxiliaryTypes().size(), is(0));
    assertThat(loaded.getLoaded().getDeclaredMethods().length, is(1));
    assertThat(loaded.getLoaded().getDeclaredMethod(FOO, String.class, String.class), not(nullValue(Method.class)));
    assertThat(loaded.getLoaded().getDeclaredConstructors().length, is(1));
    assertThat(loaded.getLoaded().getDeclaredFields().length, is(0));
    ArrayConsuming instance = loaded.getLoaded().getDeclaredConstructor().newInstance();
    assertThat(instance.getClass(), not(CoreMatchers.<Class<?>>is(ArrayConsuming.class)));
    assertThat(instance, instanceOf(ArrayConsuming.class));
    assertThat(instance.foo(FOO, BAR), is(FOO + BAR));
}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
@Test
@JavaVersionRule.Enforce(value = 7, hotSpot = 7)
public void testJava7TypesExplicit() throws Exception {
    DynamicType.Loaded<SimpleMethod> loaded = new ByteBuddy()
            .subclass(SimpleMethod.class)
            .method(named(FOO))
            .intercept(MethodCall.invoke(Foo.class.getDeclaredMethod(BAR, Object.class, Object.class))
                    .with(JavaConstant.MethodHandle.ofLoaded(makeMethodHandle()), JavaConstant.MethodType.ofLoaded(makeMethodType(void.class))))
            .make()
            .load(SimpleMethod.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER);
    assertThat(loaded.getLoadedAuxiliaryTypes().size(), is(0));
    assertThat(loaded.getLoaded().getDeclaredMethods().length, is(1));
    assertThat(loaded.getLoaded().getDeclaredFields().length, is(0));
    SimpleMethod instance = loaded.getLoaded().getDeclaredConstructor().newInstance();
    assertThat(instance.foo(), is("" + makeMethodHandle() + makeMethodType(void.class)));
    assertThat(instance.getClass(), not(CoreMatchers.<Class<?>>is(SimpleMethod.class)));
    assertThat(instance, instanceOf(SimpleMethod.class));
}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
@Test
public void testInvokeOnArgumentDynamic() throws Exception {
    DynamicType.Loaded<ArgumentCallDynamic> loaded = new ByteBuddy()
            .subclass(ArgumentCallDynamic.class)
            .method(isDeclaredBy(ArgumentCallDynamic.class))
            .intercept(MethodCall.invoke(ArgumentCallDynamic.Target.class.getDeclaredMethod("foo")).onArgument(0)
                    .withAssigner(Assigner.DEFAULT, Assigner.Typing.DYNAMIC))
            .make()
            .load(ArgumentCallDynamic.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER);
    assertThat(loaded.getLoadedAuxiliaryTypes().size(), is(0));
    assertThat(loaded.getLoaded().getDeclaredMethods().length, is(1));
    assertThat(loaded.getLoaded().getDeclaredFields().length, is(0));
    ArgumentCallDynamic instance = loaded.getLoaded().getDeclaredConstructor().newInstance();
    assertThat(instance.foo(new ArgumentCallDynamic.Target(BAR)), is(BAR));
    assertThat(instance.getClass(), not(CoreMatchers.<Class<?>>is(InstanceMethod.class)));
    assertThat(instance, instanceOf(ArgumentCallDynamic.class));
}
 

import net.bytebuddy.dynamic.DynamicType; //导入依赖的package包/类
/**
 * The handling method.
 */
@Override
public <E> DynamicType.Builder<E> processMethod(final DynamicType.Builder<E> builder, final Method method, final Annotation annotation)
{
    String methodName = method.getName();
    if (ReflectionUtility.isGetMethod(method))
        return createInterceptor(builder, method);
    else if (ReflectionUtility.isSetMethod(method))
        return createInterceptor(builder, method);
    else if (methodName.startsWith("addAll"))
        return createInterceptor(builder, method);
    else if (methodName.startsWith("add"))
        return createInterceptor(builder, method);
    else
        throw new WindupException("Only get*, set*, add*, and addAll* method names are supported for @"
                    + SetInProperties.class.getSimpleName() + ", found at: " + method.getName());
}