import sun.reflect.annotation.AnnotationType; //导入依赖的package包/类
Object getValue(Attribute attr) {
    Method method;              // runtime method of annotation element
    try {
        method = annoType.getMethod(meth.name.toString());
    } catch (NoSuchMethodException e) {
        return null;
    }
    returnClass = method.getReturnType();
    attr.accept(this);
    if (!(value instanceof ExceptionProxy) &&
        !AnnotationType.invocationHandlerReturnType(returnClass)
                                                .isInstance(value)) {
        typeMismatch(method, attr);
    }
    return value;
}
 

import sun.reflect.annotation.AnnotationType; //导入依赖的package包/类
/**
 * Returns the default value for the annotation member represented by
 * this {@code Method} instance.  If the member is of a primitive type,
 * an instance of the corresponding wrapper type is returned. Returns
 * null if no default is associated with the member, or if the method
 * instance does not represent a declared member of an annotation type.
 *
 * @return the default value for the annotation member represented
 *     by this {@code Method} instance.
 * @throws TypeNotPresentException if the annotation is of type
 *     {@link Class} and no definition can be found for the
 *     default class value.
 * @since  1.5
 */
public Object getDefaultValue() {
    if  (annotationDefault == null)
        return null;
    Class<?> memberType = AnnotationType.invocationHandlerReturnType(
        getReturnType());
    Object result = AnnotationParser.parseMemberValue(
        memberType, ByteBuffer.wrap(annotationDefault),
        SharedSecrets.getJavaLangAccess().
            getConstantPool(getDeclaringClass()),
        getDeclaringClass());
    if (result instanceof ExceptionProxy) {
        if (result instanceof TypeNotPresentExceptionProxy) {
            TypeNotPresentExceptionProxy proxy = (TypeNotPresentExceptionProxy)result;
            throw new TypeNotPresentException(proxy.typeName(), proxy.getCause());
        }
        throw new AnnotationFormatError("Invalid default: " + this);
    }
    return result;
}
 

import sun.reflect.annotation.AnnotationType; //导入依赖的package包/类
/**
 * Returns the default value for the annotation member represented by
 * this {@code Method} instance.  If the member is of a primitive type,
 * an instance of the corresponding wrapper type is returned. Returns
 * null if no default is associated with the member, or if the method
 * instance does not represent a declared member of an annotation type.
 *
 * @return the default value for the annotation member represented
 *     by this {@code Method} instance.
 * @throws TypeNotPresentException if the annotation is of type
 *     {@link Class} and no definition can be found for the
 *     default class value.
 * @since  1.5
 */
public Object getDefaultValue() {
    if  (annotationDefault == null)
        return null;
    Class<?> memberType = AnnotationType.invocationHandlerReturnType(
        getReturnType());
    Object result = AnnotationParser.parseMemberValue(
        memberType, ByteBuffer.wrap(annotationDefault),
        sun.misc.SharedSecrets.getJavaLangAccess().
            getConstantPool(getDeclaringClass()),
        getDeclaringClass());
    if (result instanceof sun.reflect.annotation.ExceptionProxy)
        throw new AnnotationFormatError("Invalid default: " + this);
    return result;
}
 

import sun.reflect.annotation.AnnotationType; //导入依赖的package包/类
private static Map<Class<? extends Annotation>, Annotation> mapAnnotations(Annotation[] annos) {
    Map<Class<? extends Annotation>, Annotation> result =
        new LinkedHashMap<>();
    for (Annotation a : annos) {
        Class<? extends Annotation> klass = a.annotationType();
        AnnotationType type = AnnotationType.getInstance(klass);
        if (type.retention() == RetentionPolicy.RUNTIME)
            if (result.put(klass, a) != null)
                throw new AnnotationFormatError("Duplicate annotation for class: "+klass+": " + a);
    }
    return result;
}
 

import sun.reflect.annotation.AnnotationType; //导入依赖的package包/类
/**
 * Returns the default value for the annotation member represented by
 * this {@code Method} instance.  If the member is of a primitive type,
 * an instance of the corresponding wrapper type is returned. Returns
 * null if no default is associated with the member, or if the method
 * instance does not represent a declared member of an annotation type.
 *
 * @return the default value for the annotation member represented
 *     by this {@code Method} instance.
 * @throws TypeNotPresentException if the annotation is of type
 *     {@link Class} and no definition can be found for the
 *     default class value.
 * @since  1.5
 */
public Object getDefaultValue() {
    if  (annotationDefault == null)
        return null;
    Class<?> memberType = AnnotationType.invocationHandlerReturnType(
        getReturnType());
    Object result = AnnotationParser.parseMemberValue(
        memberType, ByteBuffer.wrap(annotationDefault),
        SharedSecrets.getJavaLangAccess().
            getConstantPool(getDeclaringClass()),
        getDeclaringClass());
    if (result instanceof sun.reflect.annotation.ExceptionProxy)
        throw new AnnotationFormatError("Invalid default: " + this);
    return result;
}
 

import sun.reflect.annotation.AnnotationType; //导入依赖的package包/类
public static String getFieldExportName(Field field) {
    if (!field.isPublic() || field.isSynthetic())
        return null;

    AnnotationEntry[] entries = field.getAnnotationEntries();

    for (AnnotationEntry annotationEntry : entries) {
        String translated = Signature.translate(annotationEntry.getAnnotationType());

        if (translated.equals(OJNIExclude.class.getName()))
            return null;

        if (translated.equals(OJNIExportName.class.getName())) {

            ElementValuePair[] elementValuePairs = annotationEntry.getElementValuePairs();

            AnnotationType annotationType = AnnotationType.getInstance(OJNIExportName.class);

            for (ElementValuePair elementValuePair : elementValuePairs) {

                if (annotationType.memberTypes().get(elementValuePair.getNameString()) != null) {
                    return elementValuePair.getValue().stringifyValue();
                }
            }
        }
    }

    return field.getName();
}
 

import sun.reflect.annotation.AnnotationType; //导入依赖的package包/类
/**
 * Returns the default value for the annotation member represented by
 * this <tt>Method</tt> instance.  If the member is of a primitive type,
 * an instance of the corresponding wrapper type is returned. Returns
 * null if no default is associated with the member, or if the method
 * instance does not represent a declared member of an annotation type.
 *
 * @return the default value for the annotation member represented
 *     by this <tt>Method</tt> instance.
 * @throws TypeNotPresentException if the annotation is of type
 *     {@link Class} and no definition can be found for the
 *     default class value.
 * @since  1.5
 */
public Object getDefaultValue() {
    if  (annotationDefault == null)
        return null;
    Class memberType = AnnotationType.invocationHandlerReturnType(
        getReturnType());
    Object result = AnnotationParser.parseMemberValue(
        memberType, ByteBuffer.wrap(annotationDefault),
        sun.misc.SharedSecrets.getJavaLangAccess().
            getConstantPool(getDeclaringClass()),
        getDeclaringClass());
    if (result instanceof sun.reflect.annotation.ExceptionProxy)
        throw new AnnotationFormatError("Invalid default: " + this);
    return result;
}
 

import sun.reflect.annotation.AnnotationType; //导入依赖的package包/类
/**
 * Returns annotations that are <em>associated</em> with this element.
 *
 * If there are no annotations <em>associated</em> with this element, the return
 * value is an array of length 0.
 *
 * The difference between this method and {@link #getAnnotation(Class)}
 * is that this method detects if its argument is a <em>repeatable
 * annotation type</em> (JLS 9.6), and if so, attempts to find one or
 * more annotations of that type by "looking through" a container
 * annotation.
 *
 * The caller of this method is free to modify the returned array; it will
 * have no effect on the arrays returned to other callers.
 *
 * @implSpec The default implementation first calls {@link
 * #getDeclaredAnnotationsByType(Class)} passing {@code
 * annotationClass} as the argument. If the returned array has
 * length greater than zero, the array is returned. If the returned
 * array is zero-length and this {@code AnnotatedElement} is a
 * class and the argument type is an inheritable annotation type,
 * and the superclass of this {@code AnnotatedElement} is non-null,
 * then the returned result is the result of calling {@link
 * #getAnnotationsByType(Class)} on the superclass with {@code
 * annotationClass} as the argument. Otherwise, a zero-length
 * array is returned.
 *
 * @param <T> the type of the annotation to query for and return if present
 * @param annotationClass the Class object corresponding to the
 *        annotation type
 * @return all this element's annotations for the specified annotation type if
 *     associated with this element, else an array of length zero
 * @throws NullPointerException if the given annotation class is null
 * @since 1.8
 */
default <T extends Annotation> T[] getAnnotationsByType(Class<T> annotationClass) {
     /*
      * Definition of associated: directly or indirectly present OR
      * neither directly nor indirectly present AND the element is
      * a Class, the annotation type is inheritable, and the
      * annotation type is associated with the superclass of the
      * element.
      */
     T[] result = getDeclaredAnnotationsByType(annotationClass);

     if (result.length == 0 && // Neither directly nor indirectly present
         this instanceof Class && // the element is a class
         AnnotationType.getInstance(annotationClass).isInherited()) { // Inheritable
         Class<?> superClass = ((Class<?>) this).getSuperclass();
         if (superClass != null) {
             // Determine if the annotation is associated with the
             // superclass
             result = superClass.getAnnotationsByType(annotationClass);
         }
     }

     return result;
 }
 

import sun.reflect.annotation.AnnotationType; //导入依赖的package包/类
public static MethodExportInfo getMethodExportInfo(Method method) {
    MethodExportInfo result = new MethodExportInfo();

    if (!method.isPublic() || method.isAnnotation() || method.isSynthetic())
        return result;

    String name = method.getName();

    AnnotationEntry[] entries = method.getAnnotationEntries();

    for (AnnotationEntry annotationEntry : entries) {
        String translated = Signature.translate(annotationEntry.getAnnotationType());

        if (translated.equals(OJNIExclude.class.getName()))
            return result;

        if (translated.equals(OJNIExportName.class.getName())) {
            result.isCustom = true;

            ElementValuePair[] elementValuePairs = annotationEntry.getElementValuePairs();

            AnnotationType annotationType = AnnotationType.getInstance(OJNIExportName.class);

            for (ElementValuePair elementValuePair : elementValuePairs) {

                if (annotationType.memberTypes().get(elementValuePair.getNameString()) != null) {
                    name = elementValuePair.getValue().stringifyValue();
                }
            }
        }
    }

    result.name = name;

    return result;
}