protected void checkProducerField(EnhancedAnnotatedField<T, ? super X> enhancedField) { if (getDeclaringBean() instanceof SessionBean<?> && !enhancedField.isStatic()) { throw BeanLogger.LOG.producerFieldOnSessionBeanMustBeStatic(enhancedField, enhancedField.getDeclaringType()); } if (enhancedField.isAnnotationPresent(Inject.class)) { if (getDeclaringBean() != null) { throw BeanLogger.LOG.injectedFieldCannotBeProducer(enhancedField, getDeclaringBean()); } else { throw BeanLogger.LOG.injectedFieldCannotBeProducer(enhancedField, enhancedField.getDeclaringType()); } } }
protected EEResourceProducerField(BeanAttributes<T> attributes, EnhancedAnnotatedField<T, ? super X> field, AbstractClassBean<X> declaringBean, DisposalMethod<X, ?> disposalMethod, BeanManagerImpl manager, ServiceRegistry services) { super(attributes, field, declaringBean, disposalMethod, manager, services); this.rawType = field.getJavaClass(); }
public ProducerFieldProducer(EnhancedAnnotatedField<T, ? super X> enhancedField, DisposalMethod<?, ?> disposalMethod) { super(enhancedField, disposalMethod); this.accessibleField = AccessController.doPrivileged(new GetAccessibleCopyOfMember<Field>(enhancedField.getJavaMember())); checkProducerField(enhancedField); }
protected InferringFieldInjectionPointAttributes(EnhancedAnnotatedField<T, X> field, Bean<?> bean, Class<?> declaringComponentClass, BeanManagerImpl manager) { super(field, manager.getContextId(), bean, SharedObjectCache.instance(manager).getSharedSet(field.getQualifiers()), declaringComponentClass); this.field = field.slim(); }
ArrayList<EnhancedAnnotatedField<?, ? super T>> declaredFieldsTemp = new ArrayList<EnhancedAnnotatedField<?, ? super T>>(); Class<T> javaClass = annotatedType.getJavaClass(); EnhancedAnnotatedField<?, ? super T> annotatedField = EnhancedAnnotatedFieldImpl.of(field, this, classTransformer); declaredFieldsTemp.add(annotatedField); for (Annotation annotation : annotatedField.getAnnotations()) { declaredAnnotatedFields.put(annotation.annotationType(), annotatedField); if ((superclass != null) && (superclass.getJavaClass() != Object.class)) { fieldsTemp = Sets.union(fieldsTemp, Reflections.<Set<EnhancedAnnotatedField<?, ? super T>>>cast(superclass.getFields())); declaredFieldsTemp.add(weldField); for (Annotation annotation : weldField.getAnnotations()) { annotatedFields.put(annotation.annotationType(), weldField); if (annotatedField.getDeclaringType().getJavaClass().equals(javaClass)) { if (weldMethod.getEnhancedParameters(annotationType).size() > 0) { declaredMethodsByAnnotatedParameters.put(annotationType, weldMethod); if (superclass != null) { EnhancedAnnotatedType<?> current = superclass; while (current.getJavaClass() != Object.class) { methodsTemp.removeAll(getOverriddenMethods(this, methodsTemp, true));
public List<Set<FieldInjectionPoint<?, ?>>> getFieldInjectionPoints(Bean<?> declaringBean, EnhancedAnnotatedType<?> type, BeanManagerImpl manager) { List<Set<FieldInjectionPoint<?, ?>>> injectableFieldsList = new ArrayList<Set<FieldInjectionPoint<?, ?>>>(); if (type.slim() instanceof UnbackedAnnotatedType<?>) { // external AnnotatedTypes require special treatment Collection<EnhancedAnnotatedField<?, ?>> allFields = type.getEnhancedFields(Inject.class); for (Class<?> clazz = type.getJavaClass(); clazz != null && clazz != Object.class; clazz = clazz.getSuperclass()) { ImmutableSet.Builder<FieldInjectionPoint<?, ?>> fields = ImmutableSet.builder(); for (EnhancedAnnotatedField<?, ?> field : allFields) { if (!field.isStatic() && field.getJavaMember().getDeclaringClass().equals(clazz)) { addFieldInjectionPoint(field, fields, declaringBean, type.getJavaClass(), manager); } } injectableFieldsList.add(0, fields.build()); } } else { for (EnhancedAnnotatedType<?> t = type; t != null && !t.getJavaClass().equals(Object.class); t = t .getEnhancedSuperclass()) { ImmutableSet.Builder<FieldInjectionPoint<?, ?>> fields = ImmutableSet.builder(); for (EnhancedAnnotatedField<?, ?> annotatedField : t.getDeclaredEnhancedFields(Inject.class)) { if (!annotatedField.isStatic()) { addFieldInjectionPoint(annotatedField, fields, declaringBean, t.getJavaClass(), manager); } } injectableFieldsList.add(0, fields.build()); } } return immutableListView(injectableFieldsList); }
public static String forProducerField(EnhancedAnnotatedField<?, ?> field, AbstractClassBean<?> declaringBean) { StringBuilder sb = getPrefix(ProducerField.class).append(declaringBean.getAnnotated().getIdentifier().asString()) .append(BEAN_ID_SEPARATOR); if (declaringBean.getEnhancedAnnotated().isDiscovered()) { sb.append(field.getName()); } else { sb.append(AnnotatedTypes.createFieldId(field)); } return sb.toString(); }
super(attributes, new StringBeanIdentifier(BeanIdentifiers.forProducerField(field, declaringBean)), declaringBean, manager, services); this.enhancedAnnotatedField = field; this.annotatedField = field.slim(); initType(); this.proxiable = Proxies.isTypesProxyable(field.getTypeClosure(), beanManager.getServices()); setProducer(new ProducerFieldProducer<X, T>(field, disposalMethod) {
/** * Gets the default name of the bean * * @return The default name */ protected String getDefaultName(EnhancedAnnotated<?, ?> annotated) { if (annotated instanceof EnhancedAnnotatedType<?>) { if (manager.getServices().get(WeldConfiguration.class).getBooleanProperty(ConfigurationKey.DEFAULT_BEAN_NAMES_FOLLOW_JAVABEAN_RULES)) { // We need to fix WELD-1941 but still don't break existing applications return Introspector.decapitalize(((EnhancedAnnotatedType<?>) annotated).getSimpleName()); } else { StringBuilder defaultNameBuilder = new StringBuilder(((EnhancedAnnotatedType<?>) annotated).getSimpleName()); defaultNameBuilder.setCharAt(0, Character.toLowerCase(defaultNameBuilder.charAt(0))); return defaultNameBuilder.toString(); } } else if (annotated instanceof EnhancedAnnotatedField<?, ?>) { return ((EnhancedAnnotatedField<?, ?>) annotated).getPropertyName(); } else if (annotated instanceof EnhancedAnnotatedMethod<?, ?>) { return ((EnhancedAnnotatedMethod<?, ?>) annotated).getPropertyName(); } else { return null; } }
protected <X, T> void createProducerField(AbstractClassBean<X> declaringBean, EnhancedAnnotatedField<T, ? super X> field) { BeanAttributes<T> attributes = BeanAttributesFactory.forBean(field, getManager()); DisposalMethod<X, ?> disposalMethod = resolveDisposalMethod(attributes, declaringBean); ProducerField<X, T> bean; if (EEResourceProducerField.isEEResourceProducerField(manager, field)) { if (field.isStatic()) { bean = StaticEEResourceProducerField.of(attributes, field, declaringBean, disposalMethod, manager, services); } else { bean = EEResourceProducerField.of(attributes, field, declaringBean, disposalMethod, manager, services); } } else { bean = ProducerField.of(attributes, field, declaringBean, disposalMethod, manager, services); } containerLifecycleEvents.preloadProcessBeanAttributes(bean.getType()); containerLifecycleEvents.preloadProcessBean(ProcessProducerField.class, field.getBaseType(), bean.getBeanClass()); containerLifecycleEvents.preloadProcessProducer(bean.getBeanClass(), field.getBaseType()); getEnvironment().addProducerField(bean); }
/** * Gets the default name of the bean * * @return The default name */ protected String getDefaultName(EnhancedAnnotated<?, ?> annotated) { if (annotated instanceof EnhancedAnnotatedType<?>) { StringBuilder defaultName = new StringBuilder(((EnhancedAnnotatedType<?>) annotated).getSimpleName()); defaultName.setCharAt(0, Character.toLowerCase(defaultName.charAt(0))); return defaultName.toString(); } else if (annotated instanceof EnhancedAnnotatedField<?, ?>) { return ((EnhancedAnnotatedField<?, ?>) annotated).getPropertyName(); } else if (annotated instanceof EnhancedAnnotatedMethod<?, ?>) { return ((EnhancedAnnotatedMethod<?, ?>) annotated).getPropertyName(); } else { return null; } }
protected StaticEEResourceProducerField(BeanAttributes<T> attributes, EnhancedAnnotatedField<T, ? super X> field, AbstractClassBean<X> declaringBean, DisposalMethod<X, ?> disposalMethod, BeanManagerImpl manager, ServiceRegistry services) { super(attributes, field, declaringBean, disposalMethod, manager, services); this.resourceInjection = getResourceInjection(field, declaringBean, manager); this.accessibleField = AccessController.doPrivileged(new GetAccessibleCopyOfMember<Field>(field.getJavaMember())); this.injectionContext = new InjectionContextImpl<X>(manager, declaringBean.getInjectionTarget(), declaringBean.getAnnotated(), null) { @Override public void proceed() { } }; }
@Override public EnhancedAnnotatedType<X> getDeclaringType() { return delegate().getDeclaringType(); }
public Field getJavaMember() { return delegate().getJavaMember(); }
public String getPropertyName() { return delegate().getPropertyName(); }
ArrayList<EnhancedAnnotatedField<?, ? super T>> declaredFieldsTemp = new ArrayList<EnhancedAnnotatedField<?, ? super T>>(); Class<T> javaClass = annotatedType.getJavaClass(); EnhancedAnnotatedField<?, ? super T> annotatedField = EnhancedAnnotatedFieldImpl.of(field, this, classTransformer); declaredFieldsTemp.add(annotatedField); for (Annotation annotation : annotatedField.getAnnotations()) { declaredAnnotatedFields.put(annotation.annotationType(), annotatedField); if ((superclass != null) && (superclass.getJavaClass() != Object.class)) { fieldsTemp = Sets.union(fieldsTemp, Reflections.<Set<EnhancedAnnotatedField<?, ? super T>>>cast(superclass.getFields())); declaredFieldsTemp.add(weldField); for (Annotation annotation : weldField.getAnnotations()) { annotatedFields.put(annotation.annotationType(), weldField); if (annotatedField.getDeclaringType().getJavaClass().equals(javaClass)) { if (weldMethod.getEnhancedParameters(annotationType).size() > 0) { declaredMethodsByAnnotatedParameters.put(annotationType, weldMethod); if (superclass != null) { EnhancedAnnotatedType<?> current = superclass; while (current.getJavaClass() != Object.class) { methodsTemp.removeAll(getOverriddenMethods(this, methodsTemp, true));
public List<Set<FieldInjectionPoint<?, ?>>> getFieldInjectionPoints(Bean<?> declaringBean, EnhancedAnnotatedType<?> type, BeanManagerImpl manager) { List<Set<FieldInjectionPoint<?, ?>>> injectableFieldsList = new ArrayList<Set<FieldInjectionPoint<?, ?>>>(); if (type.slim() instanceof UnbackedAnnotatedType<?>) { // external AnnotatedTypes require special treatment Collection<EnhancedAnnotatedField<?, ?>> allFields = type.getEnhancedFields(Inject.class); for (Class<?> clazz = type.getJavaClass(); clazz != null && clazz != Object.class; clazz = clazz.getSuperclass()) { ImmutableSet.Builder<FieldInjectionPoint<?, ?>> fields = ImmutableSet.builder(); for (EnhancedAnnotatedField<?, ?> field : allFields) { if (!field.isStatic() && field.getJavaMember().getDeclaringClass().equals(clazz)) { addFieldInjectionPoint(field, fields, declaringBean, type.getJavaClass(), manager); } } injectableFieldsList.add(0, fields.build()); } } else { for (EnhancedAnnotatedType<?> t = type; t != null && !t.getJavaClass().equals(Object.class); t = t .getEnhancedSuperclass()) { ImmutableSet.Builder<FieldInjectionPoint<?, ?>> fields = ImmutableSet.builder(); for (EnhancedAnnotatedField<?, ?> annotatedField : t.getDeclaredEnhancedFields(Inject.class)) { if (!annotatedField.isStatic()) { addFieldInjectionPoint(annotatedField, fields, declaringBean, t.getJavaClass(), manager); } } injectableFieldsList.add(0, fields.build()); } } return ImmutableList.copyOf(injectableFieldsList); }
protected InferringFieldInjectionPointAttributes(EnhancedAnnotatedField<T, X> field, Bean<?> bean, Class<?> declaringComponentClass, BeanManagerImpl manager) { super(field, manager.getContextId(), bean, SharedObjectCache.instance(manager).getSharedSet(field.getQualifiers()), declaringComponentClass); this.field = field.slim(); }
public static String forProducerField(EnhancedAnnotatedField<?, ?> field, AbstractClassBean<?> declaringBean) { StringBuilder sb = getPrefix(ProducerField.class).append(declaringBean.getAnnotated().getIdentifier().asString()) .append(BEAN_ID_SEPARATOR); if (declaringBean.getEnhancedAnnotated().isDiscovered()) { sb.append(field.getName()); } else { sb.append(AnnotatedTypes.createFieldId(field)); } return sb.toString(); }