public InjectionTargetService(BeanManagerImpl beanManager) { this.validator = new Validator(); this.producersToValidate = new ConcurrentLinkedQueue<Producer<?>>(); this.injectionTargetsToInitialize = new ConcurrentLinkedQueue<InjectionTargetInitializationContext<?>>(); this.container = Container.instance(beanManager); this.beanManager = beanManager; }
private void checkScopeAnnotations(InjectionPoint ij, MetaAnnotationStore metaAnnotationStore) { Annotated annotated = ij.getAnnotated(); if (annotated instanceof EnhancedAnnotated<?, ?>) { EnhancedAnnotated<?, ?> weldAnnotated = (EnhancedAnnotated<?, ?>) annotated; Set<Annotation> scopes = weldAnnotated.getMetaAnnotations(Scope.class); Set<Annotation> normalScopes = weldAnnotated.getMetaAnnotations(NormalScope.class); for (Annotation annotation : scopes) { logScopeOnInjectionPointWarning(ij, annotation); } for (Annotation annotation : normalScopes) { logScopeOnInjectionPointWarning(ij, annotation); } } else { for (Annotation annotation : annotated.getAnnotations()) { if (hasScopeMetaAnnotation(annotation)) { logScopeOnInjectionPointWarning(ij, annotation); } } } }
private boolean isAlternativeCandidate(Class<?> enabledClass, BeanManagerImpl beanManager) { // Note that the deployment would fail if any alternative <class> cannot be loaded // <class> exists and is annotated with @Alternative or alternative stereotype if (isAlternativeOrHasAlternativeStereotype(enabledClass, beanManager)) { return true; } // <class> declares producer with alternative // Intentionally do not process the class hierarchy - for (Method declaredMethod : AccessController.doPrivileged(new GetDeclaredMethodsAction(enabledClass))) { if (declaredMethod.isAnnotationPresent(Produces.class) && isAlternativeOrHasAlternativeStereotype(declaredMethod, beanManager)) { return true; } } for (Field declaredField : AccessController.doPrivileged(new GetDeclaredFieldsAction(enabledClass))) { if (declaredField.isAnnotationPresent(Produces.class) && isAlternativeOrHasAlternativeStereotype(declaredField, beanManager)) { return true; } } return false; }
if (ij.getAnnotated().getAnnotation(New.class) != null && ij.getQualifiers().size() > 1) { throw ValidatorLogger.LOG.newWithQualifiers(ij, Formats.formatAsStackTraceElement(ij)); if (ij.getType() instanceof TypeVariable<?>) { throw ValidatorLogger.LOG.injectionPointWithTypeVariable(ij, Formats.formatAsStackTraceElement(ij)); if (!(ij.getMember() instanceof Field) && ij.getAnnotated().isAnnotationPresent(Named.class) && ij.getAnnotated().getAnnotation(Named.class).value().equals("")) { throw ValidatorLogger.LOG.nonFieldInjectionPointCannotUseNamed(ij, Formats.formatAsStackTraceElement(ij)); if (ij.getAnnotated().isAnnotationPresent(Produces.class)) { throw BeanLogger.LOG.injectedFieldCannotBeProducer(ij.getAnnotated(), bean); } else { throw BeanLogger.LOG.injectedFieldCannotBeProducer(ij.getAnnotated(), Reflections.<AnnotatedField<?>>cast(ij.getAnnotated()).getDeclaringType()); checkScopeAnnotations(ij, beanManager.getServices().get(MetaAnnotationStore.class)); checkFacadeInjectionPoint(ij, Instance.class); checkFacadeInjectionPoint(ij, Event.class); JtaApiAbstraction jtaApi = beanManager.getServices().get(JtaApiAbstraction.class); if (jtaApi.USER_TRANSACTION_CLASS.equals(ij.getType()) && (ij.getQualifiers().isEmpty() || ij.getQualifiers().contains(DefaultLiteral.INSTANCE)) && beanManager.getServices().get(EJBApiAbstraction.class).isSessionBeanWithContainerManagedTransactions(bean)) { throw ValidatorLogger.LOG.userTransactionInjectionIntoBeanWithContainerManagedTransactions(ij, Formats.formatAsStackTraceElement(ij));
public void validateMetadataInjectionPoint(InjectionPoint ij, Bean<?> bean, MessageCallback<DefinitionException> messageCallback) { // metadata injection points if (ij.getType().equals(InjectionPoint.class) && bean == null) { throw messageCallback.construct(ij, Formats.formatAsStackTraceElement(ij)); } if (ij.getType().equals(InjectionPoint.class) && !Dependent.class.equals(bean.getScope())) { throw ValidatorLogger.LOG.injectionIntoNonDependentBean(ij, Formats.formatAsStackTraceElement(ij)); } Class<?> rawType = Reflections.getRawType(ij.getType()); if (Bean.class.equals(rawType) || Interceptor.class.equals(rawType) || Decorator.class.equals(rawType)) { if (bean == null) { throw messageCallback.construct(ij, Formats.formatAsStackTraceElement(ij)); } if (bean instanceof AbstractClassBean<?>) { checkBeanMetadataInjectionPoint(bean, ij, AnnotatedTypes.getDeclaringAnnotatedType(ij.getAnnotated()).getBaseType()); } if (bean instanceof ProducerMethod<?, ?>) { ProducerMethod<?, ?> producerMethod = Reflections.cast(bean); checkBeanMetadataInjectionPoint(bean, ij, producerMethod.getAnnotated().getBaseType()); } } }
private void validateEnabledAlternativeClasses(BeanManagerImpl beanManager, BeanDeployment deployment) { BeansXml beansXml = deployment.getBeanDeploymentArchive().getBeansXml(); if (beansXml != null && !beansXml.getEnabledAlternativeClasses().isEmpty()) { // prepare lookup structure Map<String, Class<?>> loadedClasses = buildClassNameMap(beanManager.getEnabled().getAlternativeClasses()); // lookup structure for validation of alternatives Multimap<Class<?>, Bean<?>> beansByClass = SetMultimap.newSetMultimap(); for (Bean<?> bean : beanManager.getDynamicAccessibleBeans()) { if (!(bean instanceof NewBean)) { beansByClass.put(bean.getBeanClass(), bean); } } for (Metadata<String> definition : beansXml.getEnabledAlternativeClasses()) { Class<?> enabledClass = loadedClasses.get(definition.getValue()); if (enabledClass.isAnnotation() || enabledClass.isInterface()) { throw ValidatorLogger.LOG.alternativeBeanClassNotClass(definition); } else { if (!isAlternativeBean(enabledClass, beansByClass) && !isAlternativeCandidate(enabledClass, beanManager)) { throw ValidatorLogger.LOG.alternativeBeanClassNotAnnotated(definition.getValue(), definition.getLocation()); } } } } }
Map<String, Class<?>> loadedClasses = buildClassNameMap(beanManager.getEnabled().getAlternativeClasses()); for (Bean<?> bean : beanManager.getDynamicAccessibleBeans()) { if (!(bean instanceof NewBean)) { beansByClass.put(bean.getBeanClass(), bean); Class<?> enabledClass = loadedClasses.get(definition.getValue()); if (enabledClass.isAnnotation() || enabledClass.isInterface()) { throw ValidatorLogger.LOG.alternativeBeanClassNotClass(definition); } else { final WeldConfiguration configuration = beanManager.getServices().get(WeldConfiguration.class); boolean allowVetoedAlternatives = configuration.getBooleanProperty(ConfigurationKey.ALLOW_VETOED_ALTERNATIVES); if (!isAlternativeBean(enabledClass, beansByClass)) { if (!allowVetoedAlternatives) { throw ValidatorLogger.LOG.alternativeBeanClassNotAnnotatedOrVetoed(definition.getValue(), definition.getLocation()); } else if (! isAlternativeCandidate(enabledClass, beanManager)) { throw ValidatorLogger.LOG.alternativeBeanClassNotAnnotated(definition.getValue(), definition.getLocation());
public void validateInterceptorDecoratorInjectionPointPassivationCapable(InjectionPoint ij, Bean<?> resolvedBean, BeanManagerImpl beanManager, Bean<?> bean) { if (!isInjectionPointPassivationCapable(ij, resolvedBean, beanManager)) { throw ValidatorLogger.LOG.interceptorDecoratorInjectionPointHasNonSerializableDependency(bean, ij.getBean(), resolvedBean); } }
public void validateInjectionPointPassivationCapable(InjectionPoint ij, Bean<?> resolvedBean, BeanManagerImpl beanManager) { if (!isInjectionPointPassivationCapable(ij, resolvedBean, beanManager)) { throw ValidatorLogger.LOG.injectionPointHasNonSerializableDependency(ij.getBean(), resolvedBean); } }
private void validateEnabledAlternativeStereotypes(BeanManagerImpl beanManager, BeanDeployment deployment) { BeansXml beansXml = deployment.getBeanDeploymentArchive().getBeansXml(); if (beansXml != null && !beansXml.getEnabledAlternativeStereotypes().isEmpty()) { // prepare lookup structure Map<String, Class<? extends Annotation>> loadedStereotypes = buildClassNameMap(beanManager.getEnabled().getAlternativeStereotypes()); for (Metadata<String> definition : beansXml.getEnabledAlternativeStereotypes()) { Class<? extends Annotation> stereotype = loadedStereotypes.get(definition.getValue()); if (!beanManager.isStereotype(stereotype)) { throw ValidatorLogger.LOG.alternativeStereotypeNotStereotype(definition); } if (!isAlternativeStereotype(beanManager, stereotype)) { throw ValidatorLogger.LOG.alternativeStereotypeNotAnnotated(definition); } } } }
private void checkDisposalMethod(EnhancedAnnotatedMethod<T, ? super X> enhancedAnnotatedMethod, AbstractClassBean<X> declaringBean) { if (enhancedAnnotatedMethod.getEnhancedParameters(Disposes.class).size() > 1) { throw BeanLogger.LOG .multipleDisposeParams(disposalMethodInjectionPoint, Formats.formatAsStackTraceElement(enhancedAnnotatedMethod.getJavaMember())); Formats.formatAsStackTraceElement(enhancedAnnotatedMethod.getJavaMember())); Formats.formatAsStackTraceElement(enhancedAnnotatedMethod.getJavaMember())); Class<?> rawType = Reflections.getRawType(ip.getType()); if (Bean.class.equals(rawType) || Interceptor.class.equals(rawType) || Decorator.class.equals(rawType)) { Validator.checkBeanMetadataInjectionPoint(this, ip, getDisposesParameter().getBaseType());
private boolean isAlternativeOrHasAlternativeStereotype(AnnotatedElement annotatedElement, BeanManagerImpl beanManager) { if (annotatedElement.isAnnotationPresent(Alternative.class)) { return true; } for (Annotation annotation : annotatedElement.getAnnotations()) { if (isAlternativeStereotype(beanManager, annotation.annotationType())) { return true; } } return false; }
if (ij.getAnnotated().getAnnotation(New.class) != null && ij.getQualifiers().size() > 1) { throw ValidatorLogger.LOG.newWithQualifiers(ij, Formats.formatAsStackTraceElement(ij)); if (ij.getType() instanceof TypeVariable<?>) { throw ValidatorLogger.LOG.injectionPointWithTypeVariable(ij, Formats.formatAsStackTraceElement(ij)); throw ValidatorLogger.LOG.nonFieldInjectionPointCannotUseNamed(ij, Formats.formatAsStackTraceElement(ij)); throw BeanLogger.LOG.injectedFieldCannotBeProducer(ij.getAnnotated(), bean); } else { throw BeanLogger.LOG.injectedFieldCannotBeProducer(ij.getAnnotated(), Reflections.<AnnotatedField<?>>cast(ij.getAnnotated()).getDeclaringType()); checkScopeAnnotations(ij, beanManager.getServices().get(MetaAnnotationStore.class)); checkFacadeInjectionPoint(ij, Instance.class); checkFacadeInjectionPoint(ij, Event.class); if (InterceptionFactory.class.equals(Reflections.getRawType(ij.getType())) && !(bean instanceof ProducerMethod<?, ?>)) { throw ValidatorLogger.LOG.invalidInterceptionFactoryInjectionPoint(ij, Formats.formatAsStackTraceElement(ij));
public void validateMetadataInjectionPoint(InjectionPoint ij, Bean<?> bean, MessageCallback<DefinitionException> messageCallback) { // metadata injection points if (ij.getType().equals(InjectionPoint.class) && bean == null) { throw messageCallback.construct(ij, Formats.formatAsStackTraceElement(ij)); } if (ij.getType().equals(InjectionPoint.class) && !Dependent.class.equals(bean.getScope())) { throw ValidatorLogger.LOG.injectionIntoNonDependentBean(ij, Formats.formatAsStackTraceElement(ij)); } Class<?> rawType = Reflections.getRawType(ij.getType()); if (Bean.class.equals(rawType) || Interceptor.class.equals(rawType) || Decorator.class.equals(rawType)) { if (bean == null) { throw messageCallback.construct(ij, Formats.formatAsStackTraceElement(ij)); } if (bean instanceof AbstractClassBean<?>) { checkBeanMetadataInjectionPoint(bean, ij, AnnotatedTypes.getDeclaringAnnotatedType(ij.getAnnotated()).getBaseType()); } if (bean instanceof ProducerMethod<?, ?>) { ProducerMethod<?, ?> producerMethod = Reflections.cast(bean); checkBeanMetadataInjectionPoint(bean, ij, producerMethod.getAnnotated().getBaseType()); } } }
private void validateEnabledAlternativeClasses(BeanManagerImpl beanManager, BeanDeployment deployment) { BeansXml beansXml = deployment.getBeanDeploymentArchive().getBeansXml(); if (beansXml != null && !beansXml.getEnabledAlternativeClasses().isEmpty()) { // prepare lookup structure Map<String, Class<?>> loadedClasses = buildClassNameMap(beanManager.getEnabled().getAlternativeClasses()); // lookup structure for validation of alternatives Multimap<Class<?>, Bean<?>> beansByClass = SetMultimap.newSetMultimap(); for (Bean<?> bean : beanManager.getDynamicAccessibleBeans()) { if (!(bean instanceof NewBean)) { beansByClass.put(bean.getBeanClass(), bean); } } for (Metadata<String> definition : beansXml.getEnabledAlternativeClasses()) { Class<?> enabledClass = loadedClasses.get(definition.getValue()); if (enabledClass.isAnnotation() || enabledClass.isInterface()) { throw ValidatorLogger.LOG.alternativeBeanClassNotClass(definition); } else { if (!isAlternativeBean(enabledClass, beansByClass) && !isAlternativeCandidate(enabledClass, beanManager)) { throw ValidatorLogger.LOG.alternativeBeanClassNotAnnotated(definition.getValue(), definition.getLocation()); } } } } }
public void validateInterceptorDecoratorInjectionPointPassivationCapable(InjectionPoint ij, Bean<?> resolvedBean, BeanManagerImpl beanManager, Bean<?> bean) { if (!isInjectionPointPassivationCapable(ij, resolvedBean, beanManager)) { throw ValidatorLogger.LOG.interceptorDecoratorInjectionPointHasNonSerializableDependency(bean, ij.getBean(), resolvedBean); } }
public void validateInjectionPointPassivationCapable(InjectionPoint ij, Bean<?> resolvedBean, BeanManagerImpl beanManager) { if (!isInjectionPointPassivationCapable(ij, resolvedBean, beanManager)) { throw ValidatorLogger.LOG.injectionPointHasNonSerializableDependency(ij.getBean(), resolvedBean); } }
private void validateEnabledAlternativeStereotypes(BeanManagerImpl beanManager, BeanDeployment deployment) { BeansXml beansXml = deployment.getBeanDeploymentArchive().getBeansXml(); if (beansXml != null && !beansXml.getEnabledAlternativeStereotypes().isEmpty()) { // prepare lookup structure Map<String, Class<? extends Annotation>> loadedStereotypes = buildClassNameMap(beanManager.getEnabled().getAlternativeStereotypes()); for (Metadata<String> definition : beansXml.getEnabledAlternativeStereotypes()) { Class<? extends Annotation> stereotype = loadedStereotypes.get(definition.getValue()); if (!beanManager.isStereotype(stereotype)) { throw ValidatorLogger.LOG.alternativeStereotypeNotStereotype(definition); } if (!isAlternativeStereotype(beanManager, stereotype)) { throw ValidatorLogger.LOG.alternativeStereotypeNotAnnotated(definition); } } } }
private void checkDisposalMethod(EnhancedAnnotatedMethod<T, ? super X> enhancedAnnotatedMethod, AbstractClassBean<X> declaringBean) { if (enhancedAnnotatedMethod.getEnhancedParameters(Disposes.class).size() > 1) { throw BeanLogger.LOG .multipleDisposeParams(disposalMethodInjectionPoint, Formats.formatAsStackTraceElement(enhancedAnnotatedMethod.getJavaMember())); Formats.formatAsStackTraceElement(enhancedAnnotatedMethod.getJavaMember())); Formats.formatAsStackTraceElement(enhancedAnnotatedMethod.getJavaMember())); Class<?> rawType = Reflections.getRawType(ip.getType()); if (Bean.class.equals(rawType) || Interceptor.class.equals(rawType) || Decorator.class.equals(rawType)) { Validator.checkBeanMetadataInjectionPoint(this, ip, getDisposesParameter().getBaseType());
private boolean isAlternativeOrHasAlternativeStereotype(AnnotatedElement annotatedElement, BeanManagerImpl beanManager) { if (annotatedElement.isAnnotationPresent(Alternative.class)) { return true; } for (Annotation annotation : annotatedElement.getAnnotations()) { if (isAlternativeStereotype(beanManager, annotation.annotationType())) { return true; } } return false; }