Java Code Examples for org.springframework.core.annotation.AnnotatedElementUtils#getMergedAnnotationAttributes()

@Override
public void registerBeanDefinitions(AnnotationMetadata metadata,
		BeanDefinitionRegistry registry) {
	AnnotationAttributes attrs = AnnotatedElementUtils.getMergedAnnotationAttributes(
			ClassUtils.resolveClassName(metadata.getClassName(), null),
			EnableBinding.class);
	for (Class<?> type : collectClasses(attrs, metadata.getClassName())) {
		if (!registry.containsBeanDefinition(type.getName())) {
			BindingBeanDefinitionRegistryUtils.registerBindingTargetBeanDefinitions(
					type, type.getName(), registry);
			BindingBeanDefinitionRegistryUtils
					.registerBindingTargetsQualifiedBeanDefinitions(ClassUtils
							.resolveClassName(metadata.getClassName(), null), type,
							registry);
		}
	}
}
 

@Test
public void test(){
	//RestApiClient需要加@Inherited
	AnnotationAttributes annoAttr = AnnotatedElementUtils.getMergedAnnotationAttributes(SubTestClass.class, RestApiClient.class);
	assertThat(annoAttr).isNull();

	//不需要加@Inherited
	RestApiClient anno = AnnotationUtils.findAnnotation(SubTestClass.class, RestApiClient.class);
	assertThat(anno).isNotNull();
	

	anno = AnnotationUtils.findAnnotation(SubTestClass2.class, RestApiClient.class);
	assertThat(anno).isNotNull();
	assertThat(anno.name()).isEqualTo("RestApiClientTestContainerName");
	assertThat(anno.url()).isEqualTo("http://RestApiClientTestContainer");
}
 

@Override
@Nullable
public Map<String, Object> getAnnotationAttributes(String annotationName, boolean classValuesAsString) {
	if (this.nestedAnnotationsAsMap) {
		return MethodMetadata.super.getAnnotationAttributes(annotationName, classValuesAsString);
	}
	return AnnotatedElementUtils.getMergedAnnotationAttributes(this.introspectedMethod,
			annotationName, classValuesAsString, false);
}
 

@Override
@Nullable
public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
	AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(
			element, javax.transaction.Transactional.class);
	if (attributes != null) {
		return parseTransactionAnnotation(attributes);
	}
	else {
		return null;
	}
}
 

/**
 * Determine a suggested value from any of the given candidate annotations.
 */
@Nullable
protected Object findValue(Annotation[] annotationsToSearch) {
	if (annotationsToSearch.length > 0) {   // qualifier annotations have to be local
		AnnotationAttributes attr = AnnotatedElementUtils.getMergedAnnotationAttributes(
				AnnotatedElementUtils.forAnnotations(annotationsToSearch), this.valueAnnotationType);
		if (attr != null) {
			return extractValue(attr);
		}
	}
	return null;
}
 

@Override
@Nullable
public Map<String, Object> getAnnotationAttributes(String annotationName, boolean classValuesAsString) {
	if (this.nestedAnnotationsAsMap) {
		return AnnotationMetadata.super.getAnnotationAttributes(annotationName, classValuesAsString);
	}
	return AnnotatedElementUtils.getMergedAnnotationAttributes(
			getIntrospectedClass(), annotationName, classValuesAsString, false);
}
 

@Override
@Nullable
public TransactionAttribute parseTransactionAnnotation(AnnotatedElement element) {
	AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(
			element, javax.transaction.Transactional.class);
	if (attributes != null) {
		return parseTransactionAnnotation(attributes);
	}
	else {
		return null;
	}
}
 

private AnnotationAttributes findAutowiredAnnotation(AccessibleObject ao) {
	if (ao.getAnnotations().length > 0) {
		for (Class<? extends Annotation> type : this.autowiredAnnotationTypes) {
			AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ao, type);
			if (attributes != null) {
				return attributes;
			}
		}
	}
	return null;
}
 

/**
 * Determine a suggested value from any of the given candidate annotations.
 */
@Nullable
protected Object findValue(Annotation[] annotationsToSearch) {
	if (annotationsToSearch.length > 0) {   // qualifier annotations have to be local
		AnnotationAttributes attr = AnnotatedElementUtils.getMergedAnnotationAttributes(
				AnnotatedElementUtils.forAnnotations(annotationsToSearch), this.valueAnnotationType);
		if (attr != null) {
			return extractValue(attr);
		}
	}
	return null;
}
 

@Override
public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
	AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ae, Transactional.class);
	if (attributes != null) {
		return parseTransactionAnnotation(attributes);
	}
	else {
		return null;
	}
}
 

@Override
public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
	AnnotationAttributes attributes =
			AnnotatedElementUtils.getMergedAnnotationAttributes(ae, javax.transaction.Transactional.class);
	if (attributes != null) {
		return parseTransactionAnnotation(attributes);
	}
	else {
		return null;
	}
}
 

@Override
public TransactionAttribute parseTransactionAnnotation(AnnotatedElement ae) {
	AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(ae, Transactional.class);
	if (attributes != null) {
		return parseTransactionAnnotation(attributes);
	}
	else {
		return null;
	}
}
 

public static Optional<AnnotationAttributes> getAnnotationAttributes(Method method, Class<? extends Annotation> annoClass, boolean searchOnClass){
	AnnotationAttributes attrs = null;
	if(searchOnClass){
		attrs = AnnotatedElementUtils.getMergedAnnotationAttributes(method, annoClass);
		if(attrs==null){
			Class<?> clazz = method.getDeclaringClass();
			attrs = AnnotatedElementUtils.getMergedAnnotationAttributes(clazz, annoClass);
		}
	}else{
		attrs = AnnotatedElementUtils.getMergedAnnotationAttributes(method, annoClass);
	}
	return Optional.ofNullable(attrs);
}
 

/**
 * Determine a suggested value from any of the given candidate annotations.
 */
protected Object findValue(Annotation[] annotationsToSearch) {
	AnnotationAttributes attr = AnnotatedElementUtils.getMergedAnnotationAttributes(
			AnnotatedElementUtils.forAnnotations(annotationsToSearch), this.valueAnnotationType);
	if (attr != null) {
		return extractValue(attr);
	}
	return null;
}
 

@Test
	public void testInterceptableCombine1(){
		Annotation[] annos = InterceptableCombine1.class.getAnnotations();
		List<Annotation> inters = Stream.of(annos).filter(anno->{
			/*String clsName = anno.annotationType().getName();
			MetadataReader meta;
			try {
				meta = metadataReaderFactory.getMetadataReader(clsName);
			} catch (Exception e) {
				throw new BaseException("error", e);
			}
			boolean annoted = meta.getAnnotationMetadata().isAnnotated(Interceptor.class.getName());*/
//			Interceptor inter = anno.annotationType().getAnnotation(Interceptor.class);
			boolean res = anno.annotationType().isAnnotationPresent(InterceptorTest.class);
			return res;
		})
		.collect(Collectors.toList());
		assertThat(inters).isNotEmpty();
		Annotation combina = inters.get(0);
		assertThat(combina).isInstanceOf(CombinationMVCInterceptor.class);
		
		//查找包含了@Interceptor注解的注解
		List<Annotation> combines = AnnotationUtils.findCombineAnnotations(InterceptableCombine1.class, InterceptorTest.class);
		assertThat(combines).isNotEmpty();
		
		//combines.get(0).annotationType() = @CombinationMVCInterceptor
		Class<?> combinationMVCInterceptorClass = combines.get(0).annotationType();
		assertThat(combinationMVCInterceptorClass).isEqualTo(CombinationMVCInterceptor.class);
		//@CombinationMVCInterceptor注解虽然包含了@Interceptor注解，但是因为是可重复的，直接查找@Interceptor是找不到的
		AnnotationAttributes attrs = AnnotatedElementUtils.getMergedAnnotationAttributes(combinationMVCInterceptorClass, InterceptorTest.class);
		assertThat(attrs).isNotNull();
		
		

		//其实还可以直接在使用了@CombinationMVCInterceptor注解的类上面直接查找@Interceptor
		//但是会包含合并了的父类的注解，前提是子类和父类使用了不同的注解，如InterceptableCombine1类使用了包含@Interceptor的组合注解，而父类直接使用了@Interceptor注解
		attrs = AnnotatedElementUtils.getMergedAnnotationAttributes(InterceptableCombine1.class, InterceptorTest.class);
		assertThat(attrs).isNotNull();
		assertThat(attrs.getClass("value")).isEqualTo(Combine1MvcInterceptor.class);
		
		//根据注解先后顺序只获取到第一个。。。
		attrs = AnnotatedElementUtils.getMergedAnnotationAttributes(InterceptableCombine2.class, InterceptorTest.class);
		assertThat(attrs).isNotNull();
		assertThat(attrs.getClass("value")).isEqualTo(Combine2MvcInterceptor.class);
	}
 

@Override
public Map<String, Object> getAnnotationAttributes(String annotationName, boolean classValuesAsString) {
	return (this.annotations.length > 0 ? AnnotatedElementUtils.getMergedAnnotationAttributes(
			getIntrospectedClass(), annotationName, classValuesAsString, this.nestedAnnotationsAsMap) : null);
}
 

@Override
public Map<String, Object> getAnnotationAttributes(String annotationName, boolean classValuesAsString) {
	return (this.annotations.length > 0 ? AnnotatedElementUtils.getMergedAnnotationAttributes(
			getIntrospectedClass(), annotationName, classValuesAsString, this.nestedAnnotationsAsMap) : null);
}
 

private void registerFeignClients(AnnotationMetadata metadata, BeanDefinitionRegistry registry) {
	List<String> feignClients = SpringFactoriesLoader.loadFactoryNames(getSpringFactoriesLoaderFactoryClass(), getBeanClassLoader());
	// 如果 spring.factories 里为空
	if (feignClients.isEmpty()) {
		return;
	}
	for (String className : feignClients) {
		try {
			Class<?> clazz = beanClassLoader.loadClass(className);
			AnnotationAttributes attributes = AnnotatedElementUtils.getMergedAnnotationAttributes(clazz, FeignClient.class);
			if (attributes == null) {
				continue;
			}
			// 如果已经存在该 bean，支持原生的 Feign
			if (registry.containsBeanDefinition(className)) {
				continue;
			}
			registerClientConfiguration(registry, getClientName(attributes), attributes.get("configuration"));

			validate(attributes);
			BeanDefinitionBuilder definition = BeanDefinitionBuilder.genericBeanDefinition(FeignClientFactoryBean.class);
			definition.addPropertyValue("url", getUrl(attributes));
			definition.addPropertyValue("path", getPath(attributes));
			String name = getName(attributes);
			definition.addPropertyValue("name", name);

			// 兼容最新版本的 spring-cloud-openfeign，尚未发布
			StringBuilder aliasBuilder = new StringBuilder(18);
			if (attributes.containsKey("contextId")) {
				String contextId = getContextId(attributes);
				aliasBuilder.append(contextId);
				definition.addPropertyValue("contextId", contextId);
			} else {
				aliasBuilder.append(name);
			}

			definition.addPropertyValue("type", className);
			definition.addPropertyValue("decode404", attributes.get("decode404"));
			definition.addPropertyValue("fallback", attributes.get("fallback"));
			definition.addPropertyValue("fallbackFactory", attributes.get("fallbackFactory"));
			definition.setAutowireMode(AbstractBeanDefinition.AUTOWIRE_BY_TYPE);

			AbstractBeanDefinition beanDefinition = definition.getBeanDefinition();

			// alias
			String alias = aliasBuilder.append("FeignClient").toString();

			// has a default, won't be null
			boolean primary = (Boolean)attributes.get("primary");

			beanDefinition.setPrimary(primary);

			String qualifier = getQualifier(attributes);
			if (StringUtils.hasText(qualifier)) {
				alias = qualifier;
			}

			BeanDefinitionHolder holder = new BeanDefinitionHolder(beanDefinition, className, new String[] { alias });
			BeanDefinitionReaderUtils.registerBeanDefinition(holder, registry);

		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
	}
}
 

public static void main(String[] args) {

//        AnnotatedElement annotatedElement = TransactionalService.class;

        AnnotatedElement annotatedElement = TransactionalServiceBean.class;

        // 获取 @Service 注解属性独享
        AnnotationAttributes serviceAttributes =
                AnnotatedElementUtils.getMergedAnnotationAttributes(annotatedElement, Service.class);

        // 获取 @Transactional 注解属性独享
        AnnotationAttributes transactionalAttributes =
                AnnotatedElementUtils.getMergedAnnotationAttributes(annotatedElement, Transactional.class);

        // 输出
        print(serviceAttributes);

        print(transactionalAttributes);
    }
 

@Override
@Nullable
public Map<String, Object> getAnnotationAttributes(String annotationName, boolean classValuesAsString) {
	return AnnotatedElementUtils.getMergedAnnotationAttributes(this.introspectedMethod,
			annotationName, classValuesAsString, this.nestedAnnotationsAsMap);
}