private String getFieldName(InjectionPoint ip) { Annotated annotated = ip.getAnnotated(); if (annotated instanceof AnnotatedField) { AnnotatedField f = (AnnotatedField) annotated; return f.getJavaMember().getName(); } if (annotated instanceof AnnotatedParameter) { AnnotatedParameter p = (AnnotatedParameter) annotated; Member member = ip.getMember(); if (member instanceof Method) { return member.getName() + "_" + p.getPosition(); } if (member instanceof Constructor) { return "new_" + p.getPosition(); } } return ip.getMember().getName(); }
/** * Records metric producer fields defined by the application. Ignores producers * with non-default qualifiers and library producers. * * @param ppf Producer field. */ private void recordProducerFields(@Observes ProcessProducerField<? extends org.eclipse.microprofile.metrics.Metric, ?> ppf) { LOGGER.log(Level.FINE, () -> "### recordProducerFields " + ppf.getBean().getBeanClass()); if (!MetricProducer.class.equals(ppf.getBean().getBeanClass())) { Metric metric = ppf.getAnnotatedProducerField().getAnnotation(Metric.class); if (metric != null) { Optional<? extends Annotation> hasQualifier = ppf.getAnnotatedProducerField() .getAnnotations() .stream() .filter(annotation -> annotation.annotationType().isAnnotationPresent(Qualifier.class)) .findFirst(); // Ignore producers with non-default qualifiers if (!hasQualifier.isPresent() || hasQualifier.get() instanceof Default) { producers.put(ppf.getBean(), ppf.getAnnotatedProducerField()); } } } }
if (!t1.getJavaClass().equals(t2.getJavaClass())) { return false; if (!compareAnnotated(t1, t2)) { return false; if (t1.getFields().size() != t2.getFields().size()) { return false; for (AnnotatedField<?> f : t2.getFields()) { fields.put(f.getJavaMember(), f); for (AnnotatedField<?> f : t1.getFields()) { if (fields.containsKey(f.getJavaMember())) { if (!compareAnnotatedField(f, fields.get(f.getJavaMember()))) { return false; for (AnnotatedMethod<?> f : t2.getMethods()) { methods.put(f.getJavaMember(), f); for (AnnotatedMethod<?> f : t1.getMethods()) { if (methods.containsKey(f.getJavaMember())) { if (!compareAnnotatedCallable(f, methods.get(f.getJavaMember()))) { return false; for (AnnotatedConstructor<?> f : t2.getConstructors()) { constructors.put(f.getJavaMember(), f);
this.javaClass = type.getJavaClass(); for (AnnotatedField<? super X> field : type.getFields()) { if (fields.get(field.getJavaMember()) == null) { fields.put(field.getJavaMember(), new AnnotationBuilder()); mergeAnnotationsOnElement(field, overwrite, fields.get(field.getJavaMember())); for (AnnotatedMethod<? super X> method : type.getMethods()) { if (methods.get(method.getJavaMember()) == null) { methods.put(method.getJavaMember(), new AnnotationBuilder()); if (methodParameters.get(method.getJavaMember()).get(p.getPosition()) == null) { methodParameters.get(method.getJavaMember()).put(p.getPosition(), new AnnotationBuilder()); mergeAnnotationsOnElement(p, overwrite, methodParameters.get(method.getJavaMember()).get(p.getPosition())); for (AnnotatedConstructor<? super X> constructor : type.getConstructors()) { if (constructors.get(constructor.getJavaMember()) == null) { constructors.put(constructor.getJavaMember(), new AnnotationBuilder()); mergeAnnotationsOnElement(constructor, overwrite, constructors.get(constructor.getJavaMember())); for (AnnotatedParameter<? super X> p : constructor.getParameters()) { if (constructorParameters.get(constructor.getJavaMember()) == null) {
public static String formatAnnotatedField(AnnotatedField<?> field) { return Formats.formatSimpleClassName(field) + " " + Formats.addSpaceIfNeeded(Formats.formatAnnotations(field.getAnnotations())) + Formats.addSpaceIfNeeded(Formats.formatModifiers(field.getJavaMember().getModifiers())) + field.getDeclaringType().getJavaClass().getName() + "." + field.getJavaMember().getName(); }
assertEquals(annotatedType.getBaseType(), QueueMessageDrivenBean.class); assertEquals(annotatedType.getMethods().size(), 2); for (AnnotatedMethod<? super QueueMessageDrivenBean> method : annotatedType.getMethods()) { if ("initialize".equals(method.getJavaMember().getName())) { assertTrue(method.isAnnotationPresent(Inject.class)); assertEquals(method.getParameters().size(), 1); assertEquals(method.getDeclaringType().getJavaClass(), QueueMessageDrivenBean.class); } else if ("onMessage".equals(method.getJavaMember().getName())) { assertEquals(annotatedType.getFields().size(), 2); for (AnnotatedField<? super QueueMessageDrivenBean> field : annotatedType.getFields()) { if ("sheep".equals(field.getJavaMember().getName())) { assertTrue(field.isAnnotationPresent(Inject.class)); assertEquals(field.getDeclaringType().getJavaClass(), QueueMessageDrivenBean.class); } else if ("initializerCalled".equals(field.getJavaMember().getName())) { assertEquals(field.getDeclaringType().getJavaClass(), QueueMessageDrivenBean.class); } else { fail();
for (AnnotatedConstructor<T> c : event.getAnnotatedType().getConstructors()) if (c.isAnnotationPresent(Current.class)) for (AnnotatedParameter<?> p : c.getParameters()) if (p.getTypeClosure().contains(Resource.class)) builderHolder.getBuilder().overrideConstructorParameterType(c.getJavaMember(), p.getPosition(), Resource.class); modifiedType = true; for (AnnotatedField<?> f : event.getAnnotatedType().getFields()) if (f.isAnnotationPresent(Current.class)) builderHolder.getBuilder().overrideFieldType(f.getJavaMember(), Resource.class); modifiedType = true; typeOverrides.put(replacement.getJavaClass(), replacement); event.setAnnotatedType(replacement);
private void validateManagedBean(AnnotatedType<Farm> type) { assert type.getBaseType().equals(Farm.class); assert rawTypeSetMatches(type.getTypeClosure(), Farm.class, Object.class); assert type.getFields().size() == 1; assert type.getFields().iterator().next().isAnnotationPresent(Produces.class); assert type.getMethods().size() == 1; assert type.getMethods().iterator().next().isAnnotationPresent(Produces.class); }
private static <T> boolean isApplicable(AnnotatedType<T> at) { if (isApplicable(at.getJavaClass())) { return true; } Set<AnnotatedField<? super T>> fields = at.getFields(); for (AnnotatedField<? super T> field : fields) { if (field.isAnnotationPresent(Configurable.class)) { return true; } } return false; }
private boolean annotatedTypeHasAnnotations(AnnotatedType annotatedType, Class<? extends Annotation>[] withAnnotations) if (hasAnnotation(annotatedType.getAnnotations(), withAnnotations)) Set<AnnotatedField> fields = annotatedType.getFields(); for (AnnotatedField annotatedField : fields) if (hasAnnotation(annotatedField.getAnnotations(), withAnnotations)) Set<AnnotatedMethod> annotatedMethods = annotatedType.getMethods(); for (AnnotatedMethod annotatedMethod : annotatedMethods) if (hasAnnotation(annotatedMethod.getAnnotations(), withAnnotations)) for (AnnotatedParameter annotatedParameter : (List<AnnotatedParameter>) annotatedMethod.getParameters()) if (hasAnnotation(annotatedParameter.getAnnotations(), withAnnotations)) for (AnnotatedConstructor<?> annotatedConstructor : annotatedConstructors) if (hasAnnotation(annotatedConstructor.getAnnotations(), withAnnotations)) for (AnnotatedParameter annotatedParameter : annotatedConstructor.getParameters()) if (hasAnnotation(annotatedParameter.getAnnotations(), withAnnotations))
@Override public <X> FieldProducerFactory<X> getProducerFactory(AnnotatedField<? super X> field, Bean<X> declaringBean) { BeanManagerImpl manager = BeanManagerLookupService.lookupBeanManager(field.getDeclaringType().getJavaClass(), this); return new FieldProducerFactory<X>(field, declaringBean, manager); }
/** * Certain beans like CDI Interceptors and Decorators * are not allowed to define producer methods. */ protected void validateNoProducerOrObserverMethod(AnnotatedType<T> annotatedType) { Set<AnnotatedMethod<? super T>> annotatedMethods = annotatedType.getMethods(); for (AnnotatedMethod<?> annotatedMethod : annotatedMethods) { if (annotatedMethod.isAnnotationPresent(Produces.class)) { throw new WebBeansConfigurationException("This class must not have a @Produces method" + annotatedMethod.getJavaMember()); } for (AnnotatedParameter<?> parameter : annotatedMethod.getParameters()) { if (parameter.isAnnotationPresent(Observes.class) || parameter.isAnnotationPresent(ObservesAsync.class)) { throw new WebBeansConfigurationException("This class must not have an @Observes nor @ObservesAsync method " + annotatedMethod.getJavaMember()); } } } Set<AnnotatedField<? super T>> annotatedFields = annotatedType.getFields(); for (AnnotatedField<? super T> annotatedField : annotatedFields) { if (annotatedField.isAnnotationPresent(Produces.class)) { throw new WebBeansConfigurationException("This class must not have a @Produces field" + annotatedField.getJavaMember()); } } }
static String annotatedFieldToString(AnnotatedField<?> field, Class<?> beanClass) { StringBuilder builder = new StringBuilder(); builder.append(Formats.addSpaceIfNeeded(Formats.formatAnnotations(field.getAnnotations()))); builder.append(Formats.formatModifiers(field.getJavaMember().getModifiers())); builder.append(' '); builder.append(Formats.formatType(field.getJavaMember().getType())); builder.append(' '); if (!beanClass.getName().equals(field.getDeclaringType().getJavaClass().getName())) { builder.append(Formats.formatType(field.getDeclaringType().getJavaClass())); builder.append('.'); } builder.append(field.getJavaMember().getName()); return builder.toString(); }
for (Annotation annotation : field.getAnnotations()) { if (isEqualOrAnnotated(requiredAnnotation, annotation)) { return true; for (Annotation annotation : constructor.getAnnotations()) { if (isEqualOrAnnotated(requiredAnnotation, annotation)) { return true; for (AnnotatedParameter<?> parameter : constructor.getParameters()) { for (Annotation annotation : parameter.getAnnotations()) { if (isEqualOrAnnotated(requiredAnnotation, annotation)) { return true; for (Annotation annotation : method.getAnnotations()) { if (isEqualOrAnnotated(requiredAnnotation, annotation)) { return true; for (AnnotatedParameter<?> parameter : method.getParameters()) { for (Annotation annotation : parameter.getAnnotations()) { if (isEqualOrAnnotated(requiredAnnotation, annotation)) { return true;
private void introspectType() if (getBeanType().isAnnotationPresent(javax.interceptor.Interceptor.class) || getBeanType().isAnnotationPresent(javax.decorator.Decorator.class)) { _isInterceptorOrDecorator = true; return; for (AnnotatedField<? super X> field : getBeanType().getFields()) { if (field.isAnnotationPresent(Delegate.class)) { _isInterceptorOrDecorator = true; return; for (AnnotatedMethod<? super X> method : getBeanType().getMethods()) { for (AnnotatedParameter<? super X> param : method.getParameters()) { if (param.isAnnotationPresent(Delegate.class)) { _isInterceptorOrDecorator = true; return;
static boolean hasAnnotation(AnnotatedType<?> type, Class<? extends Annotation> annotation) { if (type.isAnnotationPresent(annotation)) { return true; } for (AnnotatedMethod<?> method : type.getMethods()) { if (method.isAnnotationPresent(annotation)) { return true; } } for (AnnotatedConstructor<?> constructor : type.getConstructors()) { if (constructor.isAnnotationPresent(annotation)) { return true; } } for (AnnotatedField<?> field : type.getFields()) { if (field.isAnnotationPresent(annotation)) { return true; } } return false; }
AnnotatedMethod<? super AnimalShelter> annotatedMethod = methodConfigurator.getAnnotated(); annotatedMethodEqual.set(AnnotatedTypes.compareAnnotatedCallable( event.getAnnotatedType().getMethods().stream().filter(m -> m.getJavaMember().getName().equals("observesRoomInShelter")).findAny().get(), annotatedMethod)); .filterConstructors(ac -> ac.isAnnotationPresent(Inject.class)) .findFirst().get(); AnnotatedConstructor<AnimalShelter> originalAnnotatedConstructor = event.getAnnotatedType().getConstructors().stream() .filter(m -> m.isAnnotationPresent(Inject.class)).findAny().get(); .set(AnnotatedTypes.compareAnnotatedParameters(originalAnnotatedConstructor.getParameters(), configuratorAnnotatedConstructor.getParameters())); return annotatedField.getJavaMember().getName().equals("cat"); }).findFirst().get(); .compareAnnotatedField(event.getAnnotatedType().getFields().stream().filter(af -> af.getJavaMember().getName().equals("cat")).findAny().get(), annotatedField));
for (AnnotatedConstructor<X> constructor: annotatedType.getConstructors()) if (constructor.isAnnotationPresent(Inject.class)) for (AnnotatedField<? super X> field: annotatedType.getFields()) if (owner != null && Modifier.isPublic(field.getJavaMember().getModifiers()) && !field.isStatic()) if (field.isAnnotationPresent(Inject.class)) if (method.isAnnotationPresent(Inject.class) && !Modifier.isStatic(method.getJavaMember().getModifiers()))
public void processBeans(@Observes ProcessBean<?> event, BeanManager beanManager) { probe.getBootstrapStats().increment(EventType.PB); if (eventMonitorContainerLifecycleEvents) { Object info; if (event instanceof ProcessProducerMethod) { info = formatMember(((ProcessProducerMethod<?, ?>) event).getAnnotatedProducerMethod().getJavaMember()); } else if (event instanceof ProcessProducerField) { info = formatMember(((ProcessProducerField<?, ?>) event).getAnnotatedProducerField().getJavaMember()); } else { info = Formats.formatType(event.getBean().getBeanClass(), false); } addContainerLifecycleEvent(event, info, beanManager); } }
void applyQualifier(Annotation qual, AnnotatedTypeBuilder<?> atb) { AnnotatedType<?> at = atb.create(); //do a loop on all field to replace annotation mark by CDI annotations for (AnnotatedField af : at.getFields()) if (af.isAnnotationPresent(InjectWithQualifier.class)) { atb.addToField(af, InjectLiteral.instance); atb.addToField(af, qual); } //loop on constructors to do the same for (AnnotatedConstructor ac : at.getConstructors()) { Annotation[][] pa = ac.getJavaMember().getParameterAnnotations(); //loop on args to detect marked param for (int i = 0; i < pa.length; i++) for (int j = 0; j < pa[i].length; j++) if (pa[i][j].equals(InjectWithQualifierLiteral.instance)) { atb.addToConstructor(ac, InjectLiteral.instance); atb.addToConstructorParameter(ac.getJavaMember(), i, qual); } } //loop on other methods (setters) for (AnnotatedMethod am : at.getMethods()) if (am.isAnnotationPresent(InjectWithQualifierLiteral.class)) { atb.addToMethod(am, InjectLiteral.instance); atb.addToMethod(am, qual); } }