import net.bytebuddy.description.NamedElement; //导入依赖的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.description.NamedElement; //导入依赖的package包/类
<T, B extends AnnotatedCodeElement & NamedElement.WithRuntimeName> ControllerInjectValueData<T> createValue
        (int index, TypeDescription classType, TypeDescription.ForLoadedType.Generic type, B member, String name,
         Map<Class<? extends Annotation>, ? extends Annotation> parentRawScopeAnnotations,
         Map<Class<? extends Annotation>, ? extends Annotation> parentRawQualifierAnnotations)
{
    Map<Class<? extends Annotation>, ? extends Annotation> scopeAnnotations;
    {
        Map<Class<? extends Annotation>, ? extends Annotation> memberRawScopeAnnotations = this.extractRawScopeAnnotations(member);
        Map<Class<? extends Annotation>, Annotation> rawScopeAnnotations = new HashMap<>(parentRawScopeAnnotations);
        rawScopeAnnotations.putAll(memberRawScopeAnnotations);
        scopeAnnotations = this.transformAll(classType, name, member, rawScopeAnnotations);
    }
    Map<Class<? extends Annotation>, ? extends Annotation> qualifierAnnotations;
    {
        Map<Class<? extends Annotation>, ? extends Annotation> memberRawQualifierAnnotations = this.extractRawQualifierAnnotations(member);
        Map<Class<? extends Annotation>, Annotation> rawQualifierAnnotations = new HashMap<>(parentRawQualifierAnnotations);
        rawQualifierAnnotations.putAll(memberRawQualifierAnnotations);
        qualifierAnnotations = this.transformAll(classType, name, member, rawQualifierAnnotations);
    }
    return new ControllerInjectValueData<>(index, name, type, scopeAnnotations, qualifierAnnotations);
}
 

import net.bytebuddy.description.NamedElement; //导入依赖的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.description.NamedElement; //导入依赖的package包/类
@Override
public Resolution locate(String typeName) throws IOException {
    int packageIndex = typeName.lastIndexOf('.');
    ClassFileLocator classFileLocator = classFileLocators.get(packageIndex == -1
            ? NamedElement.EMPTY_NAME
            : typeName.substring(0, packageIndex));
    return classFileLocator == null
            ? new Resolution.Illegal(typeName)
            : classFileLocator.locate(typeName);
}
 

import net.bytebuddy.description.NamedElement; //导入依赖的package包/类
@Test
public void testIsNamed() throws Exception {
    NamedElement.WithOptionalName namedElement = mock(NamedElement.WithOptionalName.class);
    assertThat(ElementMatchers.isNamed().matches(namedElement), is(false));
    when(namedElement.isNamed()).thenReturn(true);
    assertThat(ElementMatchers.isNamed().matches(namedElement), is(true));
}
 

import net.bytebuddy.description.NamedElement; //导入依赖的package包/类
@Test
public void testMatch() throws Exception {
    when(nameMatcher.matches(FOO)).thenReturn(true);
    assertThat(new NameMatcher<NamedElement>(nameMatcher).matches(namedElement), is(true));
    verify(nameMatcher).matches(FOO);
    verifyNoMoreInteractions(nameMatcher);
}
 

import net.bytebuddy.description.NamedElement; //导入依赖的package包/类
@Test
public void testNoMatch() throws Exception {
    when(nameMatcher.matches(FOO)).thenReturn(false);
    assertThat(new NameMatcher<NamedElement>(nameMatcher).matches(namedElement), is(false));
    verify(nameMatcher).matches(FOO);
    verifyNoMoreInteractions(nameMatcher);
}
 

import net.bytebuddy.description.NamedElement; //导入依赖的package包/类
@Before
public void setUp() throws Exception {
    when(foo.locate(FOO + "." + BAR)).thenReturn(fooResulution);
    when(bar.locate(BAR)).thenReturn(barResolution);
    Map<String, ClassFileLocator> map = new HashMap<String, ClassFileLocator>();
    map.put(FOO, foo);
    map.put(NamedElement.EMPTY_NAME, bar);
    classFileLocator = new ClassFileLocator.PackageDiscriminating(map);
}
 

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

import net.bytebuddy.description.NamedElement; //导入依赖的package包/类
private static Junction<NamedElement> geTypeMatchers() {

		// TODO: try that instead: type(any(), not(isBootstrapClassLoader()))
		return not(nameStartsWith("java").or(nameStartsWith("sun")).or(nameStartsWith("javax"))
				.or(nameStartsWith("com.sun")));
	}
 

import net.bytebuddy.description.NamedElement; //导入依赖的package包/类
@Test
public void testMatch() throws Exception {
    when(namedElement.isNamed()).thenReturn(true);
    assertThat(new IsNamedMatcher<NamedElement.WithOptionalName>().matches(namedElement), is(true));
}
 

import net.bytebuddy.description.NamedElement; //导入依赖的package包/类
@Test
public void testPositiveToNegative() throws Exception {
    assertThat(new IsNamedMatcher<NamedElement.WithOptionalName>().matches(namedElement), is(false));
}
 

import net.bytebuddy.description.NamedElement; //导入依赖的package包/类
@Test(expected = IllegalStateException.class)
public void testTypeEmptyEndName() throws Exception {
    makePlainInstrumentedType().withName(NamedElement.EMPTY_NAME).validated();
}
 

import net.bytebuddy.description.NamedElement; //导入依赖的package包/类
/**
 * Matches a type variable with the given name.
 *
 * @param matcher A matcher for the type variable's name.
 * @param <T>     The type of the matched object.
 * @return A matcher that matches type variables with the given name.
 */
public static <T extends TypeDefinition> ElementMatcher.Junction<T> isVariable(ElementMatcher<? super NamedElement> matcher) {
    return new TypeSortMatcher<T>(anyOf(TypeDefinition.Sort.VARIABLE, TypeDefinition.Sort.VARIABLE_SYMBOLIC)).and(matcher);
}
 

import net.bytebuddy.description.NamedElement; //导入依赖的package包/类
/**
 * Matches a {@link NamedElement} for its exact name.
 *
 * @param name The expected name.
 * @param <T>  The type of the matched object.
 * @return An element matcher for a named element's exact name.
 */
public static <T extends NamedElement> ElementMatcher.Junction<T> named(String name) {
    return new NameMatcher<T>(new StringMatcher(name, StringMatcher.Mode.EQUALS_FULLY));
}
 

import net.bytebuddy.description.NamedElement; //导入依赖的package包/类
/**
 * Matches a {@link NamedElement} for its name. The name's
 * capitalization is ignored.
 *
 * @param name The expected name.
 * @param <T>  The type of the matched object.
 * @return An element matcher for a named element's name.
 */
public static <T extends NamedElement> ElementMatcher.Junction<T> namedIgnoreCase(String name) {
    return new NameMatcher<T>(new StringMatcher(name, StringMatcher.Mode.EQUALS_FULLY_IGNORE_CASE));
}
 

import net.bytebuddy.description.NamedElement; //导入依赖的package包/类
/**
 * Matches a {@link NamedElement} for its name's prefix.
 *
 * @param prefix The expected name's prefix.
 * @param <T>    The type of the matched object.
 * @return An element matcher for a named element's name's prefix.
 */
public static <T extends NamedElement> ElementMatcher.Junction<T> nameStartsWith(String prefix) {
    return new NameMatcher<T>(new StringMatcher(prefix, StringMatcher.Mode.STARTS_WITH));
}
 

import net.bytebuddy.description.NamedElement; //导入依赖的package包/类
/**
 * Matches a {@link NamedElement} for its name's prefix. The name's
 * capitalization is ignored.
 *
 * @param prefix The expected name's prefix.
 * @param <T>    The type of the matched object.
 * @return An element matcher for a named element's name's prefix.
 */
public static <T extends NamedElement> ElementMatcher.Junction<T> nameStartsWithIgnoreCase(String prefix) {
    return new NameMatcher<T>(new StringMatcher(prefix, StringMatcher.Mode.STARTS_WITH_IGNORE_CASE));
}
 

import net.bytebuddy.description.NamedElement; //导入依赖的package包/类
/**
 * Matches a {@link NamedElement} for its name's suffix.
 *
 * @param suffix The expected name's suffix.
 * @param <T>    The type of the matched object.
 * @return An element matcher for a named element's name's suffix.
 */
public static <T extends NamedElement> ElementMatcher.Junction<T> nameEndsWith(String suffix) {
    return new NameMatcher<T>(new StringMatcher(suffix, StringMatcher.Mode.ENDS_WITH));
}
 

import net.bytebuddy.description.NamedElement; //导入依赖的package包/类
/**
 * Matches a {@link NamedElement} for its name's suffix. The name's
 * capitalization is ignored.
 *
 * @param suffix The expected name's suffix.
 * @param <T>    The type of the matched object.
 * @return An element matcher for a named element's name's suffix.
 */
public static <T extends NamedElement> ElementMatcher.Junction<T> nameEndsWithIgnoreCase(String suffix) {
    return new NameMatcher<T>(new StringMatcher(suffix, StringMatcher.Mode.ENDS_WITH_IGNORE_CASE));
}