public void fire() { try { beanManager.getGlobalLenientObserverNotifier().fireEvent(getEventType(), this); } catch (Exception e) { getErrors().add(e); } }
public void fireEvent(Type eventType, Object event, EventMetadata metadata, Annotation... qualifiers) { checkEventObjectType(eventType); // we use the array of qualifiers for resolution so that we can catch duplicate qualifiers notify(resolveObserverMethods(buildEventResolvable(eventType, qualifiers)), event, metadata); }
@Override public ObserverNotifier create(String contextId, TypeSafeObserverResolver resolver, ServiceRegistry services, boolean strict) { return new ObserverNotifier(contextId, resolver, services, strict); } }
/** * Resolves observer methods based on the given event type and qualifiers. If strict checks are enabled the given type is verified. * * @param event the event object * @param qualifiers given event qualifiers * @return resolved observer methods */ public <T> ResolvedObservers<T> resolveObserverMethods(Type eventType, Annotation... qualifiers) { checkEventObjectType(eventType); return this.<T>resolveObserverMethods(buildEventResolvable(eventType, qualifiers)); }
/** * Delivers the given event object to observer methods resolved based on the given resolvable. If strict checks are enabled the event object type is * verified. * * @param event the given event object * @param resolvable */ public void fireEvent(Object event, Resolvable resolvable) { checkEventObjectType(event); notify(resolveObserverMethods(resolvable), event, null); }
private <T> void addContainerLifecycleEvent(T event, Object info, BeanManagerImpl beanManagerImpl) { ResolvedObservers<?> resolvedObservers = null; Type eventType = null; if (event instanceof AbstractContainerEvent) { AbstractContainerEvent containerEvent = (AbstractContainerEvent) event; eventType = containerEvent.getEventType(); resolvedObservers = beanManagerImpl.getGlobalLenientObserverNotifier().resolveObserverMethods(eventType); } else if (event instanceof ProcessAnnotatedTypeImpl) { ProcessAnnotatedTypeImpl<?> processAnnotatedTypeEvent = (ProcessAnnotatedTypeImpl<?>) event; eventType = ProcessAnnotatedType.class; info = Formats.formatType(processAnnotatedTypeEvent.getOriginalAnnotatedType().getBaseType(), false); resolvedObservers = beanManagerImpl.getGlobalLenientObserverNotifier().resolveObserverMethods( ProcessAnnotatedTypeEventResolvable.of(processAnnotatedTypeEvent, beanManagerImpl.getServices().get(RequiredAnnotationDiscovery.class))); } if (resolvedObservers != null && eventType != null) { probe.addEvent(new EventInfo(eventType, Collections.emptySet(), info, null, Reflections.cast(resolvedObservers.getAllObservers()), true, System.currentTimeMillis(), false)); } }
/** * Constructs a new FastEvent instance * @param type the event type * @param manager the bean manager * @param notifier the notifier to be used for observer method resolution * @param qualifiers the event qualifiers * @return */ public static <T> FastEvent<T> of(Class<T> type, BeanManagerImpl manager, ObserverNotifier notifier, Annotation... qualifiers) { ResolvedObservers<T> resolvedObserverMethods = notifier.<T> resolveObserverMethods(type, qualifiers); if (resolvedObserverMethods.isMetadataRequired()) { EventMetadata metadata = new EventMetadataImpl(type, null, qualifiers); CurrentEventMetadata metadataService = manager.getServices().get(CurrentEventMetadata.class); return new FastEventWithMetadataPropagation<T>(resolvedObserverMethods, metadata, metadataService); } else { return new FastEvent<T>(resolvedObserverMethods); } }
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(); } }
private List<ObserverMethod<?>> resolveObservers(EventMetadata metadata, boolean containerEvent) { List<ObserverMethod<?>> observers = new ArrayList<ObserverMethod<?>>(); final ObserverNotifier notifier = (containerEvent) ? manager.getAccessibleLenientObserverNotifier() : manager.getGlobalLenientObserverNotifier(); ResolvedObservers<?> resolvedObservers = notifier.resolveObserverMethods(metadata.getType(), metadata.getQualifiers()); for (ObserverMethod<?> observer : resolvedObservers.getAllObservers()) { // do not show ProbeObserver if (getBeanClass() != observer.getBeanClass()) { observers.add(observer); } } return ImmutableList.copyOf(observers); }
/** * Delivers the given synchronous event object to synchronous and transactional observer methods. Event metadata is made available for injection into * observer methods, if needed. Asynchronous observer methods are ignored. * * @param observers the given observer methods * @param event the given event object * @param metadata event metadata */ public <T> void notify(ResolvedObservers<T> observers, T event, EventMetadata metadata) { if (!observers.isMetadataRequired()) { metadata = null; } notifySyncObservers(observers.getImmediateSyncObservers(), event, metadata, ObserverExceptionHandler.IMMEDIATE_HANDLER); notifyTransactionObservers(observers.getTransactionObservers(), event, metadata, ObserverExceptionHandler.IMMEDIATE_HANDLER); }
final NotificationMode mode = initModeOption(options.get(WeldNotificationOptions.MODE)); final Long timeout = initTimeoutOption(options.get(WeldNotificationOptions.TIMEOUT)); final Consumer<Runnable> securityContextActionConsumer = securityServices.getSecurityContextAssociator(); final ObserverExceptionHandler exceptionHandler; List<CompletableFuture<T>> completableFutures = new ArrayList<>(observers.size()); for (ObserverMethod<? super T> observer : observers) { completableFutures.add(CompletableFuture.supplyAsync(createSupplier(securityContextActionConsumer, event, metadata, exceptionHandler, false, () -> { notifyAsyncObserver(observer, event, metadata, exceptionHandler); }), executor)); handleExceptions(exceptionHandler); return event; }); completableFuture = CompletableFuture.supplyAsync(createSupplier(securityContextActionConsumer, event, metadata, exceptionHandler, true, () -> { for (ObserverMethod<? super T> observer : observers) { notifyAsyncObserver(observer, event, metadata, exceptionHandler); completableFuture = CompletableFuture.anyOf(completableFuture, startTimer(timeout)).thenApply((ignoredObject) -> event);
/** * Fires a {@link ProcessAnnotatedType} or {@link ProcessSyntheticAnnotatedType} using the default event mechanism. */ private void fireProcessAnnotatedType(ProcessAnnotatedTypeImpl<?> event, BeanManagerImpl beanManager) { final Resolvable resolvable = ProcessAnnotatedTypeEventResolvable.of(event, discovery); try { beanManager.getGlobalLenientObserverNotifier().fireEvent(event, resolvable); } catch (Exception e) { throw new DefinitionException(e); } }
private CachedObservers createCachedObservers(Class<?> runtimeType) { final Type eventType = getEventType(runtimeType); // this performs type check final ResolvedObservers<T> observers = getBeanManager().getGlobalStrictObserverNotifier().resolveObserverMethods(eventType, getQualifiers()); final EventMetadata metadata = new EventMetadataImpl(eventType, getInjectionPoint(), getQualifiers()); return new CachedObservers(runtimeType, observers, metadata); }
/** * Delivers the given event object to given observer methods. Event metadata is made available for injection into observer methods, if needed. * * @param observers the given observer methods * @param event the given event object * @param metadata event metadata */ public <T> void notify(ResolvedObservers<T> observers, T event, EventMetadata metadata) { if (!observers.isMetadataRequired()) { metadata = null; } notifySyncObservers(observers.getImmediateObservers(), event, metadata); notifyTransactionObservers(observers.getTransactionObservers(), event, metadata); }
/** * Fire an event and notify observers that belong to this module. * @param eventType * @param event * @param qualifiers */ public void fireEvent(Type eventType, Object event, Annotation... qualifiers) { final EventMetadata metadata = new EventMetadataImpl(eventType, null, qualifiers); notifier.fireEvent(eventType, event, metadata, qualifiers); }
@Override public void fire(T event) { Preconditions.checkArgumentNotNull(event, EVENT_ARGUMENT_NAME); CachedObservers observers = getObservers(event); // we can do lenient here as the event type is checked within #getObservers() getBeanManager().getGlobalLenientObserverNotifier().notify(observers.observers, event, observers.metadata); }
/** * * @param resolver * @param services * @param strict indicates whether event type should be performed or not * @return ObserverNotifier instance */ public static ObserverNotifier of(String contextId, TypeSafeObserverResolver resolver, ServiceRegistry services, boolean strict) { if (services.contains(TransactionServices.class)) { return new TransactionalObserverNotifier(contextId, resolver, services, strict); } else { return new ObserverNotifier(resolver, services, strict); } }
@Override public <T> Set<ObserverMethod<? super T>> resolveObserverMethods(T event, Annotation... bindings) { return ImmutableSet.copyOf(globalStrictObserverNotifier.resolveObserverMethods(event.getClass(), bindings).getAllObservers()); }
protected <T> void notifyTransactionObservers(List<ObserverMethod<? super T>> observers, T event, EventMetadata metadata, ObserverExceptionHandler handler) { notifySyncObservers(observers, event, metadata, ObserverExceptionHandler.IMMEDIATE_HANDLER); // no transaction support }