Refine search
BeanDeploymentModule(String moduleId, String contextId, boolean web, ServiceRegistry services) { this.id = moduleId; this.web = web; this.managers = new CopyOnWriteArraySet<>(); // create module-local observer notifier Iterable<ObserverMethod<?>> observers = flatMap(managers, BeanManagerImpl::getObservers); final TypeSafeObserverResolver resolver = new TypeSafeObserverResolver(services.get(MetaAnnotationStore.class), observers, services.get(WeldConfiguration.class)); this.notifier = DefaultObserverNotifierFactory.INSTANCE.create(contextId, resolver, services, false); }
/** * Clears cached observer method resolutions and event type checks. */ public void clear() { resolver.clear(); if (eventTypeCheckCache != null) { eventTypeCheckCache.clear(); } }
/** * Resolves observer methods using the given resolvable. * * @param resolvable the given resolvable * @return resolved observer methods */ public <T> ResolvedObservers<T> resolveObserverMethods(Resolvable resolvable) { return cast(resolver.resolve(resolvable, true)); }
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); this.currentInjectionPoint = getServices().get(CurrentInjectionPoint.class); this.clientProxyOptimization = getServices().get(WeldConfiguration.class).getBooleanProperty(ConfigurationKey.INJECTABLE_REFERENCE_OPTIMIZATION); this.requestInitializedEvent = LazyValueHolder.forSupplier(() -> FastEvent.of(Object.class, this, Initialized.Literal.REQUEST)); this.requestBeforeDestroyedEvent = LazyValueHolder.forSupplier(() -> FastEvent.of(Object.class, this, BeforeDestroyed.Literal.REQUEST)); this.requestDestroyedEvent = LazyValueHolder.forSupplier(() -> FastEvent.of(Object.class, this, Destroyed.Literal.REQUEST));
protected Resolvable buildEventResolvable(Type eventType, Annotation... qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(sharedObjectCache.getTypeClosureHolder(eventType).get()).addType(Object.class) .addQualifiers(qualifiers).addQualifierUnchecked(QualifierInstance.ANY).create(); }
@Override protected boolean matches(Resolvable resolvable, ObserverMethod<?> observer) { if (!rules.matches(observer.getObservedType(), resolvable.getTypes())) { return false; } if (!Beans.containsAllQualifiers(QualifierInstance.of(observer.getObservedQualifiers(), metaAnnotationStore), resolvable.getQualifiers())) { return false; } if (observer instanceof ContainerLifecycleEventObserverMethod) { ContainerLifecycleEventObserverMethod<?> lifecycleObserver = (ContainerLifecycleEventObserverMethod<?>) observer; if (resolvable instanceof ProcessAnnotatedTypeEventResolvable && !lifecycleObserver.getRequiredAnnotations().isEmpty()) { // this is a ProcessAnnotatedType observer method with @WithAnnotations and a resolvable for ProcessAnnotatedType ProcessAnnotatedTypeEventResolvable patResolvable = (ProcessAnnotatedTypeEventResolvable) resolvable; return patResolvable.containsRequiredAnnotations(lifecycleObserver.getRequiredAnnotations()); } } else { return !isContainerLifecycleEvent(resolvable); // container lifecycle events are only delivered to extensions } return true; }
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); this.currentInjectionPoint = getServices().get(CurrentInjectionPoint.class); this.clientProxyOptimization = getServices().get(WeldConfiguration.class).getBooleanProperty(ConfigurationKey.INJECTABLE_REFERENCE_OPTIMIZATION); this.requestInitializedEvent = LazyValueHolder.forSupplier(() -> FastEvent.of(Object.class, this, Initialized.Literal.REQUEST)); this.requestBeforeDestroyedEvent = LazyValueHolder.forSupplier(() -> FastEvent.of(Object.class, this, BeforeDestroyed.Literal.REQUEST)); this.requestDestroyedEvent = LazyValueHolder.forSupplier(() -> FastEvent.of(Object.class, this, Destroyed.Literal.REQUEST));
protected Resolvable buildEventResolvable(Type eventType, Set<Annotation> qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals Set<Type> typeClosure = sharedObjectCache.getTypeClosureHolder(eventType).get(); return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(typeClosure).addType(Object.class).addQualifiers(qualifiers) .addQualifierUnchecked(QualifierInstance.ANY).create(); }
@Override protected boolean matches(Resolvable resolvable, ObserverMethod<?> observer) { if (!rules.matches(observer.getObservedType(), resolvable.getTypes())) { return false; } if (!Beans.containsAllQualifiers(QualifierInstance.of(observer.getObservedQualifiers(), metaAnnotationStore), resolvable.getQualifiers())) { return false; } if (observer instanceof ContainerLifecycleEventObserverMethod) { ContainerLifecycleEventObserverMethod<?> lifecycleObserver = (ContainerLifecycleEventObserverMethod<?>) observer; if (resolvable instanceof ProcessAnnotatedTypeEventResolvable && !lifecycleObserver.getRequiredAnnotations().isEmpty()) { // this is a ProcessAnnotatedType observer method with @WithAnnotations and a resolvable for ProcessAnnotatedType ProcessAnnotatedTypeEventResolvable patResolvable = (ProcessAnnotatedTypeEventResolvable) resolvable; return patResolvable.containsRequiredAnnotations(lifecycleObserver.getRequiredAnnotations()); } } else { return !isContainerLifecycleEvent(resolvable); // container lifecycle events are only delivered to extensions } return true; }
BeanDeploymentModule(String moduleId, String contextId, boolean web, ServiceRegistry services) { this.id = moduleId; this.web = web; this.managers = new CopyOnWriteArraySet<>(); // create module-local observer notifier Iterable<ObserverMethod<?>> observers = flatMap(managers, BeanManagerImpl::getObservers); final TypeSafeObserverResolver resolver = new TypeSafeObserverResolver(services.get(MetaAnnotationStore.class), observers, services.get(WeldConfiguration.class)); this.notifier = DefaultObserverNotifierFactory.INSTANCE.create(contextId, resolver, services, false); }
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); this.currentInjectionPoint = getServices().get(CurrentInjectionPoint.class); this.clientProxyOptimization = getServices().get(WeldConfiguration.class).getBooleanProperty(ConfigurationKey.INJECTABLE_REFERENCE_OPTIMIZATION); this.requestInitializedEvent = LazyValueHolder.forSupplier(() -> FastEvent.of(Object.class, this, Initialized.Literal.REQUEST)); this.requestBeforeDestroyedEvent = LazyValueHolder.forSupplier(() -> FastEvent.of(Object.class, this, BeforeDestroyed.Literal.REQUEST)); this.requestDestroyedEvent = LazyValueHolder.forSupplier(() -> FastEvent.of(Object.class, this, Destroyed.Literal.REQUEST));
protected Resolvable buildEventResolvable(Type eventType, Annotation... qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(sharedObjectCache.getTypeClosureHolder(eventType).get()).addType(Object.class) .addQualifiers(qualifiers).addQualifierUnchecked(QualifierInstance.ANY).create(); }
/** * Resolves observer methods using the given resolvable. * * @param resolvable the given resolvable * @return resolved observer methods */ public <T> ResolvedObservers<T> resolveObserverMethods(Resolvable resolvable) { return cast(resolver.resolve(resolvable, true)); }
/** * Clears cached observer method resolutions and event type checks. */ public void clear() { resolver.clear(); if (eventTypeCheckCache != null) { eventTypeCheckCache.clear(); } }
@Override protected boolean matches(Resolvable resolvable, ObserverMethod<?> observer) { if (!rules.matches(observer.getObservedType(), resolvable.getTypes())) { return false; } if (!Beans.containsAllQualifiers(QualifierInstance.of(observer.getObservedQualifiers(), metaAnnotationStore), resolvable.getQualifiers())) { return false; } if (observer instanceof ContainerLifecycleEventObserverMethod) { ContainerLifecycleEventObserverMethod<?> lifecycleObserver = (ContainerLifecycleEventObserverMethod<?>) observer; if (resolvable instanceof ProcessAnnotatedTypeEventResolvable && !lifecycleObserver.getRequiredAnnotations().isEmpty()) { // this is a ProcessAnnotatedType observer method with @WithAnnotations and a resolvable for ProcessAnnotatedType ProcessAnnotatedTypeEventResolvable patResolvable = (ProcessAnnotatedTypeEventResolvable) resolvable; return patResolvable.containsRequiredAnnotations(lifecycleObserver.getRequiredAnnotations()); } } else { return !isContainerLifecycleEvent(resolvable); // container lifecycle events are only delivered to extensions } return true; }
BeanDeploymentModule(String moduleId, String contextId, boolean web, ServiceRegistry services) { this.id = moduleId; this.web = web; this.managers = new CopyOnWriteArraySet<>(); // create module-local observer notifier Iterable<ObserverMethod<?>> observers = flatMap(managers, Transform.OBSERVER); final TypeSafeObserverResolver resolver = new TypeSafeObserverResolver(services.get(MetaAnnotationStore.class), observers, services.get(WeldConfiguration.class)); this.notifier = ObserverNotifier.of(contextId, resolver, services, false); }
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); this.currentInjectionPoint = getServices().get(CurrentInjectionPoint.class); this.clientProxyOptimization = getServices().get(WeldConfiguration.class).getBooleanProperty(ConfigurationKey.INJECTABLE_REFERENCE_OPTIMIZATION); this.requestInitializedEvent = LazyValueHolder.forSupplier(() -> FastEvent.of(Object.class, this, Initialized.Literal.REQUEST)); this.requestBeforeDestroyedEvent = LazyValueHolder.forSupplier(() -> FastEvent.of(Object.class, this, BeforeDestroyed.Literal.REQUEST)); this.requestDestroyedEvent = LazyValueHolder.forSupplier(() -> FastEvent.of(Object.class, this, Destroyed.Literal.REQUEST));
protected Resolvable buildEventResolvable(Type eventType, Set<Annotation> qualifiers) { // We can always cache as this is only ever called by Weld where we avoid non-static inner classes for annotation literals Set<Type> typeClosure = sharedObjectCache.getTypeClosureHolder(eventType).get(); return new ResolvableBuilder(resolver.getMetaAnnotationStore()).addTypes(typeClosure).addType(Object.class).addQualifiers(qualifiers) .addQualifierUnchecked(QualifierInstance.ANY).create(); }
/** * Resolves observer methods using the given resolvable. * * @param resolvable the given resolvable * @return resolved observer methods */ public <T> ResolvedObservers<T> resolveObserverMethods(Resolvable resolvable) { return cast(resolver.resolve(resolvable, true)); }
/** * Clears cached observer method resolutions and event type checks. */ public void clear() { resolver.clear(); if (eventTypeCheckCache != null) { eventTypeCheckCache.clear(); } }