Java Annotation.annotationType方法代码示例

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
/**
 * Returns the binding annotation on {@code member}, or null if there isn't one.
 */
public static Annotation findBindingAnnotation(
    Errors errors, Member member, Annotation[] annotations) {
  Annotation found = null;

  for (Annotation annotation : annotations) {
    Class<? extends Annotation> annotationType = annotation.annotationType();
    if (isBindingAnnotation(annotationType)) {
      if (found != null) {
        errors.duplicateBindingAnnotations(member, found.annotationType(), annotationType);
      } else {
        found = annotation;
      }
    }
  }

  return found;
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
private static boolean isInjectedField(final Field field) {
    for (final Annotation a : field.getDeclaredAnnotations()) {
        final Class<?> t = a.annotationType();
        if (t == javax.inject.Inject.class ||
                t == javax.ws.rs.core.Context.class ||
                t == javax.ws.rs.CookieParam.class ||
                t == javax.ws.rs.FormParam.class ||
                t == javax.ws.rs.HeaderParam.class ||
                t == javax.ws.rs.QueryParam.class ||
                t == javax.ws.rs.PathParam.class ||
                t == javax.ws.rs.BeanParam.class ||
                t == OptionalClasses.PERSISTENCE_CONTEXT) {
            return true;
        }
    }
    return false;
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
private void processAnnotations(Object device) {

		if (device==null) return;

		final Method[] methods = device.getClass().getMethods();
		for (int i = 0; i < methods.length; i++) {
			final Annotation[] as = methods[i].getAnnotations();
			if (as!=null) for (Annotation annotation : as) {
				Class<? extends Annotation> clazz = annotation.annotationType();
				if (this.annotations.contains(clazz)) {
					Collection<MethodWrapper> ms = annotationMap.get(clazz);
					if (ms == null) {
						ms = new ArrayList<>(31);
						annotationMap.put(clazz, ms);
					}
					ms.add(new MethodWrapper(clazz, device, methods[i]));
				}
			}
		}
	}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
private static List<Map<String, Object>> getEntityAnnos(Object targetClass, String annotationName) {
	Annotation[] anno = null;
	if (targetClass instanceof Field)
		anno = ((Field) targetClass).getAnnotations();
	else
		anno = ((Class<?>) targetClass).getAnnotations();
	List<Map<String, Object>> l = new ArrayList<Map<String, Object>>();
	for (Annotation annotation : anno) {
		Class<? extends Annotation> type = annotation.annotationType();
		String cName = type.getName();
		if (matchNameCheck(annotationName, cName)) {
			l.add(changeAnnotationValuesToMap(annotation, type));
		}
	}
	return l;
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
/**
 * Invokes the annotation of the given field
 *
 * @param field           field
 * @param annotationClazz annotation
 * @param <T>             returnType
 * @return returnValue
 */
public static <T extends Annotation> T invokeAnnotationByField(Field field, Class<T> annotationClazz) {
    if (field == null)
        throw new IllegalArgumentException("Field cannot be null!");
    if (annotationClazz == null)
        throw new IllegalArgumentException("AnnotationClass cannot be null!");
    for (final Annotation annotation : field.getDeclaredAnnotations()) {
        if (annotation.annotationType() == annotationClazz)
            return (T) annotation;
    }
    return null;
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
protected Class<?> getAnnotation(Class<?> c) {
  // we should get only declared annotations, not inherited ones
  Annotation[] anns = c.getDeclaredAnnotations();

  for (Annotation ann : anns) {
    // Hadoop clearly got it wrong for not making the annotation values (private, public, ..)
    // an enum instead we have three independent annotations!
    Class<?> type = ann.annotationType();
    if (isInterfaceAudienceClass(type)) {
      return type;
    }
  }
  return null;
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
private boolean getAlwaysRunFromAnnotation(final Annotation methodAnnotation) {
    if (methodAnnotation.annotationType() == OurBeforeSuite.class) {
        return ((OurBeforeSuite) methodAnnotation).alwaysRun();
    }
    if (methodAnnotation.annotationType() == OurBeforeGroups.class) {
        return ((OurBeforeGroups) methodAnnotation).alwaysRun();
    }
    if (methodAnnotation.annotationType() == OurAfterGroups.class) {
        return ((OurAfterGroups) methodAnnotation).alwaysRun();
    }

    return methodAnnotation.annotationType() != OurAfterSuite.class || ((OurAfterSuite) methodAnnotation).alwaysRun();
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
/**
 * Gets the class of the value annotation belonging
 * to a field, null if there is none.
 *
 * @param field Field being checked
 * @return The value annotation of the field
 */
private static Class<? extends Annotation> getValueAnnotation(Field field) {
    // Values must have a label annotation
    if (!field.isAnnotationPresent(Label.class))
        return null;

    // Find a valid value type annotation, if any
    Annotation a = Arrays.stream(field.getDeclaredAnnotations())
            .filter(annotation -> annotation.annotationType().isAnnotationPresent(ValueDefinition.class))
            .findFirst().orElse(null);

    return a != null ? a.annotationType() : null;
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
@Nullable public static Annotation findAnnotation(Set<? extends Annotation> annotations,
    Class<? extends Annotation> annotationClass) {
  if (annotations.isEmpty()) return null; // Save an iterator in the common case.
  for (Annotation annotation : annotations) {
    if (annotation.annotationType() == annotationClass) return annotation;
  }
  return null;
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
/**
 * Finds the specified annotation from the array and returns it.
 * Null if not found.
 */
public <A extends Annotation> A get( Class<A> annotationType ) {
    for (Annotation a : annotations) {
        if(a.annotationType()==annotationType)
            return annotationType.cast(a);
    }
    return null;
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
private static void printArrContents(Annotation[] actualAnnos) {
    System.out.print("Actual Arr Values: ");
    for (Annotation a : actualAnnos) {
        if (a != null && a.annotationType() != null) {
            System.out.print("[" + a.toString() + "]");
        } else {
            System.out.println("[null]");
        }
    }
    System.out.println();
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
/**
 * Invokes the annotation of the given method
 *
 * @param method          method
 * @param annotationClazz annotation
 * @param <T>             returnType
 * @return returnValue
 */
public static <T extends Annotation> T invokeAnnotationByMethod(Method method, Class<T> annotationClazz) {
    if (method == null)
        throw new IllegalArgumentException("Method cannot be null!");
    if (annotationClazz == null)
        throw new IllegalArgumentException("AnnotationClass cannot be null!");
    for (final Annotation annotation : method.getDeclaredAnnotations()) {
        if (annotation.annotationType() == annotationClazz)
            return (T) annotation;
    }
    return null;
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
private static boolean hasRequestBodyAnnotation(Annotation[][] annotations) {
    if (annotations.length == 1) {
        Annotation[] containerAnnotations = annotations[0];
        for (Annotation annotation : containerAnnotations) {
            Type annotationType = annotation.annotationType();
            if (annotationType == RequestBody.class) {
                return true;
            }
        }
    }
    return false;
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
private void processAnnotation(final Annotation annotation) {
    final Class<? extends Annotation> annType = annotation.annotationType();

    if (annType == Context.class) {
        setStrategy(Strategy.CONTEXT);

    } else if (annType == CookieParam.class) {
        processCookieParamAnnotation((CookieParam) annotation);

    } else if (annType == FormParam.class) {
        processFormParamAnnotation((FormParam) annotation);

    } else if (annType == HeaderParam.class) {
        processHeaderParamAnnotation((HeaderParam) annotation);

    } else if (annType == Named.class) {
        processNamedAnnotation((Named) annotation);

    } else if (annType == PathParam.class) {
        processPathParamAnnotation((PathParam) annotation);

    } else if (annType == OptionalClasses.PERSISTENCE_CONTEXT) {
        processPersistenceContextAnnotation((PersistenceContext) annotation);

    } else if (annType == QueryParam.class) {
        processQueryParamAnnotation((QueryParam) annotation);

    } else if (annType == DefaultValue.class) {
        defaultValue = (DefaultValue) annotation;

    } else if (annType.isAnnotationPresent(Qualifier.class)) {
        processQualifierAnnotation(annType);
    }
}
 

import java.lang.annotation.Annotation; //导入方法依赖的package包/类
private Class<? extends Annotation> search(
        final Field field
) {
    final Annotation[] annotations = field.getDeclaredAnnotations();
    final Set<Class<? extends Annotation>>
            annotationCls = Plugins.INFIX_MAP.keySet();
    Class<? extends Annotation> hitted = null;
    for (final Annotation annotation : annotations) {
        if (annotationCls.contains(annotation.annotationType())) {
            hitted = annotation.annotationType();
            break;
        }
    }
    return hitted;
}