@Override public ObserverMethodConfigurator<T> read(ObserverMethod observerMethod) { this.beanClass = observerMethod.getBeanClass(); this.qualifiers.addAll(observerMethod.getObservedQualifiers()); this.observedType = observerMethod.getObservedType(); this.reception = observerMethod.getReception(); this.transactionPhase = observerMethod.getTransactionPhase(); this.priority = observerMethod.getPriority(); this.async = observerMethod.isAsync(); return this; }
/** * Calls the observer method, passing the given event context. * <p> * The container should always call this method, but the default implementation delegates to {@link #notify(Object)}. * <p> * The implementation of this method for a custom observer method is responsible for deciding whether to call the method if * the {@link #getReception()} returns {@link Reception#IF_EXISTS}. * * @param eventContext {@link EventContext} used to notify observers */ public default void notify(EventContext<T> eventContext) { notify(eventContext.getEvent()); }
public ProcessObserverMethodImpl(BeanManagerImpl beanManager, AnnotatedMethod<X> beanMethod, ObserverMethod<T> observerMethod) { super(beanManager, ProcessObserverMethod.class, new Type[]{observerMethod.getObservedType(), observerMethod.getBeanClass()}); this.beanMethod = beanMethod; this.observerMethod = observerMethod; }
@Test @SpecAssertion(section = DEFAULT_BEAN_DISCOVERY_EE, id = "e") public void testObserverMethodDiscovered() { Set<ObserverMethod<? super Apple>> observers = beanManager.resolveObserverMethods(new Apple()); assertEquals(observers.size(), 1); assertEquals(observers.iterator().next().getBeanClass(), AppleTree.class); }
@Test @SpecAssertion(section = OBSERVER_METHOD, id = "c") public void testGetObservedQualifiersOnObserverMethod() { Set<ObserverMethod<? super StockPrice>> observers = getCurrentManager().resolveObserverMethods(new StockPrice()); assertEquals(observers.size(), 1); ObserverMethod<?> observerMethod = observers.iterator().next(); assertTrue(observerMethod.getObservedQualifiers().isEmpty()); }
@Test @SpecAssertion(section = OBSERVER_METHOD, id = "f") public void testNotifyOnObserverMethod() { Integer event = Integer.valueOf(1); Set<ObserverMethod<? super Integer>> observerMethods = getCurrentManager().resolveObserverMethods(event, new AnnotationLiteral<Number>() { }); assertEquals(observerMethods.size(), 1); observerMethods.iterator().next().notify(event); assertTrue(IntegerObserver.wasNotified); }
@Test @SpecAssertion(section = OBSERVER_METHOD, id = "c") public void testGetObservedTypeOnObserverMethod() { Set<ObserverMethod<? super StockPrice>> observers = getCurrentManager().resolveObserverMethods(new StockPrice()); assertEquals(observers.size(), 1); ObserverMethod<?> observerMethod = observers.iterator().next(); assertEquals(observerMethod.getObservedType(), StockPrice.class); }
@Test @SpecAssertion(section = OBSERVER_METHOD, id = "d") public void testGetNotifyOnObserverMethod() { Set<ObserverMethod<? super StockPrice>> observers = getCurrentManager().resolveObserverMethods(new StockPrice()); assertEquals(observers.size(), 1); assertEquals(observers.iterator().next().getReception(), Reception.ALWAYS); Set<ObserverMethod<? super ConditionalEvent>> conditionalObservers = getCurrentManager().resolveObserverMethods( new ConditionalEvent()); assertFalse(conditionalObservers.isEmpty()); assertEquals(conditionalObservers.iterator().next().getReception(), Reception.IF_EXISTS); }
@Test @SpecAssertion(section = OBSERVES, id = "ab") public void testSyncObserver() { Set<ObserverMethod<? super DiskSpaceEvent>> diskSpaceObservers = getCurrentManager().resolveObserverMethods(new DiskSpaceEvent()); assertTrue(diskSpaceObservers.stream().allMatch(method -> !method.isAsync())); }
@Test @SpecAssertion(section = PROCESS_OBSERVER_METHOD, id = "dab") public void configuratorInitializedWithOriginalObserverMethod() { ObserverMethod<? super Kiwi> configuredOne = getCurrentManager().resolveObserverMethods(new Kiwi(), Ripe.RipeLiteral.INSTANCE).iterator().next(); ObserverMethod<Kiwi> originalOne = getCurrentManager().getExtension(ProcessObserverMethodObserver.class).getOriginalOM(); assertEquals(configuredOne.getObservedType(), originalOne.getObservedType()); assertEquals(configuredOne.getObservedQualifiers(), originalOne.getObservedQualifiers()); assertEquals(configuredOne.getPriority(), originalOne.getPriority()); }
@Test @SpecAssertions({ @SpecAssertion(section = OBSERVER_METHOD_CONFIGURATOR, id = "be"), @SpecAssertion(section = OBSERVER_METHOD_CONFIGURATOR, id = "bf") }) public void setReceptionAndTransactionPhase() { Set<ObserverMethod<? super Orange>> orangeEventObservers = getCurrentManager() .resolveObserverMethods(new Orange(), Any.Literal.INSTANCE, Delicious.DeliciousLiteral.INSTANCE); assertEquals(orangeEventObservers.size(), 1); assertEquals(orangeEventObservers.iterator().next().getReception(), Reception.IF_EXISTS); assertEquals(orangeEventObservers.iterator().next().getTransactionPhase(), TransactionPhase.AFTER_SUCCESS); assertEquals(orangeEventObservers.iterator().next().getObservedQualifiers(), Collections.singleton(Delicious.DeliciousLiteral.INSTANCE)); }
@SuppressWarnings("serial") @Test @SpecAssertion(section = MEMBER_LEVEL_INHERITANCE, id = "g") public void testObserverResolution() throws Exception { Set<ObserverMethod<? super Qux>> observerMethods = getCurrentManager().resolveObserverMethods(new Qux(null)); assertEquals(observerMethods.size(), 1); ObserverMethod<? super Qux> observerMethod = observerMethods.iterator().next(); assertEquals(observerMethod.getBeanClass(), Foo.class); assertEquals(observerMethod.getObservedType(), new TypeLiteral<Baz<String>>() { }.getType()); }
@Test(groups = { "events" }) @SpecAssertion(section = "11.1.3", id = "e") public void testGetTransactionPhaseOnObserverMethod() { assert getCurrentManager().resolveObserverMethods(new StockPrice()).iterator().next().getTransactionPhase().equals(TransactionPhase.IN_PROGRESS); assert getCurrentManager().resolveObserverMethods(new DisobedientDog()).iterator().next().getTransactionPhase().equals(TransactionPhase.BEFORE_COMPLETION); assert getCurrentManager().resolveObserverMethods(new ShowDog()).iterator().next().getTransactionPhase().equals(TransactionPhase.AFTER_COMPLETION); assert getCurrentManager().resolveObserverMethods(new SmallDog()).iterator().next().getTransactionPhase().equals(TransactionPhase.AFTER_FAILURE); assert getCurrentManager().resolveObserverMethods(new LargeDog()).iterator().next().getTransactionPhase().equals(TransactionPhase.AFTER_SUCCESS); }
@Test @SpecAssertion(section = OBSERVER_METHOD, id = "e") public void testGetTransactionPhaseOnObserverMethod() { assertEquals(getCurrentManager().resolveObserverMethods(new StockPrice()).iterator().next().getTransactionPhase(), TransactionPhase.IN_PROGRESS); assertEquals(getCurrentManager().resolveObserverMethods(new DisobedientDog()).iterator().next().getTransactionPhase(), TransactionPhase.BEFORE_COMPLETION); assertEquals(getCurrentManager().resolveObserverMethods(new ShowDog()).iterator().next().getTransactionPhase(), TransactionPhase.AFTER_COMPLETION); assertEquals(getCurrentManager().resolveObserverMethods(new SmallDog()).iterator().next().getTransactionPhase(), TransactionPhase.AFTER_FAILURE); assertEquals(getCurrentManager().resolveObserverMethods(new LargeDog()).iterator().next().getTransactionPhase(), TransactionPhase.AFTER_SUCCESS); }
@Test @SpecAssertions({ @SpecAssertion(section = OBSERVER_METHOD_CONFIGURATOR, id = "bg"), @SpecAssertion(section = OBSERVER_METHOD_CONFIGURATOR, id = "bd"), @SpecAssertion(section = OBSERVER_METHOD_CONFIGURATOR, id = "bi") }) public void addQualifiersAndSetPriorityAndChangeToAsync() throws InterruptedException { Set<ObserverMethod<? super Pear>> pearEventObservers = getCurrentManager() .resolveObserverMethods(new Pear(), Any.Literal.INSTANCE, Ripe.RipeLiteral.INSTANCE, Delicious.DeliciousLiteral.INSTANCE); assertEquals(pearEventObservers.size(), 1); assertEquals(pearEventObservers.iterator().next().getPriority(), ObserverMethod.DEFAULT_PRIORITY + 100); assertEquals(pearEventObservers.iterator().next().isAsync(), true); assertEquals(pearEventObservers.iterator().next().getObservedQualifiers(), Stream.of(Ripe.RipeLiteral.INSTANCE, Delicious.DeliciousLiteral.INSTANCE).collect( Collectors.toSet())); BlockingQueue<Pear> queue = new LinkedBlockingQueue<>(); pearEvent.select(Any.Literal.INSTANCE, Ripe.RipeLiteral.INSTANCE, Delicious.DeliciousLiteral.INSTANCE).fireAsync(new Pear()).thenAccept(queue::offer); Pear pear = queue.poll(2, TimeUnit.SECONDS); assertNotNull(pear); assertTrue(FruitObserver.pearObserverNotified.get()); }
@Test @SpecAssertions({ @SpecAssertion(section = PROCESS_OBSERVER_METHOD, id = "ba"), @SpecAssertion(section = BEAN_DISCOVERY_STEPS, id = "kb") }) public void testGetObserverMethod() { Assert.assertEquals(ProcessObserverMethodObserver.getObserverMethod().getObservedType(), (EventA.class)); }
public static void validateObserverMethod(ObserverMethod<?> observerMethod, BeanManager beanManager) { Set<Annotation> qualifiers = observerMethod.getObservedQualifiers(); if (observerMethod.getBeanClass() == null) { throw EventLogger.LOG.observerMethodsMethodReturnsNull("getBeanClass", observerMethod); } if (observerMethod.getObservedType() == null) { throw EventLogger.LOG.observerMethodsMethodReturnsNull("getObservedType", observerMethod); } Bindings.validateQualifiers(qualifiers, beanManager, observerMethod, "ObserverMethod.getObservedQualifiers"); if (observerMethod.getReception() == null) { throw EventLogger.LOG.observerMethodsMethodReturnsNull("getReception", observerMethod); } if (observerMethod.getTransactionPhase() == null) { throw EventLogger.LOG.observerMethodsMethodReturnsNull("getTransactionPhase", observerMethod); } }
static JsonObjectBuilder createBasicObserverJson(ObserverMethod<?> observerMethod, Probe probe) { JsonObjectBuilder observerBuilder = createSimpleObserverJson(observerMethod, probe); observerBuilder.add(RECEPTION, observerMethod.getReception().toString()); observerBuilder.add(TX_PHASE, observerMethod.getTransactionPhase().toString()); if (!observerMethod.getObservedQualifiers().isEmpty()) { JsonArrayBuilder qualifiersBuilder = Json.arrayBuilder(); for (Annotation qualifier : observerMethod.getObservedQualifiers()) { qualifiersBuilder.add(qualifier.toString()); } observerBuilder.add(QUALIFIERS, qualifiersBuilder); } if (observerMethod instanceof ObserverMethodImpl) { ObserverMethodImpl<?, ?> observerMethodImpl = (ObserverMethodImpl<?, ?>) observerMethod; observerBuilder.add(DECLARING_BEAN, createSimpleBeanJson(observerMethodImpl.getDeclaringBean(), probe)); if (isUnrestrictedProcessAnnotatedTypeObserver(observerMethodImpl)) { observerBuilder.add(DESCRIPTION, WARNING_UNRESTRICTED_PAT_OBSERVER); } } return observerBuilder; }
@SuppressWarnings("unchecked") public static <T> ResolvedObservers<T> of(List<ObserverMethod<? super T>> observers) { if (observers.isEmpty()) { return (ResolvedObservers<T>) EMPTY; } boolean metadataRequired = false; List<ObserverMethod<? super T>> immediateSyncObservers = new ArrayList<ObserverMethod<? super T>>(); List<ObserverMethod<? super T>> transactionObservers = new ArrayList<ObserverMethod<? super T>>(); List<ObserverMethod<? super T>> asyncObservers = new ArrayList<ObserverMethod<? super T>>(); for (ObserverMethod<? super T> observer : observers) { if(observer.isAsync()) { asyncObservers.add(observer); } else if (TransactionPhase.IN_PROGRESS == observer.getTransactionPhase()) { immediateSyncObservers.add(observer); } else { transactionObservers.add(observer); } if (!metadataRequired && Observers.isEventMetadataRequired(observer)) { metadataRequired = true; } } return new ResolvedObservers<>(copyOf(immediateSyncObservers), copyOf(asyncObservers), copyOf(transactionObservers), metadataRequired); }
@Override public void registerTransactionSynchronization(final TransactionPhase phase, final ObserverMethod<? super Object> observer, final Object event) throws Exception { Set<Annotation> qualifiers = observer.getObservedQualifiers(); if (qualifiers == null) { qualifiers = Collections.emptySet(); } TransactionalEventNotifier.registerTransactionSynchronization(phase, observer, event, new EventMetadataImpl(observer.getObservedType(), null, null, qualifiers.toArray(new Annotation[qualifiers.size()]), webBeansContext)); } }