public static String getUnsatisfiedDependenciesAdditionalInfo(InjectionPoint ij, BeanManagerImpl beanManager) { Set<Bean<?>> beansMatchedByType = beanManager.getBeans(ij.getType(), AnyLiteral.INSTANCE); if (beansMatchedByType.isEmpty()) { Class<?> rawType = Reflections.getRawType(ij.getType()); if (rawType != null) { MissingDependenciesRegistry missingDependenciesRegistry = beanManager.getServices().get(MissingDependenciesRegistry.class); String missingDependency = missingDependenciesRegistry.getMissingDependencyForClass(rawType.getName()); if (missingDependency != null) { return ValidatorLogger.LOG.unsatisfiedDependencyBecauseClassIgnored( rawType.getName(), missingDependency); } } } else { return ValidatorLogger.LOG.unsatisfiedDependencyBecauseQualifiersDontMatch( WeldCollections.toMultiRowString(beansMatchedByType)); } return ""; }
/** * Returns an unmodifiable list of dependent instances. */ public List<ContextualInstance<?>> getDependentInstances() { return WeldCollections.immutableListView(dependentInstances); }
@Override public Map<?, ?> apply(Map<?, ?> from) { return WeldCollections.immutableMapView(from); } });
private static void validatePseudoScopedInjectionPoint(InjectionPoint ij, BeanManagerImpl beanManager, Set<Object> dependencyPath, Set<Bean<?>> validatedBeans) { Set<Bean<?>> resolved = beanManager.getBeans(ij); Bean<?> bean = null; try { bean = beanManager.resolve(resolved); } catch (AmbiguousResolutionException ex) { throw ValidatorLogger.LOG.injectionPointHasAmbiguousDependencies(ij, Formats.formatAnnotations(ij.getQualifiers()), Formats.formatInjectionPointType(ij.getType()), Formats.formatAsStackTraceElement(ij), WeldCollections.toMultiRowString(resolved)); } if (bean != null) { if (!(bean instanceof AbstractBuiltInBean<?>)) { if (!ij.isDelegate()) { boolean normalScoped = beanManager.isNormalScope(bean.getScope()); if (!normalScoped && !(bean instanceof SessionBean)) { reallyValidatePseudoScopedBean(bean, beanManager, dependencyPath, validatedBeans); } } } } }
private Set<InterceptionModel> getInterceptionModelsForType(EnhancedAnnotatedType<T> type, BeanManagerImpl manager, Bean<?> bean) { // if the bean has decorators consider all methods as intercepted if (bean != null && !manager.resolveDecorators(bean.getTypes(), bean.getQualifiers()).isEmpty()) { return null; } SlimAnnotatedTypeStore store = manager.getServices().get(SlimAnnotatedTypeStore.class); Set<InterceptionModel> models = new HashSet<InterceptionModel>(); WeldCollections.addIfNotNull(models, manager.getInterceptorModelRegistry().get(type.slim())); for (SlimAnnotatedType<?> slimType : store.get(type.getJavaClass())) { WeldCollections.addIfNotNull(models, manager.getInterceptorModelRegistry().get(slimType)); } for (InterceptionModel model : models) { if (model.hasTargetClassInterceptors() && model.getTargetClassInterceptorMetadata().isEligible(InterceptionType.AROUND_INVOKE)) { // this means that all methods are intercepted // returning null here means that all methods will be overridden and will delegate to MethodHandler return null; } } return models; }
if (ij.isDelegate()) { return; // do not validate delegate injection points as these are special Set<?> resolvedBeans = beanManager.getBeanResolver().resolve(beanManager.getBeans(ij)); if (!isInjectionPointSatisfied(ij, resolvedBeans, beanManager)) { throw ValidatorLogger.LOG.injectionPointHasUnsatisfiedDependencies( ij, Formats.formatAnnotations(ij.getQualifiers()), Formats.formatInjectionPointType(ij.getType()), Formats.formatAsStackTraceElement(ij), InjectionPoints.getUnsatisfiedDependenciesAdditionalInfo(ij, beanManager)); throw ValidatorLogger.LOG.injectionPointHasAmbiguousDependencies( ij, Formats.formatAnnotations(ij.getQualifiers()), Formats.formatInjectionPointType(ij.getType()), Formats.formatAsStackTraceElement(ij), WeldCollections.toMultiRowString(resolvedBeans)); if (beanManager.isNormalScope(resolvedBean.getScope())) { UnproxyableResolutionException ue = Proxies.getUnproxyableTypeException(ij.getType(), resolvedBean, beanManager.getServices()); if (ue != null) { throw ValidatorLogger.LOG.injectionPointHasNonProxyableDependencies(ij, Formats.formatAsStackTraceElement(ij), ue); validateInjectionPointPassivationCapable(ij, resolvedBean, beanManager);
private void checkBeanResolved() { if (bean != null) { return; } else if (isUnsatisfied()) { throw BeanManagerLogger.LOG.injectionPointHasUnsatisfiedDependencies(Formats.formatAnnotations(ip.getQualifiers()), Formats.formatInjectionPointType(ip.getType()), InjectionPoints.getUnsatisfiedDependenciesAdditionalInfo(ip, getBeanManager())); } else { throw BeanManagerLogger.LOG.injectionPointHasAmbiguousDependencies(Formats.formatAnnotations(ip.getQualifiers()), Formats.formatInjectionPointType(ip.getType()), WeldCollections.toMultiRowString(allBeans())); } }
public <X> List<ParameterInjectionPoint<?, X>> getParameterInjectionPoints(EnhancedAnnotatedCallable<?, X, ?> callable, Bean<?> declaringBean, Class<?> declaringComponentClass, BeanManagerImpl manager, boolean observerOrDisposer) { List<ParameterInjectionPoint<?, X>> parameters = new ArrayList<ParameterInjectionPoint<?, X>>(); /* * bean that the injection point belongs to this is null for observer and disposer methods */ Bean<?> bean = null; if (!observerOrDisposer) { bean = declaringBean; } for (EnhancedAnnotatedParameter<?, X> parameter : callable.getEnhancedParameters()) { if (isSpecialParameter(parameter)) { parameters.add(SpecialParameterInjectionPoint.of(parameter, bean, declaringBean.getBeanClass(), manager)); } else { parameters.add(createParameterInjectionPoint(parameter, bean, declaringComponentClass, manager)); } } return immutableListView(parameters); }
throw ValidatorLogger.LOG.pseudoScopedBeanHasCircularReferences(WeldCollections.toMultiRowString(realDependencyPath)); for (InjectionPoint injectionPoint : bean.getInjectionPoints()) { if (!injectionPoint.isDelegate()) { dependencyPath.add(injectionPoint); validatePseudoScopedInjectionPoint(injectionPoint, beanManager, dependencyPath, validatedBeans); dependencyPath.remove(injectionPoint); final List<Decorator<?>> decorators = Reflections.<DecorableBean<?>>cast(bean).getDecorators(); if (!decorators.isEmpty()) { for (final Decorator<?> decorator : decorators) { reallyValidatePseudoScopedBean(decorator, beanManager, dependencyPath, validatedBeans); if (!beanManager.isNormalScope(producer.getDeclaringBean().getScope()) && !producer.getAnnotated().isStatic()) { reallyValidatePseudoScopedBean(producer.getDeclaringBean(), beanManager, dependencyPath, validatedBeans);
public BeanDeploymentModule getModule(BeanManagerImpl manager) { final EEModuleDescriptor descriptor = manager.getServices().get(EEModuleDescriptor.class); // fallback for legacy integrators if (descriptor == null) { defaultModule.addManager(manager); modules.putIfAbsent(defaultModule.getId(), defaultModule); return defaultModule; } BeanDeploymentModule module = modules.get(descriptor.getId()); if (module == null) { module = new BeanDeploymentModule(descriptor.getId(), manager.getContextId(), descriptor.getType() == EEModuleDescriptor.ModuleType.WEB, manager.getServices()); module = WeldCollections.putIfAbsent(modules, descriptor.getId(), module); } module.addManager(manager); return module; }
/** * Initializes module enablement. * * @see ModuleEnablement */ public void createEnablement() { GlobalEnablementBuilder builder = beanManager.getServices().get(GlobalEnablementBuilder.class); ModuleEnablement enablement = builder.createModuleEnablement(this); beanManager.setEnabled(enablement); if (BootstrapLogger.LOG.isDebugEnabled()) { BootstrapLogger.LOG.enabledAlternatives(this.beanManager, WeldCollections.toMultiRowString(enablement.getAllAlternatives())); BootstrapLogger.LOG.enabledDecorators(this.beanManager, WeldCollections.toMultiRowString(enablement.getDecorators())); BootstrapLogger.LOG.enabledInterceptors(this.beanManager, WeldCollections.toMultiRowString(enablement.getInterceptors())); } }
public Set<Type> getInterfaceClosure() { Set<Type> interfaces = new HashSet<Type>(); for (Type t : getTypeClosure()) { if (Reflections.getRawType(t).isInterface()) { interfaces.add(t); } } return WeldCollections.immutableSetView(interfaces); }
private void validateEnabledDecoratorClasses(BeanManagerImpl beanManager, BeanDeployment deployment) { BeansXml beansXml = deployment.getBeanDeploymentArchive().getBeansXml(); if (beansXml != null && !beansXml.getEnabledDecorators().isEmpty()) { Set<String> decoratorBeanClasses = new HashSet<String>(); for (Decorator<?> bean : beanManager.getDynamicAccessibleDecorators()) { decoratorBeanClasses.add(bean.getBeanClass().getName()); } for (Metadata<String> decoratorClassName : beansXml.getEnabledDecorators()) { if (!decoratorBeanClasses.contains(decoratorClassName.getValue())) { throw ValidatorLogger.LOG.decoratorClassNotBeanClassOfDecorator(decoratorClassName.getValue(), WeldCollections.toMultiRowString(decoratorBeanClasses)); } } } }
private void validateDisposalMethods(BeanDeployerEnvironment environment) { Set<DisposalMethod<?, ?>> beans = environment.getUnresolvedDisposalBeans(); if (!beans.isEmpty()) { throw ValidatorLogger.LOG.disposalMethodsWithoutProducer(WeldCollections.toMultiRowString(beans)); } }
@Override public Set<?> apply(Set<?> from) { return WeldCollections.immutableSetView(from); } });
private CachedObservers getObservers(T event) { Class<?> runtimeType = event.getClass(); CachedObservers lastResolvedObservers = this.lastCachedObservers; // fast track for cases when the same type is used repeatedly if (lastResolvedObservers != null && lastResolvedObservers.rawType.equals(runtimeType)) { return lastResolvedObservers; } lastResolvedObservers = cachedObservers.get(runtimeType); if (lastResolvedObservers == null) { // this is not atomic and less elegant than computeIfAbsent but is faster and atomicity does not really matter here // as createCachedObservers() does not have any side effects lastResolvedObservers = putIfAbsent(cachedObservers, runtimeType, createCachedObservers(runtimeType)); } return this.lastCachedObservers = lastResolvedObservers; }
protected <X> DisposalMethod<X, ?> resolveDisposalMethod(BeanAttributes<?> attributes, AbstractClassBean<X> declaringBean) { Set<DisposalMethod<X, ?>> disposalBeans = environment.<X>resolveDisposalBeans(attributes.getTypes(), attributes.getQualifiers(), declaringBean); if (disposalBeans.size() == 1) { return disposalBeans.iterator().next(); } else if (disposalBeans.size() > 1) { throw BeanLogger.LOG.multipleDisposalMethods(this, WeldCollections.toMultiRowString(disposalBeans)); } return null; }
private static void validatePseudoScopedInjectionPoint(InjectionPoint ij, BeanManagerImpl beanManager, Set<Object> dependencyPath, Set<Bean<?>> validatedBeans) { Set<Bean<?>> resolved = beanManager.getBeans(ij); Bean<?> bean = null; try { bean = beanManager.resolve(resolved); } catch (AmbiguousResolutionException ex) { throw ValidatorLogger.LOG.injectionPointHasAmbiguousDependencies(ij, Formats.formatAnnotations(ij.getQualifiers()), Formats.formatInjectionPointType(ij.getType()), Formats.formatAsStackTraceElement(ij), WeldCollections.toMultiRowString(resolved)); } if (bean != null) { if (!(bean instanceof AbstractBuiltInBean<?>)) { if (!ij.isDelegate()) { boolean normalScoped = beanManager.isNormalScope(bean.getScope()); if (!normalScoped && !(bean instanceof SessionBean)) { reallyValidatePseudoScopedBean(bean, beanManager, dependencyPath, validatedBeans); } } } } }
private Set<InterceptionModel> getInterceptionModelsForType(EnhancedAnnotatedType<T> type, BeanManagerImpl manager, Bean<?> bean) { // if the bean has decorators consider all methods as intercepted if (bean != null && !manager.resolveDecorators(bean.getTypes(), bean.getQualifiers()).isEmpty()) { return null; } SlimAnnotatedTypeStore store = manager.getServices().get(SlimAnnotatedTypeStore.class); Set<InterceptionModel> models = new HashSet<InterceptionModel>(); WeldCollections.addIfNotNull(models, manager.getInterceptorModelRegistry().get(type.slim())); for (SlimAnnotatedType<?> slimType : store.get(type.getJavaClass())) { WeldCollections.addIfNotNull(models, manager.getInterceptorModelRegistry().get(slimType)); } for (InterceptionModel model : models) { if (model.hasTargetClassInterceptors() && model.getTargetClassInterceptorMetadata().isEligible(InterceptionType.AROUND_INVOKE)) { // this means that all methods are intercepted // returning null here means that all methods will be overridden and will delegate to MethodHandler return null; } } return models; }
if (ij.isDelegate()) { return; // do not validate delegate injection points as these are special Set<Bean<?>> resolvedBeans = beanManager.getBeanResolver().resolve(beanManager.getBeans(ij)); if (!isInjectionPointSatisfied(ij, resolvedBeans, beanManager)) { throw ValidatorLogger.LOG.injectionPointHasUnsatisfiedDependencies( ij, Formats.formatAnnotations(ij.getQualifiers()), Formats.formatInjectionPointType(ij.getType()), Formats.formatAsStackTraceElement(ij), InjectionPoints.getUnsatisfiedDependenciesAdditionalInfo(ij, beanManager)); throw ValidatorLogger.LOG.injectionPointHasAmbiguousDependencies( ij, Formats.formatAnnotations(ij.getQualifiers()), Formats.formatInjectionPointType(ij.getType()), Formats.formatAsStackTraceElement(ij), WeldCollections.toMultiRowString(resolvedBeans)); if (beanManager.isNormalScope(resolvedBean.getScope())) { UnproxyableResolutionException ue = Proxies.getUnproxyableTypeException(ij.getType(), resolvedBean, beanManager.getServices(), false); if (ue != null) { throw ValidatorLogger.LOG.injectionPointHasNonProxyableDependencies(ij, Formats.formatAsStackTraceElement(ij), ue); validateInjectionPointPassivationCapable(ij, resolvedBean, beanManager);