import jdk.internal.dynalink.linker.TypeBasedGuardingDynamicLinker; //导入依赖的package包/类
@SuppressWarnings("fallthrough")
@Override
protected List<TypeBasedGuardingDynamicLinker> computeValue(final Class<?> clazz) {
    List<TypeBasedGuardingDynamicLinker> list = NO_LINKER;
    for(int i = 0; i < linkers.length; ++i) {
        final TypeBasedGuardingDynamicLinker linker = linkers[i];
        if(linker.canLinkType(clazz)) {
            switch(list.size()) {
                case 0: {
                    list = singletonLinkers[i];
                    break;
                }
                case 1: {
                    list = new LinkedList<>(list);
                }
                default: {
                    list.add(linker);
                }
            }
        }
    }
    return list;
}
 

import jdk.internal.dynalink.linker.TypeBasedGuardingDynamicLinker; //导入依赖的package包/类
private static void addTypeBased(final List<GuardingDynamicLinker> llinkers,
        final List<TypeBasedGuardingDynamicLinker> tblinkers) {
    switch(tblinkers.size()) {
        case 0: {
            break;
        }
        case 1: {
            llinkers.addAll(tblinkers);
            tblinkers.clear();
            break;
        }
        default: {
            llinkers.add(new CompositeTypeBasedGuardingDynamicLinker(tblinkers));
            tblinkers.clear();
            break;
        }
    }
}
 

import jdk.internal.dynalink.linker.TypeBasedGuardingDynamicLinker; //导入依赖的package包/类
@Override
protected List<TypeBasedGuardingDynamicLinker> computeValue(Class<?> clazz) {
    List<TypeBasedGuardingDynamicLinker> list = NO_LINKER;
    for(int i = 0; i < linkers.length; ++i) {
        final TypeBasedGuardingDynamicLinker linker = linkers[i];
        if(linker.canLinkType(clazz)) {
            switch(list.size()) {
                case 0: {
                    list = singletonLinkers[i];
                    break;
                }
                case 1: {
                    list = new LinkedList<>(list);
                }
                //$FALL-THROUGH$
                default: {
                    list.add(linker);
                }
            }
        }
    }
    return list;
}
 

import jdk.internal.dynalink.linker.TypeBasedGuardingDynamicLinker; //导入依赖的package包/类
private static void addTypeBased(List<GuardingDynamicLinker> llinkers,
        List<TypeBasedGuardingDynamicLinker> tblinkers) {
    switch(tblinkers.size()) {
        case 0: {
            break;
        }
        case 1: {
            llinkers.addAll(tblinkers);
            tblinkers.clear();
            break;
        }
        default: {
            llinkers.add(new CompositeTypeBasedGuardingDynamicLinker(tblinkers));
            tblinkers.clear();
            break;
        }
    }
}
 

import jdk.internal.dynalink.linker.TypeBasedGuardingDynamicLinker; //导入依赖的package包/类
@Override
protected TypeBasedGuardingDynamicLinker computeValue(final Class<?> clazz) {
    // If ClassValue.put() were public, we could just pre-populate with these known mappings...
    return
        clazz == Class.class ? new ClassLinker() :
        clazz == StaticClass.class ? new StaticClassLinker() :
        DynamicMethod.class.isAssignableFrom(clazz) ? new DynamicMethodLinker() :
        new BeanLinker(clazz);
}
 

import jdk.internal.dynalink.linker.TypeBasedGuardingDynamicLinker; //导入依赖的package包/类
/**
 * Returns a collection of names of all readable instance properties of a class.
 * @param clazz the class
 * @return a collection of names of all readable instance properties of a class.
 */
public static Collection<String> getReadableInstancePropertyNames(final Class<?> clazz) {
    final TypeBasedGuardingDynamicLinker linker = getLinkerForClass(clazz);
    if(linker instanceof BeanLinker) {
        return ((BeanLinker)linker).getReadablePropertyNames();
    }
    return Collections.emptySet();
}
 

import jdk.internal.dynalink.linker.TypeBasedGuardingDynamicLinker; //导入依赖的package包/类
/**
 * Returns a collection of names of all writable instance properties of a class.
 * @param clazz the class
 * @return a collection of names of all writable instance properties of a class.
 */
public static Collection<String> getWritableInstancePropertyNames(final Class<?> clazz) {
    final TypeBasedGuardingDynamicLinker linker = getLinkerForClass(clazz);
    if(linker instanceof BeanLinker) {
        return ((BeanLinker)linker).getWritablePropertyNames();
    }
    return Collections.emptySet();
}
 

import jdk.internal.dynalink.linker.TypeBasedGuardingDynamicLinker; //导入依赖的package包/类
/**
 * Returns a collection of names of all instance methods of a class.
 * @param clazz the class
 * @return a collection of names of all instance methods of a class.
 */
public static Collection<String> getInstanceMethodNames(final Class<?> clazz) {
    final TypeBasedGuardingDynamicLinker linker = getLinkerForClass(clazz);
    if(linker instanceof BeanLinker) {
        return ((BeanLinker)linker).getMethodNames();
    }
    return Collections.emptySet();
}
 

import jdk.internal.dynalink.linker.TypeBasedGuardingDynamicLinker; //导入依赖的package包/类
@SuppressWarnings({"unchecked", "rawtypes"})
ClassToLinker(final TypeBasedGuardingDynamicLinker[] linkers) {
    this.linkers = linkers;
    singletonLinkers = new List[linkers.length];
    for(int i = 0; i < linkers.length; ++i) {
        singletonLinkers[i] = Collections.singletonList(linkers[i]);
    }
}
 

import jdk.internal.dynalink.linker.TypeBasedGuardingDynamicLinker; //导入依赖的package包/类
/**
 * Creates a new composite type-based linker.
 *
 * @param linkers the component linkers
 */
public CompositeTypeBasedGuardingDynamicLinker(final Iterable<? extends TypeBasedGuardingDynamicLinker> linkers) {
    final List<TypeBasedGuardingDynamicLinker> l = new LinkedList<>();
    for(final TypeBasedGuardingDynamicLinker linker: linkers) {
        l.add(linker);
    }
    this.classToLinker = new ClassToLinker(l.toArray(new TypeBasedGuardingDynamicLinker[l.size()]));
}
 

import jdk.internal.dynalink.linker.TypeBasedGuardingDynamicLinker; //导入依赖的package包/类
@Override
public GuardedInvocation getGuardedInvocation(final LinkRequest linkRequest, final LinkerServices linkerServices)
        throws Exception {
    final Object obj = linkRequest.getReceiver();
    if(obj == null) {
        return null;
    }
    for(final TypeBasedGuardingDynamicLinker linker: classToLinker.get(obj.getClass())) {
        final GuardedInvocation invocation = linker.getGuardedInvocation(linkRequest, linkerServices);
        if(invocation != null) {
            return invocation;
        }
    }
    return null;
}
 

import jdk.internal.dynalink.linker.TypeBasedGuardingDynamicLinker; //导入依赖的package包/类
/**
 * Optimizes a list of type-based linkers. If a group of adjacent linkers in the list all implement
 * {@link TypeBasedGuardingDynamicLinker}, they will be replaced with a single instance of
 * {@link CompositeTypeBasedGuardingDynamicLinker} that contains them.
 *
 * @param linkers the list of linkers to optimize
 * @return the optimized list
 */
public static List<GuardingDynamicLinker> optimize(final Iterable<? extends GuardingDynamicLinker> linkers) {
    final List<GuardingDynamicLinker> llinkers = new LinkedList<>();
    final List<TypeBasedGuardingDynamicLinker> tblinkers = new LinkedList<>();
    for(final GuardingDynamicLinker linker: linkers) {
        if(linker instanceof TypeBasedGuardingDynamicLinker) {
            tblinkers.add((TypeBasedGuardingDynamicLinker)linker);
        } else {
            addTypeBased(llinkers, tblinkers);
            llinkers.add(linker);
        }
    }
    addTypeBased(llinkers, tblinkers);
    return llinkers;
}