public boolean isInjectedByEEComponent(Bean<?> bean, BeanManagerImpl beanManager) { if (componentInjectionPoints.isEmpty()) { return false; } for (InjectionPoint injectionPoint : componentInjectionPoints) { if (beanManager.getBeanResolver().resolve(new ResolvableBuilder(injectionPoint, beanManager).create(), false).contains(bean)) { return true; } } return false; }
public void endInitialization() { tracker.start(Tracker.OP_END_INIT); final BeanIdentifierIndex index = deploymentManager.getServices().get(BeanIdentifierIndex.class); if (index != null) { index.build(getBeansForBeanIdentifierIndex()); flushCaches(); deploymentManager.getServices().cleanupAfterBoot(); deploymentManager.cleanupAfterBoot(); for (BeanDeployment beanDeployment : getBeanDeployments()) { BeanManagerImpl beanManager = beanDeployment.getBeanManager(); beanManager.getInterceptorMetadataReader().cleanAfterBoot(); beanManager.getServices().cleanupAfterBoot(); beanManager.cleanupAfterBoot(); if (UnusedBeans.isEnabled(deploymentManager.getServices().get(WeldConfiguration.class))) { deploymentManager.getBeanResolver().clear(); for (BeanDeployment beanDeployment : getBeanDeployments()) { beanDeployment.getBeanManager().getBeanResolver().clear(); deploymentManager.getServices().get(Validator.class).clearResolved();
requiredType = Parsers.parseType(filterValues.get(REQUIRED_TYPE), beanManager.getServices().get(ResourceLoader.class)); } else { requiredType = Object.class; return getError("Invalid required type: parsing error or the type is not accessible from the specified bean archive!"); ResolvableBuilder resolvableBuilder = new ResolvableBuilder(requiredType, beanManager); qualifierInstances = Parsers.parseQualifiers(filterValues.get(QUALIFIERS), beanManager.getServices().get(ResourceLoader.class), beanManager); } else { qualifierInstances = Collections.singletonList(QualifierInstance.DEFAULT); return getError("Invalid qualifiers: parsing error or one of the qualifier types is not accessible from the specified bean archive!"); resolvableBuilder.addQualifierUnchecked(qualifierInstance); Resolvable resolvable = resolvableBuilder.create(); beans = beanManager.getBeanResolver().resolve(resolvable, false); if (Boolean.valueOf(filterValues.get(RESOLVE))) { beans = beanManager.getBeanResolver().resolve(beans);
this.beanResolver = new TypeSafeBeanResolver(this, createDynamicAccessibleIterable(beanTransform)); this.decoratorResolver = new TypeSafeDecoratorResolver(this, createDynamicGlobalIterable(Transform.DECORATOR)); this.interceptorResolver = new TypeSafeInterceptorResolver(this, createDynamicGlobalIterable(Transform.INTERCEPTOR)); this.nameBasedResolver = new NameBasedResolver(this, createDynamicAccessibleIterable(beanTransform)); this.weldELResolver = new WeldELResolver(this); this.childActivities = new CopyOnWriteArraySet<BeanManagerImpl>(); TypeSafeObserverResolver accessibleObserverResolver = new TypeSafeObserverResolver(getServices().get(MetaAnnotationStore.class), createDynamicAccessibleIterable(Transform.OBSERVER), getServices().get(WeldConfiguration.class)); this.accessibleLenientObserverNotifier = ObserverNotifier.of(contextId, accessibleObserverResolver, getServices(), false); GlobalObserverNotifierService globalObserverNotifierService = services.get(GlobalObserverNotifierService.class); this.globalLenientObserverNotifier = globalObserverNotifierService.getGlobalLenientObserverNotifier(); this.globalStrictObserverNotifier = globalObserverNotifierService.getGlobalStrictObserverNotifier();
private void flushCaches() { deploymentManager.getBeanResolver().clear(); deploymentManager.getAccessibleLenientObserverNotifier().clear(); deploymentManager.getGlobalStrictObserverNotifier().clear(); deploymentManager.getGlobalLenientObserverNotifier().clear(); deploymentManager.getDecoratorResolver().clear(); deploymentManager.getInterceptorResolver().clear(); deploymentManager.getNameBasedResolver().clear(); for (BeanDeployment beanDeployment : getBeanDeployments()) { BeanManagerImpl beanManager = beanDeployment.getBeanManager(); beanManager.getBeanResolver().clear(); beanManager.getAccessibleLenientObserverNotifier().clear(); beanManager.getDecoratorResolver().clear(); beanManager.getInterceptorResolver().clear(); beanManager.getNameBasedResolver().clear(); } }
public void validateBeans() { BootstrapLogger.LOG.validatingBeans(); tracker.start(Tracker.OP_VALIDATE_BEANS); try { for (BeanDeployment beanDeployment : getBeanDeployments()) { BeanManagerImpl beanManager = beanDeployment.getBeanManager(); beanManager.getBeanResolver().clear(); deployment.getServices().get(Validator.class).validateDeployment(beanManager, beanDeployment); beanManager.getServices().get(InjectionTargetService.class).validate(); } } catch (Exception e) { validationFailed(e); throw e; } getContainer().setState(ContainerState.VALIDATED); tracker.start(Tracker.OP_ADV); AfterDeploymentValidationImpl.fire(deploymentManager); tracker.end(); tracker.end(); }
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()), throw ValidatorLogger.LOG.injectionPointHasAmbiguousDependencies( ij, Formats.formatAnnotations(ij.getQualifiers()), 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); if (bean != null && Beans.isPassivatingScope(bean, beanManager)) { validateInjectionPointPassivationCapable(ij, resolvedBean, beanManager);
private void removeUnusedBeans() { String excludeTypeProperty = getServices().get(WeldConfiguration.class).getStringProperty(ConfigurationKey.UNUSED_BEANS_EXCLUDE_TYPE); String excludeAnnotationProperty = getServices().get(WeldConfiguration.class).getStringProperty(ConfigurationKey.UNUSED_BEANS_EXCLUDE_ANNOTATION); Validator validator = getServices().get(Validator.class); bean = Beans.unwrap(bean); bean = Beans.unwrap(bean); if (!unusedProducers.containsAll(beanToDeclaredProducers.get(bean))) { continue; sharedBeans.removeAll(removable); beanResolver.clear(); cleanupBeansAfterBoot(removable);
public boolean isInstanceResolvedBean(Bean<?> bean, BeanManagerImpl beanManager) { if (instanceInjectionPoints.isEmpty()) { return false; } for (InjectionPoint injectionPoint : instanceInjectionPoints) { Type facadeType = getFacadeType(injectionPoint); if (facadeType != null) { Resolvable resolvable = new ResolvableBuilder(facadeType, beanManager).addQualifiers(injectionPoint.getQualifiers()) .setDeclaringBean(injectionPoint.getBean()).create(); if (beanManager.getBeanResolver().resolve(resolvable, false).contains(bean)) { return true; } } } return false; }
@Override public Set<Bean<?>> getBeans(Type beanType, Annotation... qualifiers) { Resolvable resolvable = new ResolvableBuilder(beanType, this).addQualifiers(qualifiers).create(); return beanResolver.resolve(resolvable, isCacheable(qualifiers)); }
public void cleanup() { services.cleanup(); this.accessibleManagers.clear(); this.managers.clear(); this.beanResolver.clear(); this.enabledBeans.clear(); this.clientProxyProvider.clear(); this.contexts.clear(); this.decoratorResolver.clear(); this.decorators.clear(); this.enterpriseBeans.clear(); this.interceptorResolver.clear(); this.interceptors.clear(); this.nameBasedResolver.clear(); this.namespaces.clear(); this.accessibleLenientObserverNotifier.clear(); this.observers.clear(); }
protected void validateBeanName(String name, SetMultimap<String, Bean<?>> namedAccessibleBeans, List<String> accessibleNamespaces, BeanManagerImpl beanManager) { Set<Bean<?>> resolvedBeans = beanManager.getBeanResolver().<Object> resolve(Beans.removeDisabledBeans(namedAccessibleBeans.get(name), beanManager)); if (resolvedBeans.size() > 1) { throw ValidatorLogger.LOG.ambiguousElName(name, resolvedBeans); } if (accessibleNamespaces.contains(name)) { throw ValidatorLogger.LOG.beanNameIsPrefix(name); } }
public Set<Bean<?>> getBeans(InjectionPoint injectionPoint) { boolean registerInjectionPoint = isRegisterableInjectionPoint(injectionPoint); final ThreadLocalStackReference<InjectionPoint> stack = currentInjectionPoint.pushConditionally(injectionPoint, registerInjectionPoint); try { // We always cache, we assume that people don't use inline annotation literal declarations, a little risky but FAQd return beanResolver.resolve(new ResolvableBuilder(injectionPoint, this).create(), true); } finally { stack.pop(); } }
@SuppressWarnings({ "rawtypes", "unchecked" }) private static void doDefineNewManagedBean(BeanManagerImpl beanManager, String bdaId, Class<?> beanClass) { try { ClassTransformer classTransformer = getClassTransformer(); SlimAnnotatedType<?> annotatedType = classTransformer.getBackedAnnotatedType(beanClass, bdaId); boolean managedBeanOrDecorator = Beans.isTypeManagedBeanOrDecoratorOrInterceptor(annotatedType); if (managedBeanOrDecorator) { EnhancedAnnotatedType eat = EnhancedAnnotatedTypeImpl.of(annotatedType, classTransformer); BeanAttributes attributes = BeanAttributesFactory.forBean(eat, beanManager); ManagedBean<?> bean = ManagedBean.of(attributes, eat, beanManager); ReflectionHelper.set(beanManager, beanManager.getClass(), "beanSet", Collections.synchronizedSet(new HashSet<Bean<?>>())); beanManager.addBean(bean); beanManager.getBeanResolver().clear(); bean.initializeAfterBeanDiscovery(); LOGGER.debug("Bean defined '{}'", beanClass.getName()); } else { // TODO : define session bean LOGGER.warning("Bean NOT? defined '{}', session bean?", beanClass.getName()); } } catch (Exception e) { LOGGER.debug("Bean definition failed.", e); } }
public <T> Bean<T> getBean(Resolvable resolvable) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals Bean<T> bean = cast(resolve(beanResolver.resolve(resolvable, true))); if (bean == null) { throw BeanManagerLogger.LOG.unresolvableElement(resolvable); } return bean; }
public void endInitialization() { tracker.start(Tracker.OP_END_INIT); final BeanIdentifierIndex index = deploymentManager.getServices().get(BeanIdentifierIndex.class); if (index != null) { index.build(getBeansForBeanIdentifierIndex()); flushCaches(); deploymentManager.getServices().cleanupAfterBoot(); deploymentManager.cleanupAfterBoot(); for (BeanDeployment beanDeployment : getBeanDeployments()) { BeanManagerImpl beanManager = beanDeployment.getBeanManager(); beanManager.getInterceptorMetadataReader().cleanAfterBoot(); beanManager.getServices().cleanupAfterBoot(); beanManager.cleanupAfterBoot(); if (UnusedBeans.isEnabled(deploymentManager.getServices().get(WeldConfiguration.class))) { deploymentManager.getBeanResolver().clear(); for (BeanDeployment beanDeployment : getBeanDeployments()) { beanDeployment.getBeanManager().getBeanResolver().clear(); deploymentManager.getServices().get(Validator.class).clearResolved();
requiredType = Parsers.parseType(filterValues.get(REQUIRED_TYPE), beanManager.getServices().get(ResourceLoader.class)); } else { requiredType = Object.class; return getError("Invalid required type: parsing error or the type is not accessible from the specified bean archive!"); ResolvableBuilder resolvableBuilder = new ResolvableBuilder(requiredType, beanManager); qualifierInstances = Parsers.parseQualifiers(filterValues.get(QUALIFIERS), beanManager.getServices().get(ResourceLoader.class), beanManager); } else { qualifierInstances = Collections.singletonList(QualifierInstance.DEFAULT); return getError("Invalid qualifiers: parsing error or one of the qualifier types is not accessible from the specified bean archive!"); resolvableBuilder.addQualifierUnchecked(qualifierInstance); Resolvable resolvable = resolvableBuilder.create(); beans = beanManager.getBeanResolver().resolve(resolvable, false); if (Boolean.valueOf(filterValues.get(RESOLVE))) { beans = beanManager.getBeanResolver().resolve(beans);
this.beanResolver = new TypeSafeBeanResolver(this, createDynamicAccessibleIterable(beanTransform)); this.decoratorResolver = new TypeSafeDecoratorResolver(this, createDynamicGlobalIterable(BeanManagerImpl::getDecorators)); this.interceptorResolver = new TypeSafeInterceptorResolver(this, createDynamicGlobalIterable(BeanManagerImpl::getInterceptors)); this.nameBasedResolver = new NameBasedResolver(this, createDynamicAccessibleIterable(beanTransform)); this.weldELResolver = services.getOptional(ExpressionLanguageSupport.class).map(el -> el.createElResolver(this)).orElse(null); TypeSafeObserverResolver accessibleObserverResolver = new TypeSafeObserverResolver(getServices().get(MetaAnnotationStore.class), createDynamicAccessibleIterable(BeanManagerImpl::getObservers), getServices().get(WeldConfiguration.class)); this.accessibleLenientObserverNotifier = getServices().get(ObserverNotifierFactory.class).create(contextId, accessibleObserverResolver, getServices(), false);
private void flushCaches() { deploymentManager.getBeanResolver().clear(); deploymentManager.getAccessibleLenientObserverNotifier().clear(); deploymentManager.getGlobalStrictObserverNotifier().clear(); deploymentManager.getGlobalLenientObserverNotifier().clear(); deploymentManager.getDecoratorResolver().clear(); deploymentManager.getInterceptorResolver().clear(); deploymentManager.getNameBasedResolver().clear(); for (BeanDeployment beanDeployment : getBeanDeployments()) { BeanManagerImpl beanManager = beanDeployment.getBeanManager(); beanManager.getBeanResolver().clear(); beanManager.getAccessibleLenientObserverNotifier().clear(); beanManager.getDecoratorResolver().clear(); beanManager.getInterceptorResolver().clear(); beanManager.getNameBasedResolver().clear(); } }