If two aggregates are listening to the same event; then the event will be stored in an event store twice, once for each aggregate.

class ItemLoaded implements Event {
    LocationId location;
    VehicleId vehicle;
    Amount amount;
    Date loadDate;
}

class Location implements Aggregate {
    Amount itemAmount;

    void updateFrom(ItemLoaded event) {
        this.itemAmount.subtract(event.amount);
    }
}


class Vehicle implements Aggregate {
    Amount itemAmount;

    void updateFrom(ItemLoaded event) {
        this.itemAmount.add(event.amount);
    }
}

For instance there will be entries of the ItemLoaded event in the store once for Location and once for Vehicle, in the above case.

This much is expected, as can be seen from the two toy examples below, which you might have already seen if you’ve been reading about event sourcing:

In one example:

_current = new Dictionary<Guid, List<EventDescriptor>>();

In another example:

CREATE TABLE EventWrappers(
EventId uniqueidentifier NOT NULL,
StreamId nvarchar(50) COLLATE Latin1_General_CI_AS NOT NULL,
Sequence bigint NOT NULL,
TimeStamp datetime NOT NULL,
EventType nvarchar(100) COLLATE Latin1_General_CI_AS NOT NULL,
Body nvarchar](max) COLLATE Latin1_General_CI_AS NOT NULL,

Production systems aren’t probably that different. In axon framework event are stored in a table like below, if you choose JPA or JDBC implementation of event store :

create table DomainEventEntry (
    -- .....
    primary key (aggregateIdentifier, sequenceNumber, type)
);

type field above is a string used to differentiate different aggregate types.

Given that events apparently maybe persisted multiple times, if I want to recreate a view from scratch, or add a new view model, how would I replay the events.

If we return to the above example, consider a view model like this:

class ItemsLoadedByYearProjection {
    @Subscribe
    void update(ItemLoaded event) {
        ItemsLoadedByYear row = getRowForYear(event.loadDate.year);
        row.itemAmount.add(itemAmount);
    }
}

class ItemsLoadedByYear {
    int year;
    Amount itemAmount;
}

Not only will the amounts will be counted twice now, if I replay the events naively; if I add a new aggregate in the future, some events will be counted twice, where others will be counted three times.

How do I prevent a projection/denormalizer from double counting the events that was saved to the event store multiple times?