@Override public EventMessage getEvent() { return new GenericEventMessage<>(event, () -> scheduleTime); }
@Override protected <T> ApplyMore doApply(T payload, MetaData metaData) { appliedMessages.add(new GenericEventMessage<>(payload, metaData)); return new ApplyMore() { @Override public ApplyMore andThenApply(Supplier<?> payloadOrMessageSupplier) { appliedMessages.add(GenericEventMessage.asEventMessage(payloadOrMessageSupplier.get())); return this; } @Override public ApplyMore andThen(Runnable runnable) { runnable.run(); return this; } }; }
/** * Creates a new message for the scheduled event. This ensures that a new identifier and timestamp will always * be generated, so that the timestamp will reflect the actual moment the trigger occurred. * * @return the message to publish */ private EventMessage<?> createMessage() { EventMessage<?> eventMessage; if (event instanceof EventMessage) { eventMessage = new GenericEventMessage<>(((EventMessage) event).getPayload(), ((EventMessage) event).getMetaData()); } else { eventMessage = new GenericEventMessage<>(event, MetaData.emptyInstance()); } return eventMessage; } }
/** * Creates a new message for the scheduled event. This ensures that a new identifier and timestamp will always * be generated, so that the timestamp will reflect the actual moment the trigger occurred. * * @param event The actual event (either a payload or an entire message) to create the message from * @return the message to publish */ private EventMessage<?> createMessage(Object event) { EventMessage<?> eventMessage; if (event instanceof EventMessage) { eventMessage = new GenericEventMessage<>(((EventMessage) event).getPayload(), ((EventMessage) event).getMetaData()); } else { eventMessage = new GenericEventMessage<>(event, MetaData.emptyInstance()); } return eventMessage; } }
/** * Returns the given event as an EventMessage. If {@code event} already implements EventMessage, it is * returned as-is. If it is a Message, a new EventMessage will be created using the payload and meta data of the * given message. Otherwise, the given {@code event} is wrapped into a GenericEventMessage as its payload. * * @param event the event to wrap as EventMessage * @param <T> The generic type of the expected payload of the resulting object * @return an EventMessage containing given {@code event} as payload, or {@code event} if it already implements * EventMessage. */ @SuppressWarnings("unchecked") public static <T> EventMessage<T> asEventMessage(Object event) { if (EventMessage.class.isInstance(event)) { return (EventMessage<T>) event; } else if (event instanceof Message) { Message message = (Message) event; return new GenericEventMessage<>(message, clock.instant()); } return new GenericEventMessage<>(new GenericMessage<>((T) event), clock.instant()); }
@Override public GenericEventMessage<T> andMetaData(Map<String, ?> metaData) { if (metaData == null || metaData.isEmpty() || getMetaData().equals(metaData)) { return this; } return new GenericEventMessage<>(getDelegate().andMetaData(metaData), timestampSupplier); }
@Override public <T> EventMessage<T> convertFromInboundMessage(Message<T> message) { MessageHeaders headers = message.getHeaders(); Map<String, ?> metaData = headers.entrySet() .stream() .filter(entry -> !entry.getKey().startsWith(AXON_MESSAGE_PREFIX)) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); String messageId = Objects.toString(headers.get(MESSAGE_ID)); Long timestamp = headers.getTimestamp(); org.axonframework.messaging.GenericMessage<T> genericMessage = new org.axonframework.messaging.GenericMessage<>(messageId, message.getPayload(), metaData); if (headers.containsKey(AGGREGATE_ID)) { return new GenericDomainEventMessage<>(Objects.toString(headers.get(AGGREGATE_TYPE)), Objects.toString(headers.get(AGGREGATE_ID)), NumberUtils.convertNumberToTargetClass(headers.get(AGGREGATE_SEQ, Number.class), Long.class), genericMessage, () -> Instant.ofEpochMilli(timestamp)); } else { return new GenericEventMessage<>(genericMessage, () -> Instant.ofEpochMilli(timestamp)); } }
private Object readResolve() { return new org.axonframework.eventhandling.GenericEventMessage<>(getIdentifier(), getPayload(), MetaData.from(getMetaData().getValues()), Instant.ofEpochMilli(timestamp.getMillis())); } }
@Override public GenericEventMessage<T> withMetaData(Map<String, ?> metaData) { if (getMetaData().equals(metaData)) { return this; } return new GenericEventMessage<>(getDelegate().withMetaData(metaData), timestampSupplier); }
/** * <b>Note</b> that this function is able to retrieve an Event Message in two formats. The first is the * original, deprecated approach, which uses the Quartz serializer (read Java serialization) to serialize an * entire event message at once. The second approach uses the configurable {@link Serializer} in this class to * serialized the payload and metadata of an event message. All fields which required to instantiate a * {@link GenericEventMessage} are currently stored in the {@code jobDataMap} when calling the * {@link DirectEventJobDataBinder#toJobData(Object)} function. * Approach one only exists for backwards compatibility and should be removed in subsequent major releases. * <p> * {@inheritDoc} */ @Override public Object fromJobData(JobDataMap jobDataMap) { if (jobDataMap.containsKey(SERIALIZED_MESSAGE_PAYLOAD)) { return new GenericEventMessage<>((String) jobDataMap.get(MESSAGE_ID), deserializePayload(jobDataMap), deserializeMetaData(jobDataMap), retrieveDeadlineTimestamp(jobDataMap)); } return fromJobDataMap(jobDataMap); }
private EventMessage<Object> timeCorrectedEventMessage(Object event) { EventMessage<?> msg = GenericEventMessage.asEventMessage(event); return new GenericEventMessage<>(msg.getIdentifier(), msg.getPayload(), msg.getMetaData(), currentTime()); }
/** * Creates an {@link EventMessage} with given {@code payload} and {@code metaData}. * * @param payload payload of the resulting message * @param metaData metadata of the resulting message * @param <P> the payload type * @return the resulting message */ protected <P> EventMessage<P> createMessage(P payload, MetaData metaData) { if (lastKnownSequence != null) { long seq = lastKnownSequence + 1; String id = identifierAsString(); if (id == null) { Assert.state(seq == 0, () -> "The aggregate identifier has not been set. It must be set at the latest when applying the creation event"); return new LazyIdentifierDomainEventMessage<>(type(), seq, payload, metaData); } return new GenericDomainEventMessage<>(type(), identifierAsString(), seq, payload, metaData); } return new GenericEventMessage<>(payload, metaData); }
@Test public void testStoreAndLoadApplicationEvent() { testSubject.appendEvents(new GenericEventMessage<>("application event", MetaData.with("key", "value"))); assertEquals(1, testSubject.readEvents(null, false).count()); EventMessage<?> message = testSubject.readEvents(null, false).findFirst().get(); assertEquals("application event", message.getPayload()); assertEquals(MetaData.with("key", "value"), message.getMetaData()); }
@CommandHandler public void handleStubAggregateUpdatedWithExtraEvent(UpdateStubAggregateWithExtraEventCommand command, UnitOfWork<CommandMessage<?>> unitOfWork) { Aggregate<StubAggregate> aggregate = repository.load(command.getAggregateId().toString()); aggregate.execute(StubAggregate::makeAChange); eventBus.publish(new GenericEventMessage<>(new MyEvent())); aggregate.execute(StubAggregate::makeAChange); }
private Optional<EventMessage<?>> event(SerializedMessage<?> message, long timestamp) { return Optional.of(new GenericEventMessage<>(message, () -> Instant.ofEpochMilli(timestamp))); } }
private Optional<EventMessage<?>> event(SerializedMessage<?> message, long timestamp) { return Optional.of(new GenericEventMessage<>(message, () -> Instant.ofEpochMilli(timestamp))); }
@Override public GenericEventMessage<T> andMetaData(Map<String, ?> metaData) { if (metaData == null || metaData.isEmpty() || getMetaData().equals(metaData)) { return this; } return new GenericEventMessage<>(getDelegate().andMetaData(metaData), timestampSupplier); }
@Override public GenericEventMessage<T> andMetaData(Map<String, ?> metaData) { if (metaData == null || metaData.isEmpty() || getMetaData().equals(metaData)) { return this; } return new GenericEventMessage<>(getDelegate().andMetaData(metaData), timestampSupplier); }
@Override public GenericEventMessage<T> withMetaData(Map<String, ?> metaData) { if (getMetaData().equals(metaData)) { return this; } return new GenericEventMessage<>(getDelegate().withMetaData(metaData), timestampSupplier); }
@Override public GenericEventMessage<T> withMetaData(Map<String, ?> metaData) { if (getMetaData().equals(metaData)) { return this; } return new GenericEventMessage<>(getDelegate().withMetaData(metaData), timestampSupplier); }