Java AnnotatedObject.getAnnotation方法代码示例

import edu.umd.cs.findbugs.classfile.analysis.AnnotatedObject; //导入方法依赖的package包/类
private boolean analysisContextContained(XClass xclass) {
    AnnotatedObject ao = xclass;
    do {
        if (ao.getAnnotation(AnalysisContextContainedAnnotation) != null)
            return true;
        ao = ao.getContainingScope();

    } while (ao != null);
    return false;

}
 

import edu.umd.cs.findbugs.classfile.analysis.AnnotatedObject; //导入方法依赖的package包/类
private static @CheckForNull
TypeQualifierAnnotation checkFindBugsDefaultAnnotation(ClassDescriptor defaultAnnotation, AnnotatedObject o,
        TypeQualifierValue typeQualifierValue) {

    if (DEBUG_DEFAULT_ANNOTATION) {
        System.out.println("Checking for " + defaultAnnotation + " containing " + typeQualifierValue + " on " + o);
    }
    // - check to see if default annotation is present; if not, return null
    AnnotationValue annotationValue = o.getAnnotation(defaultAnnotation);
    if (annotationValue == null) {
        if (DEBUG_DEFAULT_ANNOTATION) {
            System.out.println("   ===> no " + defaultAnnotation);
        }
        return null;
    }

    // - get value - should be Type or array of Type
    Object value = annotationValue.getValue("value");
    if (value == null) {
        if (DEBUG_DEFAULT_ANNOTATION) {
            System.out.println("   ===> value is null");
        }
        return null;
    }
    Object[] types;
    if (value instanceof Object[]) {
        types = (Object[]) value;
    } else {
        types = new Object[] { value };
    }

    // - scan through array elements; see if any match the
    // TypeQualifierValue (including type qualifier nicknames)
    for (Object obj : types) {
        if (!(obj instanceof Type)) {
            if (DEBUG_DEFAULT_ANNOTATION) {
                System.out
                        .println("Found a non-Type value in value array of " + defaultAnnotation.toString() + " annotation");
            }
            continue;
        }

        Type type = (Type) obj;
        if (DEBUG_DEFAULT_ANNOTATION) {
            System.out.println("  ===> checking " + type.getDescriptor());
        }
        if (type.getDescriptor().startsWith("[")) {
            continue;
        }
        ClassDescriptor typeDesc = DescriptorFactory.instance().getClassDescriptor(type.getInternalName());

        // There is no general way to figure out whether a particular
        // type is a type qualifier we're interested in without
        // resolving it.
        AnnotationValue annotation = new AnnotationValue(typeDesc);
        Collection<AnnotationValue> resolvedTypeQualifiers = TypeQualifierResolver.resolveTypeQualifiers(annotation);
        TypeQualifierAnnotation tqa = extractAnnotation(resolvedTypeQualifiers, typeQualifierValue);
        if (tqa != null)
            return tqa;

    }

    return null;
}
 

import edu.umd.cs.findbugs.classfile.analysis.AnnotatedObject; //导入方法依赖的package包/类
/**
 * Look for a default type qualifier annotation.
 *
 * @param o
 *            an AnnotatedObject
 * @param typeQualifierValue
 *            a TypeQualifierValue
 * @param elementType
 *            type of element for which we're looking for a default
 *            annotation
 * @return default TypeQualifierAnnotation, or null if none
 */
private static @CheckForNull
TypeQualifierAnnotation getDefaultAnnotation(AnnotatedObject o, TypeQualifierValue<?> typeQualifierValue, ElementType elementType) {
    //
    // Try to find a default annotation using the standard JSR-305
    // default annotation mechanism.
    //
    TypeQualifierAnnotation result;
    Collection<AnnotationValue> values = TypeQualifierResolver.resolveTypeQualifierDefaults(o.getAnnotations(), elementType);
    TypeQualifierAnnotation tqa = extractAnnotation(values, typeQualifierValue);

    if (tqa != null) {
        // System.out.println("Found default annotation of " + tqa +
        // " for element " + elementType + " in " + o);
        return tqa;
    }

    //
    // Try one of the FindBugs-specific default annotation mechanisms.
    //

    if ((result = checkFindBugsDefaultAnnotation(FindBugsDefaultAnnotations.DEFAULT_ANNOTATION, o, typeQualifierValue)) != null) {
        return result;
    }

    switch (elementType) {
    case FIELD:
        result = checkFindBugsDefaultAnnotation(FindBugsDefaultAnnotations.DEFAULT_ANNOTATION_FOR_FIELDS, o,
                typeQualifierValue);
        break;
    case METHOD:
        result = checkFindBugsDefaultAnnotation(FindBugsDefaultAnnotations.DEFAULT_ANNOTATION_FOR_METHODS, o,
                typeQualifierValue);
        break;
    case PARAMETER:
        result = checkFindBugsDefaultAnnotation(FindBugsDefaultAnnotations.DEFAULT_ANNOTATION_FOR_PARAMETERS, o,
                typeQualifierValue);
        break;
    default:
        // ignore
    }

    // Try out default JDT (Eclipse) annotations
    if(result == null){
        AnnotationValue annotationValue = o.getAnnotation(TypeQualifierResolver.eclipseNonNullByDefault);
        if(annotationValue != null){
            Collection<AnnotationValue> resolvedTypeQualifiers = TypeQualifierResolver.resolveTypeQualifiers(annotationValue);
            tqa = extractAnnotation(resolvedTypeQualifiers, typeQualifierValue);
            if(tqa != null){
                return tqa;
            }
        }
    }
    return result;
}
 

import edu.umd.cs.findbugs.classfile.analysis.AnnotatedObject; //导入方法依赖的package包/类
private static @CheckForNull
TypeQualifierAnnotation checkFindBugsDefaultAnnotation(ClassDescriptor defaultAnnotation, AnnotatedObject o,
        TypeQualifierValue<?> typeQualifierValue) {

    if (DEBUG_DEFAULT_ANNOTATION) {
        System.out.println("Checking for " + defaultAnnotation + " containing " + typeQualifierValue + " on " + o);
    }
    // - check to see if default annotation is present; if not, return null
    AnnotationValue annotationValue = o.getAnnotation(defaultAnnotation);
    if (annotationValue == null) {
        if (DEBUG_DEFAULT_ANNOTATION) {
            System.out.println("   ===> no " + defaultAnnotation);
        }
        return null;
    }

    // - get value - should be Type or array of Type
    Object value = annotationValue.getValue("value");
    if (value == null) {
        if (DEBUG_DEFAULT_ANNOTATION) {
            System.out.println("   ===> value is null");
        }
        return null;
    }
    Object[] types;
    if (value instanceof Object[]) {
        types = (Object[]) value;
    } else {
        types = new Object[] { value };
    }

    // - scan through array elements; see if any match the
    // TypeQualifierValue (including type qualifier nicknames)
    for (Object obj : types) {
        if (!(obj instanceof Type)) {
            if (DEBUG_DEFAULT_ANNOTATION) {
                System.out
                        .println("Found a non-Type value in value array of " + defaultAnnotation.toString() + " annotation");
            }
            continue;
        }

        Type type = (Type) obj;
        if (DEBUG_DEFAULT_ANNOTATION) {
            System.out.println("  ===> checking " + type.getDescriptor());
        }
        if (type.getDescriptor().startsWith("[")) {
            continue;
        }
        ClassDescriptor typeDesc = DescriptorFactory.instance().getClassDescriptor(type.getInternalName());

        // There is no general way to figure out whether a particular
        // type is a type qualifier we're interested in without
        // resolving it.
        AnnotationValue annotation = new AnnotationValue(typeDesc);
        Collection<AnnotationValue> resolvedTypeQualifiers = TypeQualifierResolver.resolveTypeQualifiers(annotation);
        TypeQualifierAnnotation tqa = extractAnnotation(resolvedTypeQualifiers, typeQualifierValue);
        if (tqa != null)
            return tqa;

    }

    return null;
}