Pull Modelle

lesen auf Anfrage Events aus dem Store und erzeugen ihren "aktuellen" Zustand
Aktualisierung erfolgt synchron zur Anfrage
strikt konsistent mit dem Log

Objekt-Modell

@Data
public class Cart {
    final UUID customerId;
    final UUID cartId;
    final Map<UUID, LineItem> lineItems = new HashMap<>();
    boolean closed = false;
}

@Data
public class LineItem {
    final UUID articleId;
    int quantity = 1;
}

ReadModel erstellen

class CartReadModel extends PullReadModel {

    @Getter private Cart cart;

    CartReadModel(FactCast eventStore, UUID cartId) {
        super(eventStore,()->FactSpec.ns("jugsaxony").aggId(cartId));
        cart = new Cart(cartId);
    }

    public void apply(LineItemAdded event) {
        LineItem li = new LineItem(event.getArticleId());
        li.setQuantity(event.getQuantity());
        cart.getLineItems().put(li.getArticleId(), li);
    }

    public void apply(LineItemRemoved event) {
        cart.getLineItems().remove(event.getArticleId());
    }

    public void apply(LineItemQuantityChanged fact) {
        cart.getLineItems().get(fact.getArticleId()).setQuantity(fact.getQuantity());
    }

    public void apply(CheckoutStarted event) {
        cart.setClosed(true);
    }
}

PullReadModel

public class PullReadModel extends ReadModel {

    public PullReadModel(FactCast eventStore, Supplier<FactSpec> spec) {
        super(eventStore, spec);
    }

    private void pullFromScratch() {

        eventStore.subscribeToFacts(
            SubscriptionRequest.catchup(factsOfInterest).fromScratch(),
            this)
            .awaitComplete();
    }
    //...
}

Beispiel: Repository

public interface CartRepository {
    Cart findByCartId(UUID cartId);
}

@Component @RequiredArgsConstructor
public class CartRepositoryImpl implements CartRepository {
    final FactCast eventStore;

    @Override
    public Cart findByCartId(UUID cartId) {
        return new CartReadModel(eventStore, cartId).pull();
    }
}

Jedesmal alle Events auffinden?

Ist das nicht zu aufwändig?

Rolling Snapshot

@Service @RequiredArgsConstructor
public class CartSnapshotRepositoryImpl implements CartRepository {

    final FactCast eventStore;

    final Map<UUID, CartReadModel> modelCache = new LRUMap<>();

    @Override
    public Cart findByCartId(UUID cartId) {
        CartReadModel readModel = modelCache.computeIfAbsent(cartId, 
            id -> new CartReadModel( eventStore, id ) );
        readModel.pull();
        return readModel.getCart();
    }

}

PullReadModel (Snapshot)

public class PullReadModel extends ReadModel {

    // ...

    public void pull() {
        if (lastFactConsumed == null) {

            pullFromScratch();

        } else {

            eventStore.subscribeToFacts(
                    SubscriptionRequest.catchup(factsOfInterest)
                    .from(lastFactConsumed), this)
                    .awaitComplete();
        }
    }
}

Bei jedem Lesevorgang den Eventstore fragen?

Was tun bei großer Leselast?

Push Modelle

registrieren sich am Eventstore
lassen sich interessante Events zusenden, sobald sie auftreten
Aktualisierung erfolgt asynchron zur Anfrage
geringere Latenz
nicht immer strikt konsistent
(Events können bei Anfrage gerade 'unterwegs' sein)

Push

@Service
public class RecommendedArticles extends PushReadModel {

    final Map<UUID, Set<UUID>> recommendedArticlesByCustomer = 
            new ConcurrentHashMap<>();

    public void apply(LineItemRemoved event) {
        Set<UUID> list = getForCustomer(event.getCustomerId());
        list.add(event.getArticleId());
    }

    public void apply(CheckoutStarted event) {
        List<UUID> articlesInCart = event.getLineItems()
                .stream()
                .map(LineItem::getArticleId)
                .collect(Collectors.toList());
        Set<UUID> list = getForCustomer(event.getCustomerId());
        list.removeAll(articlesInCart);
    }
    // ...
}

Push

public class PushReadModel extends ReadModel implements SmartInitializingSingleton {

    public PushReadModel(FactCast eventStore, Supplier<FactSpec> spec) {
        super(eventStore, spec);
    }

    @Override
    public void afterSingletonsInstantiated() {
 
       eventStore.subscribeToFacts(
                SubscriptionRequest.follow(factsOfInterest).fromScratch(), this);
 
   }
}

Event Sourcing