Java TypeDescription类代码示例

import net.bytebuddy.description.type.TypeDescription; //导入依赖的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.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包/类
public EnforcingAtomPlugin() {
    super(
        new BtApplyIfMatches(
            new ConjunctionMatcher<TypeDescription>(
                not(new AnnotatedNonAtom()),
                not(new AnnotatedAtom()),
                not(isInterface())
            ),
            new BtConditional(
                new ExplicitlyExtendingAnything(),
                new BtApplyAtomAliasPatch(),
                new BtApplyAtomPatch()
            )
        )
    );
}
 

import net.bytebuddy.description.type.TypeDescription; //导入依赖的package包/类
@Override
public final boolean matches(TypeDescription target) {
    MethodList<MethodDescription.InDefinedShape> methodsToCheck = target.getDeclaredMethods()
            .filter(not(isConstructor()))
            .filter(isPublic())
            .filter(not(isStatic()))
            .filter(not(isBridge()))
            .filter(not(named("equals")))
            .filter(not(named("hashCode")))
            .filter(not(named("toString")));
    
    for(MethodDescription md : methodsToCheck) {
        if(!md.isFinal()) {
            return false;
        }
    }
    return true;
}
 

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包/类
private static ElementMatcher.Junction<TypeDescription> createMatcher() {
  // This matcher matches implementations of Executor, but excludes CurrentContextExecutor and
  // FixedContextExecutor from io.grpc.Context, which already propagate the context.
  // TODO(stschmidt): As the executor implementation itself (e.g. ThreadPoolExecutor) is
  // instrumented by the agent for automatic context propagation, CurrentContextExecutor could be
  // turned into a no-op to avoid another unneeded context propagation. Likewise, when using
  // FixedContextExecutor, the automatic context propagation added by the agent is unneeded.
  return isSubTypeOf(Executor.class)
      .and(not(isAbstract()))
      .and(
          not(
              nameStartsWith("io.grpc.Context$")
                  .and(
                      nameEndsWith("CurrentContextExecutor")
                          .or(nameEndsWith("FixedContextExecutor")))));
}
 

import net.bytebuddy.description.type.TypeDescription; //导入依赖的package包/类
UserCodeMethodInvocation(
    @Nullable Integer returnVarIndex,
    MethodDescription targetMethod,
    MethodDescription instrumentedMethod) {
  this.returnVarIndex = returnVarIndex;
  this.targetMethod = targetMethod;
  this.instrumentedMethod = instrumentedMethod;
  this.returnType = targetMethod.getReturnType().asErasure();

  boolean targetMethodReturnsVoid = TypeDescription.VOID.equals(returnType);
  checkArgument(
      (returnVarIndex == null) == targetMethodReturnsVoid,
      "returnVarIndex should be defined if and only if the target method has a return value");

  try {
    createUserCodeException =
        new MethodDescription.ForLoadedMethod(
            UserCodeException.class.getDeclaredMethod("wrap", Throwable.class));
  } catch (NoSuchMethodException | SecurityException e) {
    throw new RuntimeException("Unable to find UserCodeException.wrap", e);
  }
}
 

import net.bytebuddy.description.type.TypeDescription; //导入依赖的package包/类
@SuppressWarnings({"unchecked", "rawtypes"})
public static Annotation[] getAnnotations(Collection<AnnotationDescription> annotations)
{
    Collection<Annotation> col = new ArrayList<>(annotations.size());
    for (AnnotationDescription annotation : annotations)
    {
        TypeDescription annotationType = annotation.getAnnotationType();
        try
        {
            Class<?> forName = Class.forName(annotationType.getActualName());
            if (! forName.isAnnotation())
            {
                continue;
            }
            col.add(annotation.prepare((Class) forName).load());
        }
        catch (ClassNotFoundException ignored)
        {
        }
    }
    return col.toArray(new Annotation[col.size()]);
}