Java ElementMatcher.Junction方法代码示例

import net.bytebuddy.matcher.ElementMatcher; //导入方法依赖的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.matcher.ElementMatcher; //导入方法依赖的package包/类
/**
 * Creates the AgentBuilder that will redefine the System class.
 * @param inst instrumentation instance.
 * @return an agent builder.
 */
private static AgentBuilder createAgentBuilder(Instrumentation inst) {

    // Find me a class called "java.lang.System"
    final ElementMatcher.Junction<NamedElement> systemType = ElementMatchers.named("java.lang.System");

    // And then find a method called setSecurityManager and tell MySystemInterceptor to
    // intercept it (the method binding is smart enough to take it from there)
    final AgentBuilder.Transformer transformer =
            (b, typeDescription) -> b.method(ElementMatchers.named("setSecurityManager"))
                    .intercept(MethodDelegation.to(MySystemInterceptor.class));

    // Disable a bunch of stuff and turn on redefine as the only option
    final ByteBuddy byteBuddy = new ByteBuddy().with(Implementation.Context.Disabled.Factory.INSTANCE);
    final AgentBuilder agentBuilder = new AgentBuilder.Default()
            .withByteBuddy(byteBuddy)
            .withInitializationStrategy(AgentBuilder.InitializationStrategy.NoOp.INSTANCE)
            .withRedefinitionStrategy(AgentBuilder.RedefinitionStrategy.REDEFINITION)
            .withTypeStrategy(AgentBuilder.TypeStrategy.Default.REDEFINE)
            .type(systemType)
            .transform(transformer);

    return agentBuilder;
}
 

import net.bytebuddy.matcher.ElementMatcher; //导入方法依赖的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.matcher.ElementMatcher; //导入方法依赖的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.matcher.ElementMatcher; //导入方法依赖的package包/类
public ElementMatcher<? super TypeDescription> buildMatch() {
    ElementMatcher.Junction judge = new AbstractJunction<NamedElement>() {
        @Override
        public boolean matches(NamedElement target) {
            return nameMatchDefine.containsKey(target.getActualName());
        }
    };
    judge = judge.and(not(isInterface()));
    for (AbstractClassEnhancePluginDefine define : signatureMatchDefine) {
        ClassMatch match = define.enhanceClass();
        if (match instanceof IndirectMatch) {
            judge = judge.or(((IndirectMatch)match).buildJunction());
        }
    }
    return new ProtectiveShieldMatcher(judge);
}
 

import net.bytebuddy.matcher.ElementMatcher; //导入方法依赖的package包/类
protected ElementMatcher.Junction<MethodDescription> excludeObjectDefaultMethod() {
    ElementMatcher.Junction<MethodDescription> exclusiveMatcher = null;
    for (MethodMatcher methodMatcher : EXCLUSIVE_DEFAULT_METHOD_NAME) {
        if (exclusiveMatcher == null) {
            exclusiveMatcher = methodMatcher.buildMatcher();
            continue;
        }

        exclusiveMatcher = exclusiveMatcher.or(methodMatcher.buildMatcher());

    }
    return not(exclusiveMatcher);
}
 

import net.bytebuddy.matcher.ElementMatcher; //导入方法依赖的package包/类
@Override
public ElementMatcher.Junction<MethodDescription> match() {
    ElementMatcher.Junction<MethodDescription> result = null;

    for (MethodMatcher matcher : matchers) {
        if (result == null) {
            result = matcher.buildMatcher();
            continue;
        }

        result = result.or(matcher.buildMatcher());
    }

    return not(result);
}
 

import net.bytebuddy.matcher.ElementMatcher; //导入方法依赖的package包/类
protected ElementMatcher.Junction<MethodDescription> mergeArgumentsIfNecessary(ElementMatcher.Junction<MethodDescription> matcher) {
    if (argTypeArray != null) {
        matcher = matcher.and(takesArguments(argTypeArray));
    }

    if (argNum > -1) {
        matcher = matcher.and(takesArguments(argNum));
    }

    if (modifier != null) {
        matcher = matcher.and(modifier.elementMatcher());
    }

    return matcher;
}
 

import net.bytebuddy.matcher.ElementMatcher; //导入方法依赖的package包/类
@Override
public ElementMatcher.Junction buildJunction() {
    ElementMatcher.Junction junction = null;
    for (String annotation : annotations) {
        if (junction == null) {
            junction = buildEachAnnotation(annotation);
        } else {
            junction = junction.and(buildEachAnnotation(annotation));
        }
    }
    junction = declaresMethod(junction).and(not(isInterface()));
    return junction;
}
 

import net.bytebuddy.matcher.ElementMatcher; //导入方法依赖的package包/类
@Override
public ElementMatcher.Junction buildJunction() {
    ElementMatcher.Junction junction = null;
    for (String name : matchClassNames) {
        if (junction == null) {
            junction = named(name);
        } else {
            junction = junction.or(named(name));
        }
    }
    return junction;
}
 

import net.bytebuddy.matcher.ElementMatcher; //导入方法依赖的package包/类
@Override
public ElementMatcher.Junction buildJunction() {
    ElementMatcher.Junction junction = null;
    for (String superTypeName : parentTypes) {
        if (junction == null) {
            junction = buildSuperClassMatcher(superTypeName);
        } else {
            junction = junction.and(buildSuperClassMatcher(superTypeName));
        }
    }
    junction = junction.and(not(isInterface()));
    return junction;
}
 

import net.bytebuddy.matcher.ElementMatcher; //导入方法依赖的package包/类
@Override
public ElementMatcher.Junction buildJunction() {
    ElementMatcher.Junction junction = null;
    for (String annotation : annotations) {
        if (junction == null) {
            junction = buildEachAnnotation(annotation);
        } else {
            junction = junction.and(buildEachAnnotation(annotation));
        }
    }
    junction = junction.and(not(isInterface()));
    return junction;
}
 

import net.bytebuddy.matcher.ElementMatcher; //导入方法依赖的package包/类
public <T extends NamedElement> ElementMatcher.Junction<T> inPlugins() {
    return new NameMatcher(new PluginMathers(pluginManager));
}
 

import net.bytebuddy.matcher.ElementMatcher; //导入方法依赖的package包/类
@Override
public ElementMatcher.Junction<MethodDescription> buildMatcher() {
    return this.match().and(excludeObjectDefaultMethod());
}
 

import net.bytebuddy.matcher.ElementMatcher; //导入方法依赖的package包/类
@Override
public ElementMatcher.Junction<MethodDescription> buildMatcher() {
    ElementMatcher.Junction<MethodDescription> matcher = nameMatches(getMethodMatchDescribe());
    return mergeArgumentsIfNecessary(matcher);
}