Java SuperMethodCall类代码示例

import net.bytebuddy.implementation.SuperMethodCall; //导入依赖的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.implementation.SuperMethodCall; //导入依赖的package包/类
public static Class extendClass(Class<?> extend, final LuaTable delegations, Class<?>... inherit) {
	long startTime = System.nanoTime();

	ArrayDeque<Class> toCheck = new ArrayDeque<Class>();
	toCheck.add(extend);
	toCheck.addAll(Arrays.asList(inherit));
	extendClassWhile(toCheck, delegations);

	try {
		ReceiverTypeDefinition<?> build = b.subclass(extend).implement(inherit)
				.method(not(isConstructor()).and(isAbstract()))
				.intercept(MethodDelegation.to(new AbstractInterceptor(delegations)));
		if (!delegations.get("__new__").isnil()) {
			build = build.constructor(isConstructor()).intercept(
					SuperMethodCall.INSTANCE.andThen(MethodDelegation.to(new ConstructorInterceptor(delegations))));
		}
		Junction<MethodDescription> publicMethods = not(isConstructor().or(isAbstract())).and(isPublic())
				.and(new ElementMatcher<MethodDescription>() {
					@Override
					public boolean matches(MethodDescription target) {
						return !delegations.get(target.getName()).isnil();
					}
				});
		build = build.method(publicMethods).intercept(MethodDelegation.to(new PublicInterceptor(delegations)));

		Unloaded unloaded = build.make();
		Loaded loaded = Compatibility.get().load(unloaded);
		Class c = loaded.getLoaded();
		Log.debug("Created dynamic class " + c.getName() + " in " + ((System.nanoTime() - startTime) / 1000000)
				+ "ms");
		return c;
	} catch (Exception e) {
		Log.error("Failed to create dynamic class " + extend.getName() + " " + Arrays.toString(inherit));
		throw new CubesException("Failed to make dynamic class", e);
	}
}
 

import net.bytebuddy.implementation.SuperMethodCall; //导入依赖的package包/类
/**
 * <p>
 * Creates a new {@link Enum} type.
 * </p>
 * <p>
 * <b>Note</b>: Byte Buddy does not cache previous subclasses but will attempt the generation of a new subclass. For caching
 * types, a external cache or {@link TypeCache} should be used.
 * </p>
 *
 * @param values The names of the type's enumeration constants
 * @return A type builder for creating an enumeration type.
 */
public DynamicType.Builder<? extends Enum<?>> makeEnumeration(Collection<? extends String> values) {
    if (values.isEmpty()) {
        throw new IllegalArgumentException("Require at least one enumeration constant");
    }
    TypeDescription.Generic enumType = TypeDescription.Generic.Builder.parameterizedType(Enum.class, TargetType.class).build();
    return new SubclassDynamicTypeBuilder<Enum<?>>(instrumentedTypeFactory.subclass(namingStrategy.subclass(enumType),
            ModifierContributor.Resolver.of(Visibility.PUBLIC, TypeManifestation.FINAL, EnumerationState.ENUMERATION).resolve(),
            enumType),
            classFileVersion,
            auxiliaryTypeNamingStrategy,
            annotationValueFilterFactory,
            annotationRetention,
            implementationContextFactory,
            methodGraphCompiler,
            typeValidation,
            ignoredMethods,
            ConstructorStrategy.Default.NO_CONSTRUCTORS)
            .defineConstructor(Visibility.PRIVATE).withParameters(String.class, int.class)
            .intercept(SuperMethodCall.INSTANCE)
            .defineMethod(EnumerationImplementation.ENUM_VALUE_OF_METHOD_NAME,
                    TargetType.class,
                    Visibility.PUBLIC, Ownership.STATIC).withParameters(String.class)
            .intercept(MethodCall.invoke(enumType.getDeclaredMethods()
                    .filter(named(EnumerationImplementation.ENUM_VALUE_OF_METHOD_NAME).and(takesArguments(Class.class, String.class))).getOnly())
                    .withOwnType().withArgument(0)
                    .withAssigner(Assigner.DEFAULT, Assigner.Typing.DYNAMIC))
            .defineMethod(EnumerationImplementation.ENUM_VALUES_METHOD_NAME,
                    TargetType[].class,
                    Visibility.PUBLIC, Ownership.STATIC)
            .intercept(new EnumerationImplementation(new ArrayList<String>(values)));
}
 

import net.bytebuddy.implementation.SuperMethodCall; //导入依赖的package包/类
@Override
protected MethodRegistry doInject(MethodRegistry methodRegistry, MethodAttributeAppender.Factory methodAttributeAppenderFactory) {
    return methodRegistry.append(new LatentMatcher.Resolved<MethodDescription>(isConstructor()),
            new MethodRegistry.Handler.ForImplementation(SuperMethodCall.INSTANCE),
            methodAttributeAppenderFactory,
            Transformer.NoOp.<MethodDescription>make());
}
 

import net.bytebuddy.implementation.SuperMethodCall; //导入依赖的package包/类
@Override
public DynamicType.Builder<?> transform(DynamicType.Builder<?> builder,
                                        TypeDescription typeDescription,
                                        ClassLoader classLoader,
                                        JavaModule module) {
    return builder.constructor(ElementMatchers.any()).intercept(SuperMethodCall.INSTANCE);
}
 

import net.bytebuddy.implementation.SuperMethodCall; //导入依赖的package包/类
@Test
public void testConstructorRebaseSingleAuxiliaryType() throws Exception {
    DynamicType.Unloaded<?> dynamicType = new ByteBuddy()
            .rebase(Bar.class)
            .constructor(any()).intercept(SuperMethodCall.INSTANCE)
            .make();
    assertThat(dynamicType.getAuxiliaryTypes().size(), is(1));
    Class<?> type = dynamicType.load(new URLClassLoader(new URL[0], null), ClassLoadingStrategy.Default.WRAPPER).getLoaded();
    assertThat(type.getDeclaredConstructors().length, is(2));
    assertThat(type.getDeclaredMethods().length, is(0));
    Field field = type.getDeclaredField(BAR);
    assertThat(field.get(type.getDeclaredConstructor(String.class).newInstance(FOO)), is((Object) FOO));
}
 

import net.bytebuddy.implementation.SuperMethodCall; //导入依赖的package包/类
@Test
public void testRebaseOfRenamedType() throws Exception {
    Class<?> rebased = new ByteBuddy()
            .rebase(Sample.class)
            .name(Sample.class.getName() + FOO)
            .constructor(ElementMatchers.any())
            .intercept(SuperMethodCall.INSTANCE)
            .make()
            .load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER)
            .getLoaded();
    assertThat(rebased.getName(), is(Sample.class.getName() + FOO));
    assertThat(rebased.getDeclaredConstructors().length, is(2));
}
 

import net.bytebuddy.implementation.SuperMethodCall; //导入依赖的package包/类
@Test(expected = IllegalStateException.class)
public void testCannotRebaseDefinedMethod() throws Exception {
    new ByteBuddy()
            .rebase(Foo.class)
            .defineMethod(FOO, void.class).intercept(SuperMethodCall.INSTANCE)
            .make();
}
 

import net.bytebuddy.implementation.SuperMethodCall; //导入依赖的package包/类
@Test(expected = IllegalStateException.class)
public void testConstructorOnInterfaceAssertion() throws Exception {
    new ByteBuddy()
            .makeInterface()
            .defineConstructor(Visibility.PUBLIC)
            .intercept(SuperMethodCall.INSTANCE)
            .make();
}
 

import net.bytebuddy.implementation.SuperMethodCall; //导入依赖的package包/类
@Test(expected = IllegalStateException.class)
public void testConstructorOnAnnotationAssertion() throws Exception {
    new ByteBuddy()
            .makeAnnotation()
            .defineConstructor(Visibility.PUBLIC)
            .intercept(SuperMethodCall.INSTANCE)
            .make();
}
 

import net.bytebuddy.implementation.SuperMethodCall; //导入依赖的package包/类
@Test(expected = IllegalStateException.class)
@JavaVersionRule.Enforce(8)
public void testDefaultMethodCallFromLegacyType() throws Exception {
    new ByteBuddy(ClassFileVersion.JAVA_V7)
            .subclass(Class.forName("net.bytebuddy.test.precompiled.SingleDefaultMethodInterface"))
            .method(isDefaultMethod())
            .intercept(SuperMethodCall.INSTANCE)
            .make();
}
 

import net.bytebuddy.implementation.SuperMethodCall; //导入依赖的package包/类
/**
 * Performs a benchmark of a class extension using Byte Buddy. This benchmark uses delegation but completes with a
 * hard-coded super method call.
 *
 * @return The created instance, in order to avoid JIT removal.
 * @throws Exception If the invocation causes an exception.
 */
@Benchmark
public ExampleClass benchmarkByteBuddyWithPrefix() throws Exception {
    return new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .ignore(none())
            .subclass(baseClass)
            .method(isDeclaredBy(baseClass)).intercept(MethodDelegation.to(ByteBuddyPrefixInterceptor.class).andThen(SuperMethodCall.INSTANCE))
            .make()
            .load(newClassLoader(), ClassLoadingStrategy.Default.INJECTION)
            .getLoaded()
            .getDeclaredConstructor()
            .newInstance();
}
 

import net.bytebuddy.implementation.SuperMethodCall; //导入依赖的package包/类
/**
 * Performs a benchmark of a class extension using Byte Buddy. This benchmark uses delegation but completes with a
 * hard-coded super method call. 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 benchmarkByteBuddyWithPrefixAndReusedDelegator() throws Exception {
    return new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .ignore(none())
            .subclass(baseClass)
            .method(isDeclaredBy(baseClass)).intercept(prefixInterceptor.andThen(SuperMethodCall.INSTANCE))
            .make()
            .load(newClassLoader(), ClassLoadingStrategy.Default.INJECTION)
            .getLoaded()
            .getDeclaredConstructor()
            .newInstance();
}
 

import net.bytebuddy.implementation.SuperMethodCall; //导入依赖的package包/类
/**
 * Performs a benchmark of a class extension using Byte Buddy. This benchmark uses delegation but completes with a
 * hard-coded super method call. 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 benchmarkByteBuddyWithPrefixWithTypePool() throws Exception {
    return (ExampleClass) new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .ignore(none())
            .subclass(baseClassDescription)
            .method(isDeclaredBy(baseClassDescription)).intercept(MethodDelegation.to(prefixClassDescription).andThen(SuperMethodCall.INSTANCE))
            .make()
            .load(newClassLoader(), ClassLoadingStrategy.Default.INJECTION)
            .getLoaded()
            .getDeclaredConstructor()
            .newInstance();
}
 

import net.bytebuddy.implementation.SuperMethodCall; //导入依赖的package包/类
/**
 * Performs a benchmark of a class extension using Byte Buddy. This benchmark uses delegation but completes with a
 * hard-coded super method call. 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 benchmarkByteBuddyWithPrefixAndReusedDelegatorWithTypePool() throws Exception {
    return (ExampleClass) new ByteBuddy()
            .with(TypeValidation.DISABLED)
            .ignore(none())
            .subclass(baseClassDescription)
            .method(isDeclaredBy(baseClassDescription)).intercept(prefixInterceptorDescription.andThen(SuperMethodCall.INSTANCE))
            .make()
            .load(newClassLoader(), ClassLoadingStrategy.Default.INJECTION)
            .getLoaded()
            .getDeclaredConstructor()
            .newInstance();
}