Java TypeDescription.ForLoadedType方法代码示例

import net.bytebuddy.description.type.TypeDescription; //导入方法依赖的package包/类
@Override
public final Result<StackManipulation> result() {
    final TypeDescription declaringType = field.getDeclaringType().asErasure();
    final TypeDescription fieldType = field.getType().asErasure();
    if(new NaturalJavaAtom().matches(fieldType)) {
        return new SmtInvokeMethod(
            new TypeDescription.ForLoadedType(Object.class),
            ElementMatchers.named("equals")
        );
    } else {
        return new SmtInvokeMethod(
            declaringType,
            new ConjunctionMatcher<>(
                ElementMatchers.isSynthetic(),
                ElementMatchers.named("atom$equal")
            )
        );
    }
}
 

import net.bytebuddy.description.type.TypeDescription; //导入方法依赖的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.description.type.TypeDescription; //导入方法依赖的package包/类
public AssertValidatorSuccessTest() {
    super(
        new TestCase(
            "passes when validator under test passes",
            new AssertAssertionPasses(
                new AssertValidatorSuccess(
                    new ValSuccess(),
                    new TypeDescription.ForLoadedType(Object.class)
                )
            )
        ),
        new TestCase(
            "fails when validator under test fails",
            new AssertAssertionFails(
                new AssertValidatorSuccess(
                    new ValFail(
                        "Just as planned"
                    ),
                    new TypeDescription.ForLoadedType(Object.class)
                )
            )
        )
    );
}
 

import net.bytebuddy.description.type.TypeDescription; //导入方法依赖的package包/类
public AssertValidatorFailureTest() {
    super(
        new TestCase(
            "passes when validator fails",
            new AssertAssertionPasses(
                new AssertValidatorFailure(
                    new ValFail("Just as planned"),
                    new TypeDescription.ForLoadedType(Object.class),
                    "Just as planned"
                )
            )
        ),
        new TestCase(
            "fails when validator passes",
            new AssertAssertionFails(
                new AssertValidatorFailure(
                    new ValSuccess(),
                    new TypeDescription.ForLoadedType(Object.class),
                    "Expected failure"
                )
            )
        )
    );
}
 

import net.bytebuddy.description.type.TypeDescription; //导入方法依赖的package包/类
public SmtBoxTest() {
    super(
        new TestCase(
            "attempt to box non-primitive must fail",
            new AssertResultIsErroneous(
                new SmtBox(
                    new TypeDescription.ForLoadedType(Object.class)
                ),
                "Attempt to box non-primitive type java.lang.Object"
            )
        ),
        new TestCase(
            "can box integer primitive", 
            new AssertTokenToRepresentExpectedStackManipulation(
                new SmtBox(
                    new TypeDescription.ForLoadedType(int.class)
                ),
                () -> MethodInvocation.invoke(new MethodDescription.ForLoadedMethod(INT_VALUEOF))
            )
        )
    );
}
 

import net.bytebuddy.description.type.TypeDescription; //导入方法依赖的package包/类
public ExtendingTest() {
    super(
        new TestCase(
            "matches types inherited from atom", 
            new AssertThatTypeMatches(
                new TypeDescription.ForLoadedType(
                    Bar.class
                ), 
                new Extending(
                    ElementMatchers.anyOf(Foo.class)
                )
            )
        ),
        new TestCase(
            "mismatch atoms",
            new AssertThatTypeDoesNotMatch(
                new TypeDescription.ForLoadedType(
                    Foo.class
                ), 
                new Extending(
                    ElementMatchers.anyOf(Foo.class)
                )
            )
        )
    );
}
 

import net.bytebuddy.description.type.TypeDescription; //导入方法依赖的package包/类
public IsNotAbstractTest() {
    super(
        new TestCase(
            "match non-abstract classes",
            new AssertThatTypeMatches(
                new TypeDescription.ForLoadedType(Foo.class),
                new IsNotAbstract()
            )
        ),
        new TestCase(
            "mismatch abstract classes",
            new AssertThatTypeDoesNotMatch(
                new TypeDescription.ForLoadedType(Bar.class),
                new IsNotAbstract()
            )
        ),
        new TestCase(
            "match enumeration types",
            new AssertThatTypeMatches(
                new TypeDescription.ForLoadedType(Faz.class),
                new IsNotAbstract()
            )
        )
    );
}
 

import net.bytebuddy.description.type.TypeDescription; //导入方法依赖的package包/类
public NoMethodsTest() {
    super(
        new TestCase(
            "match type with no methods",
            new AssertThatTypeMatches(
                new TypeDescription.ForLoadedType(Foo.class),
                new NoMethods()
            )
        ),
        new TestCase(
            "mismatch type with at least one method",
            new AssertThatTypeDoesNotMatch(
                new TypeDescription.ForLoadedType(Bar.class),
                new NoMethods()
            )
        ),
        new TestCase(
            "match type ignoring methods declared in base class",
            new AssertThatTypeMatches(
                new TypeDescription.ForLoadedType(Barr.class),
                new NoMethods()
            )
        )
    );
}
 

import net.bytebuddy.description.type.TypeDescription; //导入方法依赖的package包/类
public NoFieldsTest() {
    super(
        new TestCase(
            "match type with no fields",
            new AssertThatTypeMatches(
                new TypeDescription.ForLoadedType(Foo.class),
                new NoFields()
            )
        ),
        new TestCase(
            "mismatch type with at least one field",
            new AssertThatTypeDoesNotMatch(
                new TypeDescription.ForLoadedType(Bar.class),
                new NoFields()
            )
        ),
        new TestCase(
            "match type ignoring fields from the base class",
            new AssertThatTypeMatches(
                new TypeDescription.ForLoadedType(Barr.class),
                new NoFields()
            )
        )
    );
}
 

import net.bytebuddy.description.type.TypeDescription; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
public static <T> Class<T> toClass(TypeDescription type)
{
    if ((type instanceof TypeDescription.ForLoadedType) && (typeHandle != null))
    {
        try
        {
            return (Class<T>) typeHandle.invoke(type);
        }
        catch (Throwable throwable)
        {
            throwable.printStackTrace();
        }
    }
    ClassLoader classLoader = StackWalker.getInstance().getCallerClass().getClassLoader();
    try
    {
        return (Class<T>) Class.forName(type.getActualName(), false, classLoader);
    }
    catch (ClassNotFoundException e)
    {
        throw new RuntimeException(e);
    }
}
 

import net.bytebuddy.description.type.TypeDescription; //导入方法依赖的package包/类
@Test
public void testGenericClassMultipleEvolution() throws Exception {
    TypeDescription typeDescription = new TypeDescription.ForLoadedType(GenericClassBase.Intermediate.Inner.class);
    MethodGraph.Linked methodGraph = MethodGraph.Compiler.Default.forJavaHierarchy().compile(typeDescription);
    assertThat(methodGraph.listNodes().size(), is(TypeDescription.OBJECT.getDeclaredMethods().filter(isVirtual()).size() + 1));
    MethodDescription.SignatureToken token = typeDescription.getDeclaredMethods().filter(isMethod().and(ElementMatchers.not(isBridge()))).getOnly().asSignatureToken();
    MethodGraph.Node node = methodGraph.locate(token);
    MethodDescription.SignatureToken firstBridgeToken = typeDescription.getSuperClass().getDeclaredMethods()
            .filter(isMethod().and(ElementMatchers.not(isBridge()))).getOnly().asDefined().asSignatureToken();
    MethodDescription.SignatureToken secondBridgeToken = typeDescription.getSuperClass().getSuperClass().getDeclaredMethods()
            .filter(isMethod()).getOnly().asDefined().asSignatureToken();
    assertThat(node, is(methodGraph.locate(firstBridgeToken)));
    assertThat(node, is(methodGraph.locate(secondBridgeToken)));
    assertThat(node.getSort(), is(MethodGraph.Node.Sort.RESOLVED));
    assertThat(node.getMethodTypes().size(), is(3));
    assertThat(node.getMethodTypes().contains(token.asTypeToken()), is(true));
    assertThat(node.getMethodTypes().contains(firstBridgeToken.asTypeToken()), is(true));
    assertThat(node.getMethodTypes().contains(secondBridgeToken.asTypeToken()), is(true));
    assertThat(node.getVisibility(), is(Visibility.PUBLIC));
}
 

import net.bytebuddy.description.type.TypeDescription; //导入方法依赖的package包/类
@Test
public void testReturnTypeInterfaceMultipleEvolution() throws Exception {
    TypeDescription typeDescription = new TypeDescription.ForLoadedType(ReturnTypeInterfaceBase.Intermediate.Inner.class);
    MethodGraph.Linked methodGraph = MethodGraph.Compiler.Default.forJavaHierarchy().compile(typeDescription);
    assertThat(methodGraph.listNodes().size(), is(1));
    MethodDescription.SignatureToken token = typeDescription.getDeclaredMethods().filter(ElementMatchers.not(isBridge())).getOnly().asSignatureToken();
    MethodGraph.Node node = methodGraph.locate(token);
    MethodDescription.SignatureToken firstBridgeToken = typeDescription.getInterfaces().getOnly()
            .getDeclaredMethods().filter(ElementMatchers.not(isBridge())).getOnly().asSignatureToken();
    MethodDescription.SignatureToken secondBridgeToken = typeDescription.getInterfaces().getOnly().getInterfaces().getOnly()
            .getDeclaredMethods().getOnly().asSignatureToken();
    assertThat(node, is(methodGraph.locate(firstBridgeToken)));
    assertThat(node.getSort(), is(MethodGraph.Node.Sort.RESOLVED));
    assertThat(node.getMethodTypes().size(), is(3));
    assertThat(node.getMethodTypes().contains(token.asTypeToken()), is(true));
    assertThat(node.getMethodTypes().contains(firstBridgeToken.asTypeToken()), is(true));
    assertThat(node.getMethodTypes().contains(secondBridgeToken.asTypeToken()), is(true));
    assertThat(node.getVisibility(), is(Visibility.PUBLIC));
}
 

import net.bytebuddy.description.type.TypeDescription; //导入方法依赖的package包/类
@Test
public void testGenericInterfaceMultipleEvolution() throws Exception {
    TypeDescription typeDescription = new TypeDescription.ForLoadedType(GenericInterfaceBase.Intermediate.Inner.class);
    MethodGraph.Linked methodGraph = MethodGraph.Compiler.Default.forJavaHierarchy().compile(typeDescription);
    assertThat(methodGraph.listNodes().size(), is(1));
    MethodDescription.SignatureToken token = typeDescription.getDeclaredMethods().filter(ElementMatchers.not(isBridge())).getOnly().asSignatureToken();
    MethodGraph.Node node = methodGraph.locate(token);
    MethodDescription.SignatureToken firstBridgeToken = typeDescription.getInterfaces().getOnly()
            .getDeclaredMethods().filter(ElementMatchers.not(isBridge())).getOnly().asDefined().asSignatureToken();
    MethodDescription.SignatureToken secondBridgeToken = typeDescription.getInterfaces().getOnly().getInterfaces().getOnly()
            .getDeclaredMethods().getOnly().asDefined().asSignatureToken();
    assertThat(node, is(methodGraph.locate(firstBridgeToken)));
    assertThat(node, is(methodGraph.locate(secondBridgeToken)));
    assertThat(node.getSort(), is(MethodGraph.Node.Sort.RESOLVED));
    assertThat(node.getMethodTypes().size(), is(3));
    assertThat(node.getMethodTypes().contains(token.asTypeToken()), is(true));
    assertThat(node.getMethodTypes().contains(firstBridgeToken.asTypeToken()), is(true));
    assertThat(node.getMethodTypes().contains(secondBridgeToken.asTypeToken()), is(true));
    assertThat(node.getVisibility(), is(Visibility.PUBLIC));
}
 

import net.bytebuddy.description.type.TypeDescription; //导入方法依赖的package包/类
@Test
@JavaVersionRule.Enforce(7)
public void testBootstrapWithThisValue() throws Exception {
    TypeDescription typeDescription = new TypeDescription.ForLoadedType(Class.forName(ARGUMENT_BOOTSTRAP));
    DynamicType.Loaded<Simple> dynamicType = new ByteBuddy()
            .subclass(Simple.class)
            .method(isDeclaredBy(Simple.class))
            .intercept(InvokeDynamic.bootstrap(typeDescription.getDeclaredMethods().filter(named(BOOTSTRAP)).getOnly())
                    .invoke(BAZ, String.class)
                    .withThis(Object.class))
            .make()
            .load(getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER);
    assertThat(dynamicType.getLoaded().getDeclaredFields().length, is(0));
    Simple simple = dynamicType.getLoaded().getDeclaredConstructor().newInstance();
    assertThat(simple.foo(), is(simple.toString()));
}
 

import net.bytebuddy.description.type.TypeDescription; //导入方法依赖的package包/类
@Test
public void testDuplicateNameGenericClass() throws Exception {
    TypeDescription typeDescription = new TypeDescription.ForLoadedType(DuplicateNameGenericClass.class);
    MethodGraph.Linked methodGraph = MethodGraph.Compiler.Default.forJavaHierarchy().compile(typeDescription);
    assertThat(methodGraph.listNodes().size(), is(TypeDescription.OBJECT.getDeclaredMethods().filter(isVirtual()).size() + 2));
    MethodDescription objectMethod = typeDescription.getDeclaredMethods().filter(takesArguments(Object.class)).getOnly();
    MethodGraph.Node objectNode = methodGraph.locate(objectMethod.asSignatureToken());
    assertThat(objectNode.getSort(), is(MethodGraph.Node.Sort.RESOLVED));
    assertThat(objectNode.getRepresentative(), is(objectMethod));
    assertThat(objectNode.getMethodTypes().size(), is(1));
    assertThat(objectNode.getMethodTypes().contains(objectMethod.asTypeToken()), is(true));
    assertThat(objectNode.getVisibility(), is(objectMethod.getVisibility()));
    MethodDescription voidMethod = typeDescription.getDeclaredMethods().filter(takesArguments(Integer.class)).getOnly();
    MethodGraph.Node voidNode = methodGraph.locate(voidMethod.asSignatureToken());
    assertThat(voidNode.getSort(), is(MethodGraph.Node.Sort.RESOLVED));
    assertThat(voidNode.getRepresentative(), is(voidMethod));
    assertThat(voidNode.getMethodTypes().size(), is(1));
    assertThat(voidNode.getMethodTypes().contains(voidMethod.asTypeToken()), is(true));
    assertThat(voidNode.getVisibility(), is(voidMethod.getVisibility()));
}