@Override public int getModifiers() { return annotatedMember.getJavaMember().getModifiers(); }
/** * Registers metrics for all field and method producers defined by the application. * * @param adv After deployment validation event. * @param bm Bean manager. */ private void registerProducers(@Observes AfterDeploymentValidation adv, BeanManager bm) { LOGGER.log(Level.FINE, () -> "### registerProducers"); MetricRegistry registry = getMetricRegistry(); producers.entrySet().forEach(entry -> { Metric metric = entry.getValue().getAnnotation(Metric.class); if (metric != null) { String metricName = getMetricName(new AnnotatedElementWrapper(entry.getValue()), entry.getValue().getDeclaringType().getJavaClass(), MetricUtil.MatchingType.METHOD, metric.name(), metric.absolute()); registry.register(metricName, getReference(bm, entry.getValue().getBaseType(), entry.getKey())); } }); producers.clear(); }
@Override public Object resolveResource(InjectionPoint injectionPoint) { final Member member = injectionPoint.getMember(); AnnotatedMember<?> annotatedMember; if (injectionPoint.getAnnotated() instanceof AnnotatedField) { annotatedMember = (AnnotatedField<?>) injectionPoint.getAnnotated(); } else { annotatedMember = ((AnnotatedParameter<?>) injectionPoint.getAnnotated()).getDeclaringCallable(); } if (!annotatedMember.isAnnotationPresent(Resource.class)) { throw WeldLogger.ROOT_LOGGER.annotationNotFound(Resource.class, member); } if (member instanceof Method && ((Method) member).getParameterTypes().length != 1) { throw WeldLogger.ROOT_LOGGER.injectionPointNotAJavabean((Method) member); } String name = getResourceName(injectionPoint); for (ResourceInjectionResolver resolver : resourceResolvers) { Object result = resolver.resolve(name); if (result != null) { return result; } } try { return context.lookup(name); } catch (NamingException e) { throw WeldLogger.ROOT_LOGGER.couldNotFindResource(name, injectionPoint.getMember().toString(), e); } }
if (instance == null && !isDependent()) { throw BeanLogger.LOG.nullNotAllowedFromProducer(getProducer(), Formats.formatAsStackTraceElement(getAnnotated().getJavaMember())); InjectionPoint injectionPoint = beanManager.getServices().get(CurrentInjectionPoint.class).peek(); if (injectionPoint != null) { Class<?> injectionPointRawType = Reflections.getRawType(injectionPoint.getType()); if (injectionPointRawType.isPrimitive()) { return cast(Defaults.getJlsDefaultValue(injectionPointRawType)); if (beanManager.isPassivatingScope(getScope())) { throw BeanLogger.LOG.nonSerializableProductError(getProducer(), Formats.formatAsStackTraceElement(getAnnotated().getJavaMember())); InjectionPoint injectionPoint = beanManager.getServices().get(CurrentInjectionPoint.class).peek(); if (injectionPoint != null && injectionPoint.getBean() != null && Beans.isPassivatingScope(injectionPoint.getBean(), beanManager)) { if (!(injectionPoint.getMember() instanceof Field) || !injectionPoint.isTransient()) { throw BeanLogger.LOG.unserializableProductInjectionError(this, Formats.formatAsStackTraceElement(getAnnotated().getJavaMember()), injectionPoint, Formats.formatAsStackTraceElement(injectionPoint.getMember()));
private static void checkMembersBelongToHierarchy(Iterable<? extends AnnotatedMember<?>> members, Set<Class<?>> hierarchy, AnnotatedType<?> type) { for (AnnotatedMember<?> member : members) { if (!hierarchy.contains(member.getJavaMember().getDeclaringClass())) { MetadataLogger.LOG.notInHierarchy(member.getJavaMember().getName(), member.toString(), type.getJavaClass().getName(), type.toString(), Formats.formatAsStackTraceElement(member.getJavaMember())); } } }
@Override public Class<?> getDeclaringClass() { return annotatedMember.getDeclaringType().getJavaClass(); }
private ProcessProducerImpl(BeanManagerImpl beanManager, AnnotatedMember<T> annotatedMember, AbstractProducerBean<T, X, ?> bean) { super(beanManager, ProcessProducer.class, new Type[] { bean.getAnnotated().getDeclaringType().getBaseType(), bean.getAnnotated().getBaseType() }); this.bean = bean; this.annotatedMember = annotatedMember; }
protected void defineDisposalMethod() Set<Annotation> producerQualifiers = webBeansContext.getAnnotationManager().getQualifierAnnotations(producer.getAnnotations()); if (producerQualifiers.size() == 1 && producerQualifiers.iterator().next().annotationType().equals(Default.class)) AnnotatedType declaringType = producer.getDeclaringType(); Type producerBaseType = producerType().getBaseType(); Set<AnnotatedMethod<? super P>> annotatedMethods = webBeansContext.getAnnotatedElementFactory().getFilteredAnnotatedMethods(declaringType); + annotatedMethod.getDeclaringType().getJavaClass());
if (!injectionPoint.isDelegate()) { dependencyPath.add(injectionPoint); validatePseudoScopedInjectionPoint(injectionPoint, beanManager, dependencyPath, validatedBeans); final List<Decorator<?>> decorators = Reflections.<DecorableBean<?>>cast(bean).getDecorators(); if (!decorators.isEmpty()) { for (final Decorator<?> decorator : decorators) { if (!beanManager.isNormalScope(producer.getDeclaringBean().getScope()) && !producer.getAnnotated().isStatic()) { reallyValidatePseudoScopedBean(producer.getDeclaringBean(), beanManager, dependencyPath, validatedBeans);
@Override public <T> Producer<T> createProducer(Bean<T> bean) { if (getDeclaringBean() == null && !getAnnotatedMember().isStatic()) { throw BeanManagerLogger.LOG.nullDeclaringBean(getAnnotatedMember()); } AnnotatedTypeValidator.validateAnnotatedMember(getAnnotatedMember()); try { Producer<T> producer = createProducer(getDeclaringBean(), bean, null); getManager().getServices().get(InjectionTargetService.class).validateProducer(producer); return producer; } catch (Throwable e) { throw new IllegalArgumentException(e); } } }
@Override protected DefinitionException producerWithParameterizedTypeWithTypeVariableBeanTypeMustBeDependent(AnnotatedMember<?> member) { return BeanLogger.LOG.producerFieldWithTypeVariableBeanTypeMustBeDependent(member, Formats.formatAsStackTraceElement(member.getJavaMember())); } }
@Override protected DefinitionException producerWithParameterizedTypeWithTypeVariableBeanTypeMustBeDependent(AnnotatedMember<?> member) { return BeanLogger.LOG.producerMethodWithTypeVariableReturnTypeMustBeDependent(member, Formats.formatAsStackTraceElement(member.getJavaMember())); } }
public <X, A extends EnhancedAnnotatedMember<?, X, ? extends Member>> A loadEnhancedMember(AnnotatedMember<X> member, String bdaId) { if (member instanceof EnhancedAnnotatedMember<?, ?, ?>) { return Reflections.cast(member); } EnhancedAnnotatedType<X> declaringType = transformer.getEnhancedAnnotatedType(member.getDeclaringType(), bdaId); return enhancedMemberCache.getCastValue(new MemberKey<X, AnnotatedMember<X>>(declaringType, member)); }
@Override public String of(AnnotatedMember<?> member) { if (member.isAnnotationPresent(Metric.class)) { Metric metric = member.getAnnotation(Metric.class); String name = metric.name().isEmpty() ? member.getJavaMember().getName() : of(metric.name()); return metric.absolute() | extension.<Boolean>getParameter(UseAbsoluteName).orElse(false) ? name : MetricRegistry.name(member.getJavaMember().getDeclaringClass(), name); } else { return extension.<Boolean>getParameter(UseAbsoluteName).orElse(false) ? member.getJavaMember().getName() : MetricRegistry.name(member.getJavaMember().getDeclaringClass(), member.getJavaMember().getName()); } }
public static void validateAnnotatedMember(AnnotatedMember<?> member) { validateAnnotated(member); checkNotNull(member.getJavaMember(), "getJavaMember()", member); checkNotNull(member.getDeclaringType(), "getDeclaringType()", member); }
/** * Gets the receiver of the product. The two creational contexts need to be separated because the receiver only serves the product * creation (it is not a dependent instance of the created instance). * * @param productCreationalContext the creational context of the produced instance * @param receiverCreationalContext the creational context of the receiver * @return The receiver */ protected Object getReceiver(CreationalContext<?> productCreationalContext, CreationalContext<?> receiverCreationalContext) { // This is a bit dangerous, as it means that producer methods can end up // executing on partially constructed instances. Also, it's not required // by the spec... if (getAnnotated().isStatic()) { return null; } else { if (productCreationalContext instanceof WeldCreationalContext<?>) { WeldCreationalContext<?> creationalContextImpl = (WeldCreationalContext<?>) productCreationalContext; final Object incompleteInstance = creationalContextImpl.getIncompleteInstance(getDeclaringBean()); if (incompleteInstance != null) { BeanLogger.LOG.circularCall(getAnnotated(), getDeclaringBean()); return incompleteInstance; } } return getBeanManager().getReference(getDeclaringBean(), null, receiverCreationalContext, true); } }
@Override public boolean isAnnotationPresent(Class<? extends Annotation> annotationClass) { return annotatedMember.isAnnotationPresent(annotationClass); }
protected void checkDeclaringBean() { if (getDeclaringBean() == null && !getAnnotated().isStatic()) { throw BeanLogger.LOG.declaringBeanMissing(getAnnotated()); } }
protected Type getResourceInjectionPointType(AnnotatedMember<?> member) { if (member instanceof AnnotatedField<?>) { return member.getBaseType(); } if (member instanceof AnnotatedMethod<?>) { AnnotatedMethod<?> method = (AnnotatedMethod<?>) member; if (method.getParameters().size() != 1) { throw UtilLogger.LOG.resourceSetterInjectionNotAJavabean(method); } return method.getParameters().get(0).getBaseType(); } throw new IllegalArgumentException("Unknown member " + member); }
AnnotatedMember<X> annotatedMember = processProducer.getAnnotatedMember(); List<Annotation> qualifiers = new ArrayList<Annotation>(); for (Annotation annotation : annotatedMember.getAnnotations()) Typed typed = annotatedMember.getAnnotation(Typed.class); else if (annotatedMember.getBaseType() instanceof Class) foundTypes.addAll(extractTypes((Class)annotatedMember.getBaseType()));