Java AnnotatedElementUtils.getMergedAnnotation方法代码示例

import org.springframework.core.annotation.AnnotatedElementUtils; //导入方法依赖的package包/类
private HandlerMethod getMethodHandlerMethodFunction(Object consumer, Method method) {
    final EventMapping mapping = AnnotatedElementUtils.getMergedAnnotation(method, EventMapping.class);
    if (mapping == null) {
        return null;
    }

    Preconditions.checkState(method.getParameterCount() == 1,
                             "Number of parameter should be 1. But {}",
                             (Object[]) method.getParameterTypes());
    // TODO: Support more than 1 argument. Like MVC's argument resolver?

    final Type type = method.getGenericParameterTypes()[0];

    final Predicate<Event> predicate = new EventPredicate(type);
    return new HandlerMethod(predicate, consumer, method,
                             getPriority(mapping, type));
}
 

import org.springframework.core.annotation.AnnotatedElementUtils; //导入方法依赖的package包/类
@Override
public void customizeContext(ConfigurableApplicationContext context,
		MergedContextConfiguration mergedContextConfiguration) {
	SpringBootTest annotation = AnnotatedElementUtils.getMergedAnnotation(
			mergedContextConfiguration.getTestClass(), SpringBootTest.class);
	if (annotation.webEnvironment().isEmbedded()) {
		registerTestRestTemplate(context);
	}
}
 

import org.springframework.core.annotation.AnnotatedElementUtils; //导入方法依赖的package包/类
private static boolean processDeps(List<Dependency> deps, AnnotatedElement ao) {
    if(!(AnnotatedElementUtils.isAnnotated(ao, Autowired.class))) {
        return false;
    }
    Qualifier qualifier = AnnotatedElementUtils.getMergedAnnotation(ao, Qualifier.class);
    String name = qualifier == null ? null : qualifier.value();
    Class<?> type = (ao instanceof Field)? ((Field)ao).getType() : ((Method)ao).getReturnType();
    deps.add(new Dependency(name, type));
    return true;
}
 

import org.springframework.core.annotation.AnnotatedElementUtils; //导入方法依赖的package包/类
private String convertToString(Field field, Object value) {
	Class<?> targetType = field.getType();

	if (Collection.class.isAssignableFrom(field.getType())) {
		targetType = resolveCollectionItemType(field);


		if (((Collection) value).isEmpty()) {
			return "";
		}
		else {
			ServletContextInitParameter servletContextInitParameter = AnnotatedElementUtils.getMergedAnnotation(field, ServletContextInitParameter.class);
			Iterator iterator = ((Collection) value).iterator();
			String firstValue = convertToString(targetType, iterator.next());

			StringBuilder sb = new StringBuilder(firstValue);
			while (iterator.hasNext()) {
				String nextValue = convertToString(targetType, iterator.next());
				sb.append(servletContextInitParameter.listSeparator()).append(nextValue);
			}
			return sb.toString();
		}
	}
	else {
		return convertToString(targetType, value);
	}
}
 

import org.springframework.core.annotation.AnnotatedElementUtils; //导入方法依赖的package包/类
private Annotation findMergedAnnotation(Class<?> source,
		Class<? extends Annotation> annotationType) {
	if (source == null) {
		return null;
	}
	Annotation mergedAnnotation = AnnotatedElementUtils.getMergedAnnotation(source,
			annotationType);
	return mergedAnnotation != null ? mergedAnnotation
			: findMergedAnnotation(source.getSuperclass(), annotationType);
}
 

import org.springframework.core.annotation.AnnotatedElementUtils; //导入方法依赖的package包/类
private FilterAnnotations get(Class<?> type) {
	Filters filters = AnnotatedElementUtils.getMergedAnnotation(type, Filters.class);
	return new FilterAnnotations(getClass().getClassLoader(), filters.value());
}
 

import org.springframework.core.annotation.AnnotatedElementUtils; //导入方法依赖的package包/类
DataMongoTypeExcludeFilter(final Class<?> testClass) {
    this.annotation = AnnotatedElementUtils.getMergedAnnotation(testClass,
            DataMongoTest.class);
}
 

import org.springframework.core.annotation.AnnotatedElementUtils; //导入方法依赖的package包/类
DataJpaTypeExcludeFilter(Class<?> testClass) {
	this.annotation = AnnotatedElementUtils.getMergedAnnotation(testClass,
			DataJpaTest.class);
}
 

import org.springframework.core.annotation.AnnotatedElementUtils; //导入方法依赖的package包/类
WebMvcTypeExcludeFilter(Class<?> testClass) {
	this.annotation = AnnotatedElementUtils.getMergedAnnotation(testClass,
			WebMvcTest.class);
}
 

import org.springframework.core.annotation.AnnotatedElementUtils; //导入方法依赖的package包/类
RestClientExcludeFilter(Class<?> testClass) {
	this.annotation = AnnotatedElementUtils.getMergedAnnotation(testClass,
			RestClientTest.class);
}
 

import org.springframework.core.annotation.AnnotatedElementUtils; //导入方法依赖的package包/类
JsonExcludeFilter(Class<?> testClass) {
	this.annotation = AnnotatedElementUtils.getMergedAnnotation(testClass,
			JsonTest.class);
}
 

import org.springframework.core.annotation.AnnotatedElementUtils; //导入方法依赖的package包/类
private boolean shouldInitializeFields(TestContext testContext) {
	AutoConfigureJsonTesters annotation = AnnotatedElementUtils.getMergedAnnotation(
			testContext.getTestClass(), AutoConfigureJsonTesters.class);
	return (annotation != null && annotation.initFields());
}
 

import org.springframework.core.annotation.AnnotatedElementUtils; //导入方法依赖的package包/类
protected SpringBootTest getAnnotation(Class<?> testClass) {
	return AnnotatedElementUtils.getMergedAnnotation(testClass, SpringBootTest.class);
}
 

import org.springframework.core.annotation.AnnotatedElementUtils; //导入方法依赖的package包/类
private SchedulerLock findAnnotation(Method method) {
    return AnnotatedElementUtils.getMergedAnnotation(method, SchedulerLock.class);
}
 

import org.springframework.core.annotation.AnnotatedElementUtils; //导入方法依赖的package包/类
SpringletsWebMvcExcludeFilter(Class<?> testClass) {
  this.annotation =
      AnnotatedElementUtils.getMergedAnnotation(testClass, SpringletsWebMvcTest.class);
}