Java Code Examples for java.lang.reflect.AnnotatedElement

The following examples show how to use java.lang.reflect.AnnotatedElement. These examples are extracted from open source projects. You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.
Example 1
/**
 * Given a single-argument method whose parameter is a {@link Collection}, use
 * the method's generic type information to determine the collection element
 * type and store it as the ITEM_CLASS_NAME attribute of the given Element.
 * 
 * @param method
 *          the setter method
 * @param paramElt
 *          the PARAMETER element
 */
private void determineCollectionElementType(AnnotatedElement method,
    Type paramType, Element paramElt) {
  if(paramElt.getAttributeValue("ITEM_CLASS_NAME") == null) {
    Class<?> elementType;
    CreoleParameter paramAnnot = method.getAnnotation(CreoleParameter.class);
    if(paramAnnot != null
        && paramAnnot.collectionElementType() != CreoleParameter.NoElementType.class) {
      elementType = paramAnnot.collectionElementType();
    } else {
      elementType = findCollectionElementType(paramType);
    }
    if(elementType != null) {
      paramElt.setAttribute("ITEM_CLASS_NAME", elementType.getName());
    }
  }
}
 
Example 2
/**
 * Validates the specified {@link CacheOperation}.
 * <p>Throws an {@link IllegalStateException} if the state of the operation is
 * invalid. As there might be multiple sources for default values, this ensure
 * that the operation is in a proper state before being returned.
 * @param ae the annotated element of the cache operation
 * @param operation the {@link CacheOperation} to validate
 */
private void validateCacheOperation(AnnotatedElement ae, CacheOperation operation) {
	if (StringUtils.hasText(operation.getKey()) && StringUtils.hasText(operation.getKeyGenerator())) {
		throw new IllegalStateException("Invalid cache annotation configuration on '" +
				ae.toString() + "'. Both 'key' and 'keyGenerator' attributes have been set. " +
				"These attributes are mutually exclusive: either set the SpEL expression used to" +
				"compute the key at runtime or set the name of the KeyGenerator bean to use.");
	}
	if (StringUtils.hasText(operation.getCacheManager()) && StringUtils.hasText(operation.getCacheResolver())) {
		throw new IllegalStateException("Invalid cache annotation configuration on '" +
				ae.toString() + "'. Both 'cacheManager' and 'cacheResolver' attributes have been set. " +
				"These attributes are mutually exclusive: the cache manager is used to configure a" +
				"default cache resolver if none is set. If a cache resolver is set, the cache manager" +
				"won't be used.");
	}
}
 
Example 3
Source Project: mongobee   Source File: ChangeService.java    License: Apache License 2.0 6 votes vote down vote up
private boolean matchesActiveSpringProfile(AnnotatedElement element) {
  if (!ClassUtils.isPresent("org.springframework.context.annotation.Profile", null)) {
    return true;
  }
  if (!element.isAnnotationPresent(Profile.class)) {
    return true; // no-profiled changeset always matches
  }
  List<String> profiles = asList(element.getAnnotation(Profile.class).value());
  for (String profile : profiles) {
    if (profile != null && profile.length() > 0 && profile.charAt(0) == '!') {
      if (!activeProfiles.contains(profile.substring(1))) {
        return true;
      }
    } else if (activeProfiles.contains(profile)) {
      return true;
    }
  }
  return false;
}
 
Example 4
/**
 * @return The list of annotation->owningElement pairs from the given 2-dimensional array that match the given
 * desiredAnnotationClass - note that if desiredAnnotationClassIsMultiValueConstraint is true then each matching
 * annotation will be exploded via {@link #explodeAnnotationToManyConstraintsIfMultiValue(java.lang.annotation.Annotation,
 * boolean)} before being added to the return list.
 */
private static List<Pair<Annotation, AnnotatedElement>> extractAnnotationsFrom2dArray(
    Annotation[][] annotations2dArray, Class<? extends Annotation> desiredAnnotationClass,
    boolean desiredAnnotationClassIsMultiValueConstraint, AnnotatedElement owningElement) {
    List<Pair<Annotation, AnnotatedElement>> returnList = new ArrayList<>();
    for (Annotation[] innerArray : annotations2dArray) {
        for (Annotation annotation : innerArray) {
            if (annotation.annotationType().equals(desiredAnnotationClass)) {
                List<Annotation> annotationsToRegister = explodeAnnotationToManyConstraintsIfMultiValue(
                    annotation, desiredAnnotationClassIsMultiValueConstraint
                );
                for (Annotation annotationToRegister : annotationsToRegister) {
                    returnList.add(Pair.of(annotationToRegister, owningElement));
                }
            }
        }
    }

    return returnList;
}
 
Example 5
/**
 * Validates the specified {@link CacheOperation}.
 * <p>Throws an {@link IllegalStateException} if the state of the operation is
 * invalid. As there might be multiple sources for default values, this ensure
 * that the operation is in a proper state before being returned.
 * @param ae the annotated element of the cache operation
 * @param operation the {@link CacheOperation} to validate
 */
private void validateCacheOperation(AnnotatedElement ae, CacheOperation operation) {
	if (StringUtils.hasText(operation.getKey()) && StringUtils.hasText(operation.getKeyGenerator())) {
		throw new IllegalStateException("Invalid cache annotation configuration on '" +
				ae.toString() + "'. Both 'key' and 'keyGenerator' attributes have been set. " +
				"These attributes are mutually exclusive: either set the SpEL expression used to" +
				"compute the key at runtime or set the name of the KeyGenerator bean to use.");
	}
	if (StringUtils.hasText(operation.getCacheManager()) && StringUtils.hasText(operation.getCacheResolver())) {
		throw new IllegalStateException("Invalid cache annotation configuration on '" +
				ae.toString() + "'. Both 'cacheManager' and 'cacheResolver' attributes have been set. " +
				"These attributes are mutually exclusive: the cache manager is used to configure a" +
				"default cache resolver if none is set. If a cache resolver is set, the cache manager" +
				"won't be used.");
	}
}
 
Example 6
Source Project: smallrye-metrics   Source File: CDIBeanInfo.java    License: Apache License 2.0 6 votes vote down vote up
@Override
public <T extends Annotation> AnnotationInfo getAnnotation(Class<T> metric) {
    T annotation = input.getAnnotation(metric);
    if (annotation != null) {
        return new CDIAnnotationInfoAdapter().convert(annotation);
    } else {
        // the metric annotation can also be applied via a stereotype, so look for stereotype annotations
        for (Annotation stereotypeCandidate : ((AnnotatedElement) input).getAnnotations()) {
            if (stereotypeCandidate.annotationType().isAnnotationPresent(Stereotype.class) &&
                    stereotypeCandidate.annotationType().isAnnotationPresent(metric)) {
                return new CDIAnnotationInfoAdapter().convert(stereotypeCandidate.annotationType().getAnnotation(metric));
            }
        }
        return null;
    }
}
 
Example 7
Source Project: mPaaS   Source File: ClassMemberScaner.java    License: Apache License 2.0 6 votes vote down vote up
/** 递归扫描字段 */
private boolean scanField(Class<?> clazz, List<String> visited,
                          Consumer<AnnotatedElement> consumer) {
    // 扫描当前类
    for (Field field : clazz.getDeclaredFields()) {
        String name = field.getName();
        if (!visited.contains(name)) {
            if (handle(field, consumer)) {
                return true;
            }
            visited.add(name);
        }
    }
    // 扫描父类
    Class<?> superClazz = clazz.getSuperclass();
    if (superClazz != null && superClazz != Object.class) {
        if (scanField(superClazz, visited, consumer)) {
            return true;
        }
    }
    return false;
}
 
Example 8
@Override
public boolean canConvert ( final Class<?> from, final Class<?> to, final AnnotatedElement annotatedElement )
{
    if ( !to.equals ( String.class ) )
    {
        return false;
    }

    if ( from.isAnnotationPresent ( JSON.class ) )
    {
        return true;
    }

    if ( annotatedElement != null && annotatedElement.isAnnotationPresent ( JSON.class ) )
    {
        return true;
    }

    return false;
}
 
Example 9
Source Project: spring4-understanding   Source File: AnnotationUtils.java    License: Apache License 2.0 6 votes vote down vote up
/**
 * Handle the supplied annotation introspection exception.
 * <p>If the supplied exception is an {@link AnnotationConfigurationException},
 * it will simply be thrown, allowing it to propagate to the caller, and
 * nothing will be logged.
 * <p>Otherwise, this method logs an introspection failure (in particular
 * {@code TypeNotPresentExceptions}) before moving on, assuming nested
 * Class values were not resolvable within annotation attributes and
 * thereby effectively pretending there were no annotations on the specified
 * element.
 * @param element the element that we tried to introspect annotations on
 * @param ex the exception that we encountered
 * @see #rethrowAnnotationConfigurationException
 */
static void handleIntrospectionFailure(AnnotatedElement element, Exception ex) {
	rethrowAnnotationConfigurationException(ex);

	Log loggerToUse = logger;
	if (loggerToUse == null) {
		loggerToUse = LogFactory.getLog(AnnotationUtils.class);
		logger = loggerToUse;
	}
	if (element instanceof Class && Annotation.class.isAssignableFrom((Class<?>) element)) {
		// Meta-annotation lookup on an annotation type
		if (loggerToUse.isDebugEnabled()) {
			loggerToUse.debug("Failed to introspect meta-annotations on [" + element + "]: " + ex);
		}
	}
	else {
		// Direct annotation lookup on regular Class, Method, Field
		if (loggerToUse.isInfoEnabled()) {
			loggerToUse.info("Failed to introspect annotations on [" + element + "]: " + ex);
		}
	}
}
 
Example 10
Source Project: spring4-understanding   Source File: AnnotationUtils.java    License: Apache License 2.0 6 votes vote down vote up
@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);
		}
	}
}
 
Example 11
Source Project: alfresco-mvc   Source File: RunAsAdvice.java    License: Apache License 2.0 6 votes vote down vote up
private AlfrescoRunAs parseRunAsAnnotation(AnnotatedElement ae) {
	AlfrescoRunAs ann = ae.getAnnotation(AlfrescoRunAs.class);
	if (ann == null) {
		for (Annotation metaAnn : ae.getAnnotations()) {
			ann = metaAnn.annotationType().getAnnotation(AlfrescoRunAs.class);
			if (ann != null) {
				break;
			}
		}
	}
	if (ann != null) {
		return parseAnnotation(ann);
	} else {
		return null;
	}
}
 
Example 12
public EjbRefElement(Member member, AnnotatedElement ae, PropertyDescriptor pd) {
	super(member, pd);
	EJB resource = ae.getAnnotation(EJB.class);
	String resourceBeanName = resource.beanName();
	String resourceName = resource.name();
	this.isDefaultName = !StringUtils.hasLength(resourceName);
	if (this.isDefaultName) {
		resourceName = this.member.getName();
		if (this.member instanceof Method && resourceName.startsWith("set") && resourceName.length() > 3) {
			resourceName = Introspector.decapitalize(resourceName.substring(3));
		}
	}
	Class<?> resourceType = resource.beanInterface();
	if (resourceType != null && Object.class != resourceType) {
		checkResourceType(resourceType);
	}
	else {
		// No resource type specified... check field/method.
		resourceType = getResourceType();
	}
	this.beanName = resourceBeanName;
	this.name = resourceName;
	this.lookupType = resourceType;
	this.mappedName = resource.mappedName();
}
 
Example 13
/**
 * Utility method for calling an arbitrary method in an annotation.
 *
 * @param element the element that was annotated, either a class or method
 * @param annotation the class of the annotation we're interested in
 * @param methodName the name of the method in the annotation we wish
 * to call.
 * @param defaultValue the value to return if the annotation doesn't
 * exist, or we couldn't invoke the method for some reason.
 * @return the result of calling the annotation method, or the default.
 */
protected static Object getAnnotationValue(
        AnnotatedElement element, Class<? extends Annotation> annotation,
        String methodName, Object defaultValue) {
    Object ret = defaultValue;
    try {
        Method m = annotation.getMethod(methodName);
        Annotation a = element.getAnnotation(annotation);
        ret = m.invoke(a);
    } catch (NoSuchMethodException e) {
        assert false;
    } catch (IllegalAccessException e) {
        assert false;
    } catch (InvocationTargetException e) {
        assert false;
    } catch (NullPointerException e) {
        assert false;
    }
    return ret;
}
 
Example 14
Source Project: spring-analysis-note   Source File: AnnotationUtils.java    License: MIT License 6 votes vote down vote up
/**
 * Handle the supplied annotation introspection exception.
 * <p>If the supplied exception is an {@link AnnotationConfigurationException},
 * it will simply be thrown, allowing it to propagate to the caller, and
 * nothing will be logged.
 * <p>Otherwise, this method logs an introspection failure (in particular
 * {@code TypeNotPresentExceptions}) before moving on, assuming nested
 * Class values were not resolvable within annotation attributes and
 * thereby effectively pretending there were no annotations on the specified
 * element.
 * @param element the element that we tried to introspect annotations on
 * @param ex the exception that we encountered
 * @see #rethrowAnnotationConfigurationException
 */
private static void handleIntrospectionFailure(@Nullable AnnotatedElement element, Throwable ex) {
	rethrowAnnotationConfigurationException(ex);
	IntrospectionFailureLogger logger = IntrospectionFailureLogger.INFO;
	boolean meta = false;
	if (element instanceof Class && Annotation.class.isAssignableFrom((Class<?>) element)) {
		// Meta-annotation or (default) value lookup on an annotation type
		logger = IntrospectionFailureLogger.DEBUG;
		meta = true;
	}
	if (logger.isEnabled()) {
		String message = meta ?
				"Failed to meta-introspect annotation " :
				"Failed to introspect annotations on ";
		logger.log(message + element + ": " + ex);
	}
}
 
Example 15
Source Project: java-client   Source File: DefaultElementByBuilder.java    License: Apache License 2.0 6 votes vote down vote up
@Override
protected By buildMobileNativeBy() {
    AnnotatedElement annotatedElement = annotatedElementContainer.getAnnotated();
    HowToUseLocators howToUseLocators = annotatedElement.getAnnotation(HowToUseLocators.class);

    Optional<HowToUseLocators> howToUseLocatorsOptional = ofNullable(howToUseLocators);

    if (isAndroid()) {
        return buildMobileBy(howToUseLocatorsOptional.map(HowToUseLocators::androidAutomation).orElse(null),
                getBys(AndroidFindBy.class, AndroidFindBys.class, AndroidFindAll.class));
    }

    if (isIOSXcuit() || isIOS()) {
        return buildMobileBy(howToUseLocatorsOptional.map(HowToUseLocators::iOSXCUITAutomation).orElse(null),
                getBys(iOSXCUITFindBy.class, iOSXCUITFindBys.class, iOSXCUITFindAll.class));
    }

    if (isWindows()) {
        return buildMobileBy(howToUseLocatorsOptional.map(HowToUseLocators::windowsAutomation).orElse(null),
                getBys(WindowsFindBy.class, WindowsFindBys.class, WindowsFindAll.class));
    }

    return null;
}
 
Example 16
private static String getSource(AnnotatedElement element) {
    Source source = ReflectionUtil.getAnnotation(element, Source.class);
    if (source != null) {
        return source.value();
    }
    return null;
}
 
Example 17
Source Project: cxf   Source File: AnnotationReader.java    License: Apache License 2.0 5 votes vote down vote up
public boolean isExtensibleElements(AnnotatedElement element, boolean defaultValue) {
    Boolean extensibleElements = (Boolean) getAnnotationValue("extensibleElements",
            element,
            Boolean.TRUE,
            XmlType.class);

    if (extensibleElements == null) {
        return defaultValue;
    }
    return extensibleElements;
}
 
Example 18
/**
 * Determine if the supplied {@link AnnotatedElement} is annotated with a
 * <em>composed annotation</em> that is meta-annotated with an annotation
 * of the specified {@code annotationName}.
 * <p>This method follows <em>get semantics</em> as described in the
 * {@linkplain AnnotatedElementUtils class-level javadoc}.
 * @param element the annotated element
 * @param annotationName the fully qualified class name of the
 * meta-annotation type to find
 * @return {@code true} if a matching meta-annotation is present
 * @see #getMetaAnnotationTypes
 */
public static boolean hasMetaAnnotationTypes(AnnotatedElement element, final String annotationName) {
	Assert.notNull(element, "AnnotatedElement must not be null");
	Assert.hasLength(annotationName, "annotationName must not be null or empty");

	return Boolean.TRUE.equals(searchWithGetSemantics(element, null, annotationName, new SimpleAnnotationProcessor<Boolean>() {
		@Override
		public Boolean process(AnnotatedElement annotatedElement, Annotation annotation, int metaDepth) {
			boolean found = annotation.annotationType().getName().equals(annotationName);
			return (found && metaDepth > 0 ? Boolean.TRUE : CONTINUE);
		}
	}));
}
 
Example 19
Source Project: strimzi-kafka-operator   Source File: ValidationVisitor.java    License: Apache License 2.0 5 votes vote down vote up
<M extends AnnotatedElement & Member> boolean isPresent(M member,
                  Object propertyValue) {
    JsonInclude annotation = member.getAnnotation(JsonInclude.class);
    if (annotation != null) {
        if (propertyValue == null) {
            return false;
        }
        switch (annotation.value()) {
            case NON_ABSENT:
                // Technically we should handle Optional and AtomicReference
                // but we're not using these types in the api module, so just fall through
            case NON_EMPTY:
                if (propertyValue instanceof Collection) {
                    return !((Collection) propertyValue).isEmpty();
                } else if (propertyValue instanceof Map) {
                    return !((Map) propertyValue).isEmpty();
                } else if (propertyValue instanceof String) {
                    return !((String) propertyValue).isEmpty();
                } else if (propertyValue instanceof Object[]) {
                    return ((Object[]) propertyValue).length != 0;
                } else if (propertyValue.getClass().isArray()) {
                    // primitive arrays
                    try {
                        return ((int) propertyValue.getClass().getField("length").get(propertyValue)) != 0;
                    } catch (ReflectiveOperationException e) {
                        return false;
                    }
                }
        }
    }
    return propertyValue != null;
}
 
Example 20
Source Project: attic-polygene-java   Source File: MetaInfo.java    License: Apache License 2.0 5 votes vote down vote up
public MetaInfo withAnnotations( AnnotatedElement annotatedElement )
{
    for( Annotation annotation : annotatedElement.getAnnotations() )
    {
        if( !ignored.contains( annotation.annotationType() )
            && get( annotation.annotationType() ) == null )
        {
            set( annotation );
        }
    }
    return this;
}
 
Example 21
Source Project: netbeans   Source File: FSWrapperTest.java    License: Apache License 2.0 5 votes vote down vote up
private static void checkAnnotations(AnnotatedElement el, AnnotatableWrapper aw) throws Exception {
    for (Annotation ann : el.getAnnotations()) {
        Annotation wrapper = aw.getAnnotation(ann.annotationType());

        assertNotNull(ann.annotationType().getName(), wrapper);

        checkAnnotation(ann, wrapper);
    }
}
 
Example 22
Source Project: stategen   Source File: FieldWrap.java    License: GNU Affero General Public License v3.0 5 votes vote down vote up
@Override
public AnnotatedElement[] getMembers() {
    if (members == null) {
        members = super.getMembers();
        if (field == null) {
            return members;
        }

        members = new AnnotatedElement[] { members[0], field };
    }
    return members;
}
 
Example 23
Source Project: openjdk-jdk9   Source File: TypeAnnotation.java    License: GNU General Public License v2.0 5 votes vote down vote up
public TypeAnnotation(TypeAnnotationTargetInfo targetInfo,
                      LocationInfo loc,
                      Annotation annotation,
                      AnnotatedElement baseDeclaration) {
    this.targetInfo = targetInfo;
    this.loc = loc;
    this.annotation = annotation;
    this.baseDeclaration = baseDeclaration;
}
 
Example 24
private <E extends AnnotatedElement & Member> String getName(Class<?> clazz, E elem, Object fieldValue) {
    com.codahale.metrics.annotation.Metric annotation = elem.getAnnotation(com.codahale.metrics.annotation.Metric.class);
    if(annotation == null) {
        throw new IllegalArgumentException(elem + " mut be an annotated with " + com.codahale.metrics.annotation.Metric.class);
    }
    return MetricNameUtil.chooseName(annotation.name(), annotation.absolute(), clazz, elem);
}
 
Example 25
Source Project: metanome-algorithms   Source File: ReflectionUtils.java    License: Apache License 2.0 5 votes vote down vote up
public static <T extends Annotation> Optional<T> getAnnotationIfPresent(
	AnnotatedElement annotatedElement, Class<T> annotationClass) {
	if (annotatedElement.isAnnotationPresent(annotationClass)) {
		T annotation = annotatedElement.getAnnotation(annotationClass);
		return Optional.of(annotation);
	}
	return Optional.empty();
}
 
Example 26
/**
 * Delegates to {@link #createRequestMappingInfo(RequestMapping, RequestCondition)},
 * supplying the appropriate custom {@link RequestCondition} depending on whether
 * the supplied {@code annotatedElement} is a class or method.
 * @see #getCustomTypeCondition(Class)
 * @see #getCustomMethodCondition(Method)
 */
@Nullable
private RequestMappingInfo createRequestMappingInfo(AnnotatedElement element) {
	RequestMapping requestMapping = AnnotatedElementUtils.findMergedAnnotation(element, RequestMapping.class);
	RequestCondition<?> condition = (element instanceof Class ?
			getCustomTypeCondition((Class<?>) element) : getCustomMethodCondition((Method) element));
	return (requestMapping != null ? createRequestMappingInfo(requestMapping, condition) : null);
}
 
Example 27
Source Project: backstopper   Source File: ReflectionMagicWorksTest.java    License: Apache License 2.0 5 votes vote down vote up
/**
 * Makes sure that the Reflections helper stuff is working properly and capturing all annotation possibilities (class type, constructor, constructor param, method, method param, and field).
 */
@Test
public void verifyThatTheReflectionsConfigurationIsCapturingAllAnnotationPossibilities() {
    List<Pair<Annotation, AnnotatedElement>> annotationOptionsClassAnnotations = getSubAnnotationListForElementsOfOwnerClass(TROLLER.allConstraintAnnotationsMasterList,
            DifferentValidationAnnotationOptions.class);
    assertThat(annotationOptionsClassAnnotations.size(), is(10));
    assertThat(getSubAnnotationListForAnnotationsOfClassType(annotationOptionsClassAnnotations, SomeClassLevelJsr303Annotation.class).size(), is(2));
    assertThat(getSubAnnotationListForAnnotationsOfClassType(annotationOptionsClassAnnotations, OtherClassLevelJsr303Annotation.class).size(), is(1));
    assertThat(getSubAnnotationListForAnnotationsOfClassType(annotationOptionsClassAnnotations, AssertTrue.class).size(), is(1));
    assertThat(getSubAnnotationListForAnnotationsOfClassType(annotationOptionsClassAnnotations, AssertFalse.class).size(), is(1));
    assertThat(getSubAnnotationListForAnnotationsOfClassType(annotationOptionsClassAnnotations, NotNull.class).size(), is(2));
    assertThat(getSubAnnotationListForAnnotationsOfClassType(annotationOptionsClassAnnotations, Min.class).size(), is(2));
    assertThat(getSubAnnotationListForAnnotationsOfClassType(annotationOptionsClassAnnotations, Max.class).size(), is(1));
}
 
Example 28
Source Project: bobcat   Source File: InjectorUtilsTest.java    License: Apache License 2.0 5 votes vote down vote up
@Test
void shouldRetrieveInjectorWhenPresent() {
  Optional<AnnotatedElement> optional = Optional.of(annotatedElement);
  when(context.getElement()).thenReturn(optional);
  when(store.getOrComputeIfAbsent(any(), any(), eq(Injector.class))).thenReturn(injector);
  when(context.getStore(namespace)).thenReturn(store);

  assertEquals(injector, InjectorUtils.retrieveInjectorFromStore(context, namespace));
}
 
Example 29
Source Project: spring-fabric-gateway   Source File: AnnotationUtils.java    License: MIT License 5 votes vote down vote up
public static <A extends Annotation> AnnotatedElement getMethod(Class<?> clazz, Class<A> annotationType) {
	if (clazz == null || annotationType == null) {
		return null;
	}
	Method[] methods = clazz.getMethods();
	for (Method method : methods) {
		if (method.getAnnotation(annotationType) != null) {
			return method;
		}
	}
	return null;
}
 
Example 30
Source Project: vraptor4   Source File: WithAnnotationAcceptorTest.java    License: Apache License 2.0 5 votes vote down vote up
@Before
public void setup() {
	MockitoAnnotations.initMocks(this);
	annotation = new Mirror()
	.on((AnnotatedElement) InterceptorWithCustomizedAccepts.class)
	.reflect().annotation(AcceptsWithAnnotations.class);
}