java.lang.reflect.AccessibleObject#isAnnotationPresent ( )源码实例Demo

/**
 * Given a reflective method or a constructor, creates a dynamic method that represents it. This method will
 * distinguish between caller sensitive and ordinary methods/constructors, and create appropriate caller sensitive
 * dynamic method when needed.
 * @param m the reflective member
 * @return the single dynamic method representing the reflective member
 */
private static SingleDynamicMethod createDynamicMethod(final AccessibleObject m) {
    if (m.isAnnotationPresent(CallerSensitive.class)) {
        // Method has @CallerSensitive annotation
        return new CallerSensitiveDynamicMethod(m);
    }
    // Method has no @CallerSensitive annotation
    final MethodHandle mh;
    try {
        mh = unreflectSafely(m);
    } catch (final IllegalAccessError e) {
        // java.lang.invoke can in some case conservatively treat as caller sensitive methods that aren't
        // marked with the annotation. In this case, we'll fall back to treating it as caller sensitive.
        return new CallerSensitiveDynamicMethod(m);
    }
    // Proceed with non-caller sensitive
    final Member member = (Member)m;
    return new SimpleDynamicMethod(mh, member.getDeclaringClass(), member.getName(), m instanceof Constructor);
}
 

/**
 * Constructs a SPARQL VALUES clause for successive binding of the given objects {@link Iri} mappings,
 * to the SPARQL variable <code>binding</code>.
 * The IRIs of the resources are enclosed in <code>&lt;&gt;</code> brackets.
 * @param objects The values to successively bind.
 * @param binding The name of the binding without a leading <code>"?"</code>.
 * @return Returns a SPARQL VALUES clause with the given resources and binding.
 */
private String buildValuesClause(Collection<AccessibleObject> objects, String binding) {
    StringBuilder clause = new StringBuilder("VALUES ?")
            .append(binding)
            .append(" {");

    for (AccessibleObject object : objects) {
        if(object.isAnnotationPresent(Iri.class)) {
            Iri iri = object.getAnnotation(Iri.class);

            clause.append(" <")
                    .append(iri.value())
                    .append("> ");
        }
    }
    clause.append("}");

    return clause.toString();
}
 

private static String annotatedName(AccessibleObject obj) {
  if (obj.isAnnotationPresent(PropertyName.class)) {
    PropertyName annotation = obj.getAnnotation(PropertyName.class);
    return annotation.value();
  }

  return null;
}
 

private static Member findAnnotatedMember(AccessibleObject[] members,
                                          Class<? extends Annotation> annotation) {
    for (AccessibleObject member : members) {
        if (member.isAnnotationPresent(annotation)) {
            return (Member) member;
        }
    }
    return null;
}
 

private static String annotatedName(AccessibleObject obj) {
  if (obj.isAnnotationPresent(PropertyName.class)) {
    PropertyName annotation = obj.getAnnotation(PropertyName.class);
    return annotation.value();
  }

  return null;
}
 

private CascadeType[] getCascadeTypes(AccessibleObject accessibleObject) {
    CascadeType[] cascadeTypes = null;
    if(accessibleObject.isAnnotationPresent(OneToMany.class)) {
        cascadeTypes = accessibleObject.getAnnotation(OneToMany.class).cascade();
    }else if(accessibleObject.isAnnotationPresent(ManyToOne.class)) {
        cascadeTypes = accessibleObject.getAnnotation(ManyToOne.class).cascade();
    }else if(accessibleObject.isAnnotationPresent(ManyToMany.class)) {
        cascadeTypes = accessibleObject.getAnnotation(ManyToMany.class).cascade();
    }
    return cascadeTypes;
}
 

public void test_isAnnotationPresent() throws Exception {
    AccessibleObject ao = SubTestClass.class.getMethod("annotatedMethod");
    assertTrue("Missing @AnnotationRuntime0",
            ao.isAnnotationPresent(AnnotationRuntime0.class));
    assertFalse("AnnotationSource0 should not be visible at runtime",
            ao.isAnnotationPresent(AnnotationSource0.class));
    boolean npeThrown = false;
    try {
      ao.isAnnotationPresent(null);
      fail("NPE expected");
    } catch (NullPointerException e) {
        npeThrown = true;
    }
    assertTrue("NPE expected", npeThrown);
}
 

private boolean hasInjectAnnotation(AccessibleObject f) {
  return f.isAnnotationPresent(com.google.inject.Inject.class)
      || f.isAnnotationPresent(javax.inject.Inject.class)
      || f.isAnnotationPresent(InjectTestWorkspace.class)
      || f.isAnnotationPresent(InjectTestOrganization.class)
      || f.isAnnotationPresent(InjectPageObject.class);
}
 

private static boolean isCallerSensitive(final AccessibleObject e) {
    return e.isAnnotationPresent(CallerSensitive.class);
}
 

private static boolean isCallerSensitive(final AccessibleObject e) {
    return e.isAnnotationPresent(CallerSensitive.class);
}
 

public boolean apply(AccessibleObject ao) {
/* 332 */         return ao.isAnnotationPresent(MonkeyRunnerExported.class);
/*     */       }
 

private static boolean isCallerSensitive(final AccessibleObject e) {
    return e.isAnnotationPresent(CallerSensitive.class);
}
 

private static boolean isCallerSensitive(final AccessibleObject e) {
    return e.isAnnotationPresent(CallerSensitive.class);
}
 

private static boolean isCallerSensitive(final AccessibleObject e) {
    return e.isAnnotationPresent(CallerSensitive.class);
}
 

private static boolean isCallerSensitive(final AccessibleObject e) {
    return e.isAnnotationPresent(CallerSensitive.class);
}
 

private static boolean isCallerSensitive(final AccessibleObject e) {
    return e.isAnnotationPresent(CallerSensitive.class);
}
 

private static boolean isCallerSensitive(final AccessibleObject e) {
    return e.isAnnotationPresent(CallerSensitive.class);
}
 

private boolean hasAliasAnnotation(AccessibleObject accessibleObject) {
    return accessibleObject.isAnnotationPresent(Alias.class);
}
 

@Override
public boolean test(final AccessibleObject a) {
  return a.isAnnotationPresent(this.clazz);
}
 

/**
 * Returns <code>true</code> if annotation is present on
 * given accessible object.
 */
public boolean hasAnnotation(AccessibleObject accessibleObject) {
    return accessibleObject.isAnnotationPresent(annotationClass);
}