下面列出了java.lang.reflect.AnnotatedElement#getAnnotations ( ) 实例代码，或者点击链接到github查看源代码，也可以在右侧发表评论。
private AlfrescoAuthentication parseAnnotation(AnnotatedElement ae) {
AlfrescoAuthentication ann = ae.getAnnotation(AlfrescoAuthentication.class);
if (ann == null) {
for (Annotation metaAnn : ae.getAnnotations()) {
ann = metaAnn.annotationType().getAnnotation(AlfrescoAuthentication.class);
if (ann != null) {
break;
}
}
}
if (ann != null) {
return parseAnnotation(ann);
} else {
return null;
}
}
@SuppressWarnings("unchecked")
private void process(AnnotatedElement annotatedElement) {
if (this.visited.add(annotatedElement)) {
for (Annotation ann : annotatedElement.getAnnotations()) {
if (ObjectUtils.nullSafeEquals(this.annotationType, ann.annotationType())) {
this.result.add((A) ann);
}
else if (ObjectUtils.nullSafeEquals(this.containerAnnotationType, ann.annotationType())) {
this.result.addAll(getValue(ann));
}
else if (!isInJavaLangAnnotationPackage(ann)) {
process(ann.annotationType());
}
}
}
}
/**
* Checks if a Class or Method are annotated with the given annotation
*
* @param elem the Class or Method to reflect on
* @param annotationType the annotation type
* @param checkMetaAnnotations check for meta annotations
* @return true if annotations is present
*/
public static boolean hasAnnotation(AnnotatedElement elem, Class<? extends Annotation> annotationType,
boolean checkMetaAnnotations) {
if (elem.isAnnotationPresent(annotationType)) {
return true;
}
if (checkMetaAnnotations) {
for (Annotation a : elem.getAnnotations()) {
for (Annotation meta : a.annotationType().getAnnotations()) {
if (meta.annotationType().getName().equals(annotationType.getName())) {
return true;
}
}
}
}
return false;
}
@SuppressWarnings("unchecked")
private void process(AnnotatedElement element) {
if (this.visited.add(element)) {
try {
Annotation[] annotations = (this.declaredMode ? element.getDeclaredAnnotations() : element.getAnnotations());
for (Annotation ann : annotations) {
Class<? extends Annotation> currentAnnotationType = ann.annotationType();
if (ObjectUtils.nullSafeEquals(this.annotationType, currentAnnotationType)) {
this.result.add(synthesizeAnnotation((A) ann, element));
}
else if (ObjectUtils.nullSafeEquals(this.containerAnnotationType, currentAnnotationType)) {
this.result.addAll(getValue(element, ann));
}
else if (!isInJavaLangAnnotationPackage(ann)) {
process(currentAnnotationType);
}
}
}
catch (Exception ex) {
handleIntrospectionFailure(element, ex);
}
}
}
/**
* Parses all annotations declared on the Method
*
* @param ae
* @param annotationType
* Annotation type to look for
* @return
*/
private static <T extends Annotation> List<T> getMethodAnnotations(AnnotatedElement ae, Class<T> annotationType) {
List<T> anns = new ArrayList<T>(2);
// look for raw annotation
T ann = ae.getAnnotation(annotationType);
if (ann != null) {
anns.add(ann);
}
// look for meta-annotations
for (Annotation metaAnn : ae.getAnnotations()) {
ann = metaAnn.annotationType().getAnnotation(annotationType);
if (ann != null) {
anns.add(ann);
}
}
return (anns.isEmpty() ? null : anns);
}
private AlfrescoTransaction parseAnnotation(AnnotatedElement ae) {
AlfrescoTransaction ann = ae.getAnnotation(AlfrescoTransaction.class);
if (ann == null) {
for (Annotation metaAnn : ae.getAnnotations()) {
ann = metaAnn.annotationType().getAnnotation(AlfrescoTransaction.class);
if (ann != null) {
break;
}
}
}
if (ann != null) {
return parseAnnotation(ann);
} else {
return null;
}
}
private static <A extends Annotation> A getDeclaredAnnotation(AnnotatedElement element, Class<A> annotationType) {
for (Annotation annotation: element.getAnnotations()) {
if(annotation.annotationType().equals(annotationType)) {
return (A) annotation;
}
}
return null;
}
static Optional<Annotation> getImplementationDependencyAnnotation(AnnotatedElement element)
{
if (!containsImplementationDependencyAnnotation(element.getAnnotations())) {
return Optional.empty();
}
Annotation[] annotations = element.getAnnotations();
checkArgument(annotations.length == 1, "Meta parameters may only have a single annotation [%s]", element);
return Optional.of(annotations[0]);
}
@Override
protected void processType(AnnotatedElement type) {
String suffix="";
String prefix="";
if(excludePublicElementsFromDeclared()) {
suffix=" (excluding public)";
prefix="public ";
}
Annotation[] annotations=type.getAnnotations();
super.addTitle("AnnotatedElement");
super.addMultiField(prefix+"annotations", wrapElementArray(annotations));
super.addMultiField("declared annotations"+suffix, wrapElements(publicElementFilter(annotations,type.getDeclaredAnnotations())));
}
private static Set<Annotation> getScopes(AnnotatedElement element) {
Set<Annotation> scopes = new HashSet<>();
for (Annotation annotation : element.getAnnotations()) {
if (annotation.annotationType().isAnnotationPresent(Scope.class) || annotation.annotationType().isAnnotationPresent(NormalScope.class)) {
scopes.add(annotation);
}
}
return scopes;
}
/**
* Find all "whitelisted" annotations for given element.
*
* @param annotatedElement The target element.
* @return All found annotations.
*/
private static Collection<Annotation> findWhitelistedElementAnnotations(AnnotatedElement annotatedElement) {
final Annotation[] annotations = annotatedElement.getAnnotations();
final List<Annotation> whitelistedAnnotations = new ArrayList<>(annotations.length);
for (Annotation annotation : annotations) {
final Class<? extends Annotation> annotationType = annotation.annotationType();
if (shouldScan(annotationType)) {
whitelistedAnnotations.add(annotation);
}
}
return whitelistedAnnotations;
}
private <T extends Annotation> T getAnnotationOn(AnnotatedElement element, Class<T> referenceAnnotation, Pattern matchingAnnotationPattern) {
T matchingAnnotation = null;
Annotation[] annotations = element.getAnnotations();
for (Annotation annotation : annotations) {
if (validateCustomAnnotationPattern(annotation.annotationType().getName(), matchingAnnotationPattern)) {
if (matchingAnnotation != null) {
throw new IllegalStateException("You are not allowed to use more than one @" + referenceAnnotation.getName()
+ " annotations for the same element : "
+ element.toString());
}
matchingAnnotation = AnnotationProxyFactory.getAnnotationProxy(annotation, referenceAnnotation);
}
}
return matchingAnnotation;
}
private void addAnnotationsToMap(
Map<Class<? extends Annotation>, Annotation> annotationMap, AnnotatedElement object) {
if (object != null) {
for (Annotation annotation : object.getAnnotations()) {
annotationMap.put(annotation.annotationType(), annotation);
}
}
}
public MetaInfo withAnnotations( AnnotatedElement annotatedElement )
{
for( Annotation annotation : annotatedElement.getAnnotations() )
{
if( !ignored.contains( annotation.annotationType() )
&& get( annotation.annotationType() ) == null )
{
set( annotation );
}
}
return this;
}
/**
* Iterates the annotations of the entity method implementation, it validates that only one method annotation
* is used in the entity implementation method.
*
* @param element The annotated method of the entity
* @return a hashmap with keys 'method' and 'path'
* @throws MPException
*/
private static Map<String, Object> getRestInformation(AnnotatedElement element) throws MPException{
if (element.getAnnotations().length == 0) {
throw new MPException("No rest method found");
}
Map<String, Object> hashAnnotation = new HashMap<String, Object>();
for (Annotation annotation : element.getAnnotations()) {
if (annotation instanceof DELETE) {
DELETE delete = (DELETE) annotation;
if (StringUtils.isEmpty(delete.path())) {
throw new MPException("Path not found for DELETE method");
}
hashAnnotation = fillHashAnnotations(
hashAnnotation,
HttpMethod.DELETE,
delete.path(),
null,
delete.retries(),
delete.connectionTimeout(),
delete.connectionRequestTimeout(),
delete.socketTimeout());
} else if (annotation instanceof GET) {
GET get = (GET) annotation;
if (StringUtils.isEmpty(get.path())) {
throw new MPException("Path not found for GET method");
}
hashAnnotation = fillHashAnnotations(
hashAnnotation,
HttpMethod.GET,
get.path(),
null,
get.retries(),
get.connectionTimeout(),
get.connectionRequestTimeout(),
get.socketTimeout());
} else if (annotation instanceof POST) {
POST post = (POST) annotation;
if (StringUtils.isEmpty(post.path())) {
throw new MPException("Path not found for POST method");
}
hashAnnotation = fillHashAnnotations(
hashAnnotation,
HttpMethod.POST,
post.path(),
post.payloadType(),
post.retries(),
post.connectionTimeout(),
post.connectionRequestTimeout(),
post.socketTimeout());
} else if (annotation instanceof PUT) {
PUT put = (PUT) annotation;
if (StringUtils.isEmpty(put.path())) {
throw new MPException("Path not found for PUT method");
}
hashAnnotation = fillHashAnnotations(
hashAnnotation,
HttpMethod.PUT,
put.path(),
put.payloadType(),
put.retries(),
put.connectionTimeout(),
put.connectionRequestTimeout(),
put.socketTimeout());
}
}
return hashAnnotation;
}
public static Descriptor descriptorForElement(final AnnotatedElement elmt) {
if (elmt == null)
return ImmutableDescriptor.EMPTY_DESCRIPTOR;
final Annotation[] annots = elmt.getAnnotations();
return descriptorForAnnotations(annots);
}
public static Descriptor descriptorForElement(final AnnotatedElement elmt) {
if (elmt == null)
return ImmutableDescriptor.EMPTY_DESCRIPTOR;
final Annotation[] annots = elmt.getAnnotations();
return descriptorForAnnotations(annots);
}
/**
* 从某个类上获取注解对象，注解可以深度递归
* 如果存在多个继承注解，则优先获取浅层第一个注解，如果浅层不存在，则返回第一个获取到的注解
* 请尽可能保证仅存在一个或者一种继承注解，否则获取到的类型将不可控
*
* @param from 获取注解的某个类
* @param annotationType 想要获取的注解类型
* @param ignored 获取注解列表的时候的忽略列表
* @return 获取到的第一个注解对象
*/
public static <T extends Annotation> T getAnnotation(AnnotatedElement from, Class<T> annotationType, Class<T>... ignored) {
// 首先尝试获取缓存
T cache = getCache(from, annotationType);
if(cache != null){
return cache;
}
if(isNull(from, annotationType)){
return null;
}
//先尝试直接获取
T annotation = from.getAnnotation(annotationType);
//如果存在直接返回，否则查询
if (annotation != null) {
saveCache(from, annotation);
return annotation;
}
// 获取target注解
Target target = annotationType.getAnnotation(Target.class);
// 判断这个注解能否标注在其他注解上，如果不能，则不再深入获取
boolean annotationable = false;
if (target != null) {
for (ElementType elType : target.value()) {
if (elType == ElementType.TYPE || elType == ElementType.ANNOTATION_TYPE) {
annotationable = true;
break;
}
}
}
Annotation[] annotations = from.getAnnotations();
annotation = annotationable ? getAnnotationFromArrays(annotations, annotationType, ignored) : null;
// 如果还是获取不到，看看查询的注解类型有没有对应的ByNameType
if (annotation == null) {
annotation = getByNameAnnotation(from, annotationType);
}
// 如果无法通过注解本身所指向的byName注解获取，看看有没有反向指向此类型的注解
// 此情况下不进行深层获取
if(annotation == null){
annotation = getAnnotationFromByNames(annotations, annotationType);
}
// 如果最终不是null，计入缓存
if(annotation != null){
saveCache(from, annotation);
}else{
nullCache(from, annotationType);
}
return annotation;
}
public static Descriptor descriptorForElement(final AnnotatedElement elmt) {
if (elmt == null)
return ImmutableDescriptor.EMPTY_DESCRIPTOR;
final Annotation[] annots = elmt.getAnnotations();
return descriptorForAnnotations(annots);
}
/**
* Perform the search algorithm for the {@link #searchWithGetSemantics}
* method, avoiding endless recursion by tracking which annotated elements
* have already been <em>visited</em>.
* <p>The {@code metaDepth} parameter is explained in the
* {@link Processor#process process()} method of the {@link Processor} API.
* @param element the annotated element
* @param annotationTypes the annotation types to find
* @param annotationName the fully qualified class name of the annotation
* type to find (as an alternative to {@code annotationType})
* @param containerType the type of the container that holds repeatable
* annotations, or {@code null} if the annotation is not repeatable
* @param processor the processor to delegate to
* @param visited the set of annotated elements that have already been visited
* @param metaDepth the meta-depth of the annotation
* @return the result of the processor (potentially {@code null})
*/
@Nullable
private static <T> T searchWithGetSemantics(AnnotatedElement element,
Set<Class<? extends Annotation>> annotationTypes, @Nullable String annotationName,
@Nullable Class<? extends Annotation> containerType, Processor<T> processor,
Set<AnnotatedElement> visited, int metaDepth) {
if (visited.add(element)) {
try {
// Start searching within locally declared annotations
List<Annotation> declaredAnnotations = Arrays.asList(AnnotationUtils.getDeclaredAnnotations(element));
T result = searchWithGetSemanticsInAnnotations(element, declaredAnnotations,
annotationTypes, annotationName, containerType, processor, visited, metaDepth);
if (result != null) {
return result;
}
if (element instanceof Class) { // otherwise getAnnotations doesn't return anything new
Class<?> superclass = ((Class<?>) element).getSuperclass();
if (superclass != null && superclass != Object.class) {
List<Annotation> inheritedAnnotations = new LinkedList<>();
for (Annotation annotation : element.getAnnotations()) {
if (!declaredAnnotations.contains(annotation)) {
inheritedAnnotations.add(annotation);
}
}
// Continue searching within inherited annotations
result = searchWithGetSemanticsInAnnotations(element, inheritedAnnotations,
annotationTypes, annotationName, containerType, processor, visited, metaDepth);
if (result != null) {
return result;
}
}
}
}
catch (Throwable ex) {
AnnotationUtils.handleIntrospectionFailure(element, ex);
}
}
return null;
}