@Override public DomainEventMessage<?> peek() { if (!hasNext()) { return null; } return delegate.peek(); }
@Override public DomainEventMessage<?> peek() { if (!hasNext()) { return null; } return streams.peekFirst().peek(); }
@Override public boolean hasNext() { // check if there is anything to read if (!delegate.hasNext()) { return false; } DomainEventMessage<?> peeked = delegate.peek(); while (!filter.test(peeked)) { // consume delegate.next(); if (delegate.hasNext()) { peeked = delegate.peek(); } else { return false; } } return delegate.hasNext(); }
@Override public void run() { DomainEventStream eventStream = eventStore.readEvents(identifier); // a snapshot should only be stored if the snapshot replaces at least more than one event long firstEventSequenceNumber = eventStream.peek().getSequenceNumber(); DomainEventMessage snapshotEvent = createSnapshot(aggregateType, identifier, eventStream); if (snapshotEvent != null && snapshotEvent.getSequenceNumber() > firstEventSequenceNumber) { eventStore.storeSnapshot(snapshotEvent); } } }
@SuppressWarnings("unchecked") @Override protected DomainEventMessage createSnapshot(Class<?> aggregateType, String aggregateIdentifier, DomainEventStream eventStream) { DomainEventMessage firstEvent = eventStream.peek(); AggregateFactory<?> aggregateFactory = getAggregateFactory(aggregateType); if (aggregateFactory == null) { throw new IllegalArgumentException( "Aggregate Type is unknown in this snapshotter: " + aggregateType.getName() ); } aggregateModels.computeIfAbsent(aggregateType, k -> AnnotatedAggregateMetaModelFactory .inspectAggregate(k, parameterResolverFactory, handlerDefinition)); Object aggregateRoot = aggregateFactory.createAggregateRoot(aggregateIdentifier, firstEvent); SnapshotAggregate<Object> aggregate = new SnapshotAggregate(aggregateRoot, aggregateModels.get(aggregateType), repositoryProvider); aggregate.initializeState(eventStream); if (aggregate.isDeleted()) { return null; } return new GenericDomainEventMessage<>(aggregate.type(), aggregate.identifierAsString(), aggregate.version(), aggregate.getAggregateRoot()); }
aggregateIdentifier, eventStream.peek()), model, eventStore, repositoryProvider, trigger );
/** * Perform the actual loading of an aggregate. The necessary locks have been obtained. * * @param aggregateIdentifier the identifier of the aggregate to load * @param expectedVersion The expected version of the loaded aggregate * @return the fully initialized aggregate * * @throws AggregateDeletedException in case an aggregate existed in the past, but has been deleted * @throws AggregateNotFoundException when an aggregate with the given identifier does not exist */ @Override protected EventSourcedAggregate<T> doLoadWithLock(String aggregateIdentifier, Long expectedVersion) { DomainEventStream eventStream = readEvents(aggregateIdentifier); SnapshotTrigger trigger = snapshotTriggerDefinition.prepareTrigger(aggregateFactory.getAggregateType()); if (!eventStream.hasNext()) { throw new AggregateNotFoundException(aggregateIdentifier, "The aggregate was not found in the event store"); } EventSourcedAggregate<T> aggregate = EventSourcedAggregate .initialize(aggregateFactory.createAggregateRoot(aggregateIdentifier, eventStream.peek()), aggregateModel(), eventStore, repositoryProvider, trigger); aggregate.initializeState(eventStream); if (aggregate.isDeleted()) { throw new AggregateDeletedException(aggregateIdentifier); } return aggregate; }
@Override public DomainEventMessage<?> peek() { if (!hasNext()) { return null; } return delegate.peek(); }
@Override public DomainEventMessage<?> peek() { if (!hasNext()) { return null; } return delegate.peek(); }
@Override public DomainEventMessage<?> peek() { if (!hasNext()) { return null; } return streams.peekFirst().peek(); }
@Override public DomainEventMessage<?> peek() { if (!hasNext()) { return null; } return streams.peekFirst().peek(); }
@Override public boolean hasNext() { // check if there is anything to read if (!delegate.hasNext()) { return false; } DomainEventMessage<?> peeked = delegate.peek(); while (!filter.test(peeked)) { // consume delegate.next(); if (delegate.hasNext()) { peeked = delegate.peek(); } else { return false; } } return delegate.hasNext(); }
@Override public boolean hasNext() { // check if there is anything to read if (!delegate.hasNext()) { return false; } DomainEventMessage<?> peeked = delegate.peek(); while (!filter.test(peeked)) { // consume delegate.next(); if (delegate.hasNext()) { peeked = delegate.peek(); } else { return false; } } return delegate.hasNext(); }
@Override public void run() { DomainEventStream eventStream = eventStore.readEvents(identifier); // a snapshot should only be stored if the snapshot replaces at least more than one event long firstEventSequenceNumber = eventStream.peek().getSequenceNumber(); DomainEventMessage snapshotEvent = createSnapshot(aggregateType, identifier, eventStream); if (snapshotEvent != null && snapshotEvent.getSequenceNumber() > firstEventSequenceNumber) { eventStore.storeSnapshot(snapshotEvent); } } }
@Override public void run() { DomainEventStream eventStream = eventStore.readEvents(identifier); // a snapshot should only be stored if the snapshot replaces at least more than one event long firstEventSequenceNumber = eventStream.peek().getSequenceNumber(); DomainEventMessage snapshotEvent = createSnapshot(aggregateType, identifier, eventStream); if (snapshotEvent != null && snapshotEvent.getSequenceNumber() > firstEventSequenceNumber) { eventStore.storeSnapshot(snapshotEvent); } } }
/** * Perform the actual loading of an aggregate. The necessary locks have been obtained. * * @param aggregateIdentifier the identifier of the aggregate to load * @param expectedVersion The expected version of the loaded aggregate * @return the fully initialized aggregate * @throws AggregateDeletedException in case an aggregate existed in the past, but has been deleted * @throws AggregateNotFoundException when an aggregate with the given identifier does not exist */ @Override protected EventSourcedAggregate<T> doLoadWithLock(String aggregateIdentifier, Long expectedVersion) { DomainEventStream eventStream = readEvents(aggregateIdentifier); SnapshotTrigger trigger = snapshotTriggerDefinition.prepareTrigger(aggregateFactory.getAggregateType()); if (!eventStream.hasNext()) { throw new AggregateNotFoundException(aggregateIdentifier, "The aggregate was not found in the event store"); } EventSourcedAggregate<T> aggregate = EventSourcedAggregate .initialize(aggregateFactory.createAggregateRoot(aggregateIdentifier, eventStream.peek()), aggregateModel(), eventStore, repositoryProvider, trigger); aggregate.initializeState(eventStream); if (aggregate.isDeleted()) { throw new AggregateDeletedException(aggregateIdentifier); } return aggregate; }