/** * Initializes a {@link SimpleEventHandlerInvoker} as specified through this Builder. * * @return a {@link SimpleEventHandlerInvoker} as specified through this Builder */ public SimpleEventHandlerInvoker build() { return new SimpleEventHandlerInvoker(this); }
String processorName = processorNameForProcessingGroup(processingGroup); handlerInvokers.computeIfAbsent(processorName, k -> new ArrayList<>()).add( c -> SimpleEventHandlerInvoker.builder() .eventHandlers(handlers) .parameterResolverFactory(configuration.parameterResolverFactory())
@Override public boolean canHandle(EventMessage<?> eventMessage, Segment segment) { return hasHandler(eventMessage) && segment.matches(Objects.hashCode(getOrDefault( sequencingPolicy.getSequenceIdentifierFor(eventMessage), eventMessage::getIdentifier) )); }
/** * Initializes a {@link SimpleEventHandlerInvoker} containing one or more {@code eventListeners}. If an event * listener is assignable to {@link EventListener} it will registered as is. If not, it will be wrapped by a new * {@link AnnotationEventListenerAdapter}. * <p> * Events handled by the invoker will be passed to all the given {@code eventListeners}. If an exception is * triggered during event handling it will be logged using a {@link LoggingErrorHandler} but otherwise * ignored. * <p> * When this invoker is invoked for multiple Segments (i.e. using parallel processing), events from the same * Aggregate are guaranteed to be processed in sequence (see {@link SequentialPerAggregatePolicy}). * * @param eventListeners one or more event listeners to register with this invoker */ public SimpleEventHandlerInvoker(Object... eventListeners) { this(detectList(eventListeners), new LoggingErrorHandler()); }
/** * Builds the event processor. It uses deprecated {@code eventProcessorBuilder} and extracts event listeners from * {@code eventHandlerInvoker} with an assumption that all of them are {@link SimpleEventHandlerInvoker}s. This * method is only for backward compatibility purposes. * * @param processorName name of the processor * @param config axon configuration * @param eventHandlerInvoker multi event handler invoker. Assumption is that all invokers which this one contains * are of {@link SimpleEventHandlerInvoker} type * @param eventProcessorBuilder backward compatible event processor builder * @return event processor */ private EventProcessor buildEventProcessor(String processorName, Configuration config, MultiEventHandlerInvoker eventHandlerInvoker, EventProcessorBuilder eventProcessorBuilder) { return eventProcessorBuilder .createEventProcessor(config, processorName, eventHandlerInvoker .delegates() .stream() .map(i -> ((SimpleEventHandlerInvoker) i).eventListeners()) .flatMap(Collection::stream) .collect(Collectors.toList())); }
/** * Initializes a {@link SimpleEventHandlerInvoker} as specified through this Builder. * * @return a {@link SimpleEventHandlerInvoker} as specified through this Builder */ public SimpleEventHandlerInvoker build() { return new SimpleEventHandlerInvoker(this); }
when(mockHandler.canHandle(any())).thenReturn(true); when(mockHandler.supportsReset()).thenReturn(true); eventHandlerInvoker = Mockito.spy(SimpleEventHandlerInvoker.builder().eventHandlers(mockHandler).build()); mockTransaction = mock(Transaction.class); mockTransactionManager = mock(TransactionManager.class);
@Override public boolean canHandle(EventMessage<?> eventMessage, Segment segment) { return hasHandler(eventMessage) && segment.matches(Objects.hashCode(getOrDefault( sequencingPolicy.getSequenceIdentifierFor(eventMessage), eventMessage::getIdentifier) )); }
@Bean public EventProcessor externalListenersEventProcessor() { SubscribingEventProcessor eventProcessor = new SubscribingEventProcessor("externalListenersEventProcessor", new SimpleEventHandlerInvoker(executedTradesBroadcaster), eventStore); eventProcessor.start(); return eventProcessor; }
@Before public void setUp() { tokenStore = spy(new InMemoryTokenStore()); mockHandler = mock(EventMessageHandler.class); when(mockHandler.canHandle(any())).thenReturn(true); eventHandlerInvoker = SimpleEventHandlerInvoker.builder() .eventHandlers(singletonList(mockHandler)) .sequencingPolicy(event -> { if (event instanceof DomainEventMessage) { return ((DomainEventMessage) event) .getSequenceNumber(); } return event.getIdentifier(); }) .build(); eventBus = EmbeddedEventStore.builder().storageEngine(new InMemoryEventStorageEngine()).build(); // A processor config, with a policy which guarantees segmenting by using the sequence number. configureProcessor(TrackingEventProcessorConfiguration.forParallelProcessing(2)); }
@Override public boolean canHandle(EventMessage<?> eventMessage, Segment segment) { return hasHandler(eventMessage) && segment.matches(Objects.hashCode(getOrDefault(sequencingPolicy.getSequenceIdentifierFor(eventMessage), eventMessage::getIdentifier))); }
@Override public void initialize(Configuration config) { selectors.sort(comparing(ProcessorSelector::getPriority).reversed()); this.config = config; Map<String, List<Object>> assignments = new HashMap<>(); eventHandlers.stream().map(Component::get).forEach(handler -> { String processor = selectors.stream().map(s -> s.select(handler)).filter(Optional::isPresent).map(Optional::get) .findFirst() .orElseGet(() -> defaultSelector.select(handler).orElseThrow(IllegalStateException::new)); assignments.computeIfAbsent(processor, k -> new ArrayList<>()).add(handler); }); onInit.forEach(h -> h.accept(config)); assignments.forEach((name, handlers) -> { config.eventProcessingConfiguration().registerHandlerInvoker(name, c -> new SimpleEventHandlerInvoker(handlers, c.parameterResolverFactory(), getListenerInvocationErrorHandler(c, name), getSequencingPolicy(c, name))); if (eventProcessorBuilders.containsKey(name)) { eventProcessorBuilders.get(name).accept(config, handlers); } interceptorsFor(config, name).forEach(i -> config.eventProcessingConfiguration() .registerHandlerInterceptor(name, c -> i)); }); }
SimpleEventHandlerInvoker.builder() .eventHandlers( (EventMessageHandler) eventHandler -> {
private EventProcessor buildTrackingEventProcessor(Configuration conf, String name, List<?> handlers, Function<Configuration, TrackingEventProcessorConfiguration> config, Function<Configuration, StreamableMessageSource<TrackedEventMessage<?>>> source, Function<Configuration, SequencingPolicy<? super EventMessage<?>>> sequencingPolicy) { return new TrackingEventProcessor(name, new SimpleEventHandlerInvoker(handlers, conf.parameterResolverFactory(), getListenerInvocationErrorHandler(conf, name), sequencingPolicy.apply(conf)), source.apply(conf), tokenStore.getOrDefault( name, c -> c.getComponent(TokenStore.class, InMemoryTokenStore::new) ).apply(conf), conf.getComponent(TransactionManager.class, NoTransactionManager::instance), getMessageMonitor(conf, EventProcessor.class, name), RollbackConfigurationType.ANY_THROWABLE, getErrorHandler(conf, name), config.apply(conf)); }
@Before public void setUp() { mockHandler = mock(EventMessageHandler.class); eventHandlerInvoker = SimpleEventHandlerInvoker.builder().eventHandlers(mockHandler).build(); eventBus = EmbeddedEventStore.builder().storageEngine(new InMemoryEventStorageEngine()).build(); testSubject = SubscribingEventProcessor.builder() .name("test") .eventHandlerInvoker(eventHandlerInvoker) .messageSource(eventBus) .build(); }
@Before public void setUp() { SimpleEventHandlerInvoker eventHandlerInvoker = SimpleEventHandlerInvoker.builder() .eventHandlers(this) .build(); eventProcessor = SubscribingEventProcessor.builder() .name("test") .eventHandlerInvoker(eventHandlerInvoker) .messageSource(eventBus) .build(); eventProcessor.start(); }
}; SimpleEventHandlerInvoker eventHandlerInvoker = SimpleEventHandlerInvoker.builder() .eventHandlers(eventHandler) .listenerInvocationErrorHandler(PropagatingErrorHandler.INSTANCE)
SimpleEventHandlerInvoker eventHandlerInvoker = SimpleEventHandlerInvoker.builder() .eventHandlers(eventHandler) .build();
String processorName = processorNameForProcessingGroup(processingGroup); handlerInvokers.computeIfAbsent(processorName, k -> new ArrayList<>()).add( c -> SimpleEventHandlerInvoker.builder() .eventHandlers(handlers) .parameterResolverFactory(configuration.parameterResolverFactory())