Java MethodDescription类代码示例

import net.bytebuddy.description.method.MethodDescription; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
public ElementMatcher<MethodDescription> getIncludes() {
    return not(ElementMatchers.<MethodDescription>isPrivate()
            .or(ObjectMethodElementMatchers.INSTANCE)
            .or(named("close"))
            .or(named("getDB"))
            .or(named("getClient"))
            .or(named("connect"))
            .or(named("setDataSource"))
            .or(named("resetState"))
            .or(named("clusterSlots"))
            .or(named("isConnected"))
            .or(named("ping"))
            .or(named("quit"))
            .or(named("checkIsInMultiOrPipeline")));
}
 

import net.bytebuddy.description.method.MethodDescription; //导入依赖的package包/类
/**
 * Returns a byte buddy matcher matching any method contained in methodSignatures.
 */
public static ElementMatcher<MethodDescription> matchAnyMethodIn(Set<MethodSignature> methodSignatures) {
    ElementMatcher.Junction<MethodDescription> methodMatcher = ElementMatchers.none();
    for (MethodSignature methodSignature : methodSignatures) {
        ElementMatcher.Junction<MethodDescription> junction = ElementMatchers
                .named(methodSignature.getMethodName())
                .and(not(isAbstract()))
                .and(isPublic())
                .and(takesArguments(methodSignature.getParameterTypes().size()));
        for (int i = 0; i < methodSignature.getParameterTypes().size(); i++) {
            junction = junction.and(takesArgument(i, named(methodSignature.getParameterTypes().get(i))));
        }
        methodMatcher = methodMatcher.or(junction);
    }
    return methodMatcher;
}
 

import net.bytebuddy.description.method.MethodDescription; //导入依赖的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.method.MethodDescription; //导入依赖的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.method.MethodDescription; //导入依赖的package包/类
public SmtBoxFieldTest() {
    super(
        new TestCase(
            "generates no bytecode for non-primitive fields",
            new AssertTokensToRepresentIdenticalBytecode(
                new SmtBoxField(
                    new FieldDescription.ForLoadedField(
                        NON_PRIMITIVE_FIELD
                    )
                ),
                new SmtDoNothing()
            )
        ),
        new TestCase(
            "boxes primitive fields",
            new AssertTokenToRepresentExpectedStackManipulation(
                new SmtBoxField(
                    new FieldDescription.ForLoadedField(
                        PRIMITIVE_FIELD
                    )
                ),
                () -> MethodInvocation.invoke(new MethodDescription.ForLoadedMethod(INT_VALUEOF))
            )
        )
    );
}
 

import net.bytebuddy.description.method.MethodDescription; //导入依赖的package包/类
private ElementMatcher.Junction<MethodDescription> elementMatcher() {
    switch (this) {
        case Private: {
            return isPrivate();
        }
        case Default: {
            return isPackagePrivate();
        }
        case Public: {
            return isPublic();
        }
        case Protected: {
            return isProtected();
        }
        default:
            return isPublic();
    }
}
 

import net.bytebuddy.description.method.MethodDescription; //导入依赖的package包/类
@Override
protected StackManipulation beforeDelegation(MethodDescription instrumentedMethod) {
  // Parameters of the wrapper invoker method:
  //   DoFnInvoker.ArgumentProvider
  // Parameters of the wrapped DoFn method:
  //   [DoFn.ProcessContext, BoundedWindow, InputProvider, OutputReceiver] in any order
  ArrayList<StackManipulation> pushParameters = new ArrayList<>();

  // To load the delegate, push `this` and then access the field
  StackManipulation pushDelegate =
      new StackManipulation.Compound(
          MethodVariableAccess.REFERENCE.loadFrom(0),
          FieldAccess.forField(delegateField).read());

  StackManipulation pushExtraContextFactory = MethodVariableAccess.REFERENCE.loadFrom(1);

  // Push the arguments in their actual order.
  for (DoFnSignature.Parameter param : signature.extraParameters()) {
    pushParameters.add(
        new StackManipulation.Compound(
            pushExtraContextFactory, getExtraContextParameter(param, pushDelegate)));
  }
  return new StackManipulation.Compound(pushParameters);
}
 

import net.bytebuddy.description.method.MethodDescription; //导入依赖的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.method.MethodDescription; //导入依赖的package包/类
@Override
protected StackManipulation beforeDelegation(MethodDescription instrumentedMethod) {
  // Parameters of the wrapper invoker method:
  //   DoFn.ArgumentProvider
  // Parameters of the wrapped DoFn method:
  //   a dynamic set of allowed "extra" parameters in any order subject to
  //   validation prior to getting the DoFnSignature
  ArrayList<StackManipulation> parameters = new ArrayList<>();

  // To load the delegate, push `this` and then access the field
  StackManipulation pushDelegate =
      new StackManipulation.Compound(
          MethodVariableAccess.REFERENCE.loadFrom(0),
          FieldAccess.forField(delegateField).read());

  StackManipulation pushExtraContextFactory = MethodVariableAccess.REFERENCE.loadFrom(1);

  // Push the extra arguments in their actual order.
  for (DoFnSignature.Parameter param : signature.extraParameters()) {
    parameters.add(
        new StackManipulation.Compound(
            pushExtraContextFactory,
            ByteBuddyDoFnInvokerFactory.getExtraContextParameter(param, pushDelegate)));
  }
  return new StackManipulation.Compound(parameters);
}
 

import net.bytebuddy.description.method.MethodDescription; //导入依赖的package包/类
@Override protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() {
    return new InstanceMethodsInterceptPoint[] {
        new InstanceMethodsInterceptPoint() {
            @Override public ElementMatcher<MethodDescription> getMethodsMatcher() {
                return named(CONSUMER_MESSAGE_METHOD);
            }

            @Override public String getMethodsInterceptor() {
                return INTERCEPTOR_CLASS;
            }

            @Override public boolean isOverrideArgs() {
                return false;
            }
        }
    };
}
 

import net.bytebuddy.description.method.MethodDescription; //导入依赖的package包/类
@Override
public boolean isMatch(TypeDescription typeDescription) {
    for (MethodDescription.InDefinedShape methodDescription : typeDescription.getDeclaredMethods()) {
        List<String> annotationList = new ArrayList<String>(Arrays.asList(annotations));

        AnnotationList declaredAnnotations = methodDescription.getDeclaredAnnotations();
        for (AnnotationDescription annotation : declaredAnnotations) {
            annotationList.remove(annotation.getAnnotationType().getActualName());
        }
        if (annotationList.isEmpty()) {
            return true;
        }
    }

    return false;
}
 

import net.bytebuddy.description.method.MethodDescription; //导入依赖的package包/类
/**
 * @return the collection of {@link InstanceMethodsInterceptPoint}, represent the intercepted methods and their
 * interceptors.
 */
@Override
protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() {
    return new InstanceMethodsInterceptPoint[] {
        new InstanceMethodsInterceptPoint() {
            @Override
            public ElementMatcher<MethodDescription> getMethodsMatcher() {
                return named("convert");
            }

            @Override
            public String getMethodsInterceptor() {
                return "PrintTraceIdInterceptor";
            }

            @Override public boolean isOverrideArgs() {
                return false;
            }
        }
    };
}
 

import net.bytebuddy.description.method.MethodDescription; //导入依赖的package包/类
@Override protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() {
    return new InstanceMethodsInterceptPoint[] {
        new InstanceMethodsInterceptPoint() {
            @Override public ElementMatcher<MethodDescription> getMethodsMatcher() {
                return named(ENHANCE_METHOD);
            }

            @Override public String getMethodsInterceptor() {
                return INTERCEPT_CLASS;
            }

            @Override public boolean isOverrideArgs() {
                return false;
            }
        }
    };
}
 

import net.bytebuddy.description.method.MethodDescription; //导入依赖的package包/类
/**
 * @return the collection of {@link StaticMethodsInterceptPoint}, represent the intercepted methods and their
 * interceptors.
 */
@Override
protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() {
    return new InstanceMethodsInterceptPoint[] {
        new InstanceMethodsInterceptPoint() {
            @Override
            public ElementMatcher<MethodDescription> getMethodsMatcher() {
                return named("convert");
            }

            @Override
            public String getMethodsInterceptor() {
                return "PrintTraceIdInterceptor";
            }

            @Override public boolean isOverrideArgs() {
                return false;
            }
        }
    };
}
 

import net.bytebuddy.description.method.MethodDescription; //导入依赖的package包/类
@Override
protected InstanceMethodsInterceptPoint[] getInstanceMethodsInterceptPoints() {
    return new InstanceMethodsInterceptPoint[] {
        new InstanceMethodsInterceptPoint() {
            @Override
            public ElementMatcher<MethodDescription> getMethodsMatcher() {
                return named("convertTID");
            }

            @Override
            public String getMethodsInterceptor() {
                return "PrintMDCTraceIdInterceptor";
            }

            @Override public boolean isOverrideArgs() {
                return false;
            }
        }
    };
}