How to use

getPayload

method

in

org.axonframework.eventhandling.DomainEventMessage

/**
 * Returns a {@link Predicate} for a {@link ConflictResolver} that responds affirmative if the payload of any event
 * in a list of unseen events is of given {@code payloadType} and matches the given {@code messageFilter}. If the
 * returned predicate matches an unseen event the ConflictResolver will throw an exception.
 *
 * @param payloadType   the type of event payload to filter for
 * @param payloadFilter predicate for the payload of a single event
 * @return a Predicate to detect conflicts in unseen aggregate events
 */
@SuppressWarnings("unchecked")
public static <T> Predicate<List<DomainEventMessage<?>>> payloadMatching(Class<T> payloadType,
                                  Predicate<? super T>
                                              payloadFilter) {
  return events -> events.stream().filter(event -> payloadType.isAssignableFrom(event.getPayloadType()))
      .map(event -> (T) event.getPayload()).anyMatch(payloadFilter::test);
}

@Test
@DirtiesContext
@SuppressWarnings({"unchecked", "OptionalGetWithoutIsPresent"})
public void testStoreAndLoadEventsWithUpcaster() {
  EventUpcaster mockUpcasterChain = mock(EventUpcaster.class);
  when(mockUpcasterChain.upcast(isA(Stream.class))).thenAnswer(invocation -> {
    Stream<?> inputStream = (Stream) invocation.getArguments()[0];
    return inputStream.flatMap(e -> Stream.of(e, e));
  });
  testSubject = createEngine(mockUpcasterChain);
  testSubject.appendEvents(createEvents(4));
  List<DomainEventMessage> upcastedEvents = testSubject.readEvents(AGGREGATE).asStream().collect(toList());
  assertEquals(8, upcastedEvents.size());
  Iterator<DomainEventMessage> iterator = upcastedEvents.iterator();
  while (iterator.hasNext()) {
    DomainEventMessage event1 = iterator.next(), event2 = iterator.next();
    assertEquals(event1.getAggregateIdentifier(), event2.getAggregateIdentifier());
    assertEquals(event1.getSequenceNumber(), event2.getSequenceNumber());
    assertEquals(event1.getPayload(), event2.getPayload());
    assertEquals(event1.getMetaData(), event2.getMetaData());
  }
}

@SuppressWarnings("unchecked")
@Override
public final T createAggregateRoot(String aggregateIdentifier, DomainEventMessage<?> firstEvent) {
  T aggregate;
  if (aggregateBaseType.isAssignableFrom(firstEvent.getPayloadType())) {
    aggregate = (T) firstEvent.getPayload();
  } else {
    aggregate = doCreateAggregate(aggregateIdentifier, firstEvent);
  }
  return postProcessInstance(aggregate);
}

@Test
public void testReturnedEventMessageBehavior() {
  testSubject.appendEvents(createEvent().withMetaData(singletonMap("key", "value")));
  DomainEventMessage<?> messageWithMetaData = testSubject.readEvents(AGGREGATE).next();
  /// we make sure persisted events have the same MetaData alteration logic
  DomainEventMessage<?> altered = messageWithMetaData.withMetaData(singletonMap("key2", "value"));
  DomainEventMessage<?> combined = messageWithMetaData.andMetaData(singletonMap("key2", "value"));
  assertTrue(altered.getMetaData().containsKey("key2"));
  altered.getPayload();
  assertFalse(altered.getMetaData().containsKey("key"));
  assertTrue(altered.getMetaData().containsKey("key2"));
  assertTrue(combined.getMetaData().containsKey("key"));
  assertTrue(combined.getMetaData().containsKey("key2"));
  assertNotNull(messageWithMetaData.getPayload());
  assertNotNull(messageWithMetaData.getMetaData());
  assertFalse(messageWithMetaData.getMetaData().isEmpty());
}

/**
 * Returns a {@link Predicate} for a {@link ConflictResolver} that responds affirmative if the payload of any event
 * in a list of unseen events is of given {@code payloadType} and matches the given {@code messageFilter}. If the
 * returned predicate matches an unseen event the ConflictResolver will throw an exception.
 *
 * @param payloadType   the type of event payload to filter for
 * @param payloadFilter predicate for the payload of a single event
 * @return a Predicate to detect conflicts in unseen aggregate events
 */
@SuppressWarnings("unchecked")
public static <T> Predicate<List<DomainEventMessage<?>>> payloadMatching(Class<T> payloadType,
                                  Predicate<? super T>
                                              payloadFilter) {
  return events -> events.stream().filter(event -> payloadType.isAssignableFrom(event.getPayloadType()))
      .map(event -> (T) event.getPayload()).anyMatch(payloadFilter::test);
}

while (storedEvents.hasNext()) {
  DomainEventMessage next = storedEvents.next();
  if (next.getPayload() instanceof CounterChangedEvent) {
    CounterChangedEvent event = (CounterChangedEvent) next.getPayload();
    assertEquals(event.getCounter(), next.getSequenceNumber());

@SuppressWarnings("unchecked")
@Override
public final T createAggregateRoot(String aggregateIdentifier, DomainEventMessage<?> firstEvent) {
  T aggregate;
  if (aggregateBaseType.isAssignableFrom(firstEvent.getPayloadType())) {
    aggregate = (T) firstEvent.getPayload();
  } else {
    aggregate = doCreateAggregate(aggregateIdentifier, firstEvent);
  }
  return postProcessInstance(aggregate);
}

if (next.getPayload() instanceof CounterChangedEvent) {
  CounterChangedEvent event = (CounterChangedEvent) next.getPayload();
  assertEquals(event.getCounter(), next.getSequenceNumber());