An Introduction To CQRS

Introduction to CQRS Approaches to System Architecture@NeilRobbinsneil@computer.org

Tonights show is brought to by the following #tags#cqrs#glnetHopefully not#fail, #WTF, or #WasteOfTime

What are we going to cover?Overview of the spaceCQS, Commands, Queries, DDDSimple CQRSDistributing CQRSEventsPub-SubEventual Consistency & Conflict ManagementEvent Sourcing & CQRSWhat & Why?Some Code – Phew!

An interface should be attractive!Simple

ChangeCommand-Query Separation PrincipleFunctions should not produce abstract side effectsFrom: Object-Oriented Software Construction, 2nd Edition by Bertrand Meyer

Command-Query Separation PrincipleAsking a question should not change the answerFrom: Object-Oriented Software Construction, 2nd Edition by Bertrand Meyer

Command-Query Separation Principlepublic interface IAmACqsExample{ void DoSomething(); void DoSomething(Argument arg); Result GetSomething(); Result GetSomething(Argument arg);}

So what is CQRS?Started out as:DDDD (Domain Driven Design + Distributed)Architectural CQSNow:CommandQueryResponsibilitySegregation

So what is CQRS? – Part DeuxA trinityCommandsQueriesIntent capturing UI

Simple CQRSFaçade\ClientLogically distributableCommandsFullyConsistentQueries

What does a command look like?CreateAnOrderForTheCustomerImperative

Clearly represent client intent

Highly likely to succeedCommand HandlingGet the decorators in!

CQRS Meets DDDBut it doesn’t have toCore domain, supporting domainsNeed not be everywhere, some can be transaction script with Anaemic objectsUbiquitous language can lead to a clean interfaceOrganising by aggregate root can make for simpler persistenceDomain object should never be put in an invalid state!

Domain Objects: Forget Properties! public class Event { public string Name { get; set; } public int Venue { get; set; } public DateTime Date { get; set; } public IEnumerable<Session> Sessions { get; set; } } public class Session { public PresentationPresentation { get; set; } public string Location { get; set; } public DateTime Time { get; set; } }

Domain Objects: No QueriesNo Queries on your domain objects!Yes, that definitely includes any getters!Nada! (well maybe one, we’ll see that much later)All querying will be done through the Query systemNo binding to domain objects

Domain Objects: Control your mutationsOnly Command methods exposedThey don’t return things either!Controlled mutation of stateEnsures that aggregate roots do not enter into invalid statesEver! No IsValid() method (it’d be a query anyway)

So what about Queries?They’re just queriesThey support the UI which should provide a Decision Support SystemGet quickly from the databaseImmutable objects

Intentful UIShopping Cart ServiceCommandCommandRatings ServiceCommandCommandProduct Images ServiceCommandCommandCommandBuying Choices ServiceOffers ServiceBought Together Service

Intentful UICaptures IntentAligns with commandsWant to know WHY something changed, not just that it didDecide on an appropriate level of granularity, what’s important to your client/business?Customer address changedOrCustomer moved houseOrCustomer’s address was incorrect

Intentful UIUses the query infrastructureFor displayFor decision supportShould be a pit of successCommands should succeedWill contain logic, is typically rich

Distributing CQRSIntroduces some issuesKeeping things in syncFaults become more likelyCan give some winsAvailabilityScalabilityMay/Should make some choicesCAP Theorum

Introducing EventsSomething happenedPast-tenseCapture the details of the changeSimple immutable data-structuresCan be fed into MapReduce jobsCan be consumed more widely across the enterpriseIntegrate with other systemsSend emailsUpdate DataMarts/Warehouses

Façade\ClientBusCommandsEventuallyConsistentQueriesHandler

Keeping the Query Side in SyncDon’t have to forego ConsistencyCan perform 2 Phase CommitsCan use quorumsButthere’s a price in the face of a faultwrite performance will degraderestrictive in the face of wide-geographical distributionCan use:RDBMS crazyness ;)PubSub

SubscriberSubscriberPublisherSubscribersSubscriber

Event Sourcing…there are times when we don't just want to see where we are,we also want to know how we got therehttp://martinfowler.com/eaaDev/EventSourcing.html2 Ways to persist changesSnapshot of current stateJust the change itself

ID : 123Name : The Art of WarAuthor: Sun TzuISBN: 1234ABCD5678Event: BookIsbnChangedNewValue: 4321DCBA8765

Time to See Some CodeYou didn’t think I’d make you watch me type did you?A small taste of Greg Young’s course (with minor changes) – link at the end.

First up a domain objectnamespaceProgNetDemo{public classCatalogItem { }}The domain object

A Command MethodnamespaceProgNetDemo{public classCatalogItem { public void Retire() { } }}Now we add a behaviour

Some State To ChangenamespaceProgNetDemo{public classCatalogItem {privatebool _retired; public void Retire() { } }}Some state that will need to be mutated

Guard the MutationnamespaceProgNetDemo{public classCatalogItem {privatebool _retired; public void Retire() {if (!_retired)thrownewInvalidOperationException(); } }}Protect the validity of the object!

Make the State Mutation A Domain EventnamespaceProgNetDemo{public classCatalogItem {privatebool _retired; public void Retire() {if (!_retired)thrownewInvalidOperationException();ApplyEvent(new RetiredEvent(_id)); } }}State mutations are a 2 phase activity

Need an Identifier for the Aggregatepublic classCatalogItem{privatebool _retired;privateGuid_id; public void Retire() {if (!_retired)thrownewInvalidOperationException();ApplyEvent(new RetiredEvent(_id)); }}The event needs to know the Id of the Entity being updated

Create the EventpublicclassRetiredEvent{privatereadonlyGuid _id;publicRetiredEvent(Guid id) { _id = id; }}Don’t need more state, in this case the name says it allNote it’s immutable

Need to be Able to Apply the Eventpublic classCatalogItem{privatebool _retired;privateGuid_id; public void Retire() {if (!_retired)thrownewInvalidOperationException();ApplyEvent(new RetiredEvent(_id)); }}Still need to write the code to apply the event.

Create a Base Classpublic abstract classAggregateRoot {protected voidApplyEvent(Event @event) { }}All Aggregate Roots will extend this classWe’ll need to handle more than just the one type of event!

Create the Event Typepublic classEvent { }Would want to move the AggregateId into this base class

Have our RetiredEvent Inherit From the Base TypepublicclassRetiredEvent : Event{privatereadonlyGuid _id;publicRetiredEvent(Guid id) { _id = id; }}

Still Need to Mutate the Statepublic classCatalogItem : AggregateRoot{privatebool _retired;privateGuid_id; public void Retire() {if (!_retired)thrownewInvalidOperationException();ApplyEvent(new RetiredEvent(_id)); }}

Create a Method to Handle the State Change From the Eventpublic classCatalogItem : AggregateRoot{privatebool _retired;privateGuid_id; public void Retire() {if (!_retired)thrownewInvalidOperationException();ApplyEvent(new RetiredEvent(_id)); }private voidApplyRetiredEvent(RetiredEvent @event) { _retired = true; }}This method will actually apply the event, that is mutate the state

Done!?public classCatalogItem : AggregateRoot{privatebool _retired;privateGuid_id; public void Retire() {if (!_retired)thrownewInvalidOperationException();ApplyEvent(new RetiredEvent(_id)); }private voidApplyRetiredEvent(RetiredEvent @event) { _retired = true; }}

Need to Connect the Event with the Handlerpublic classCatalogItem : AggregateRoot{privatebool _retired;privateGuid_id;publicCatalogItem() {RegisterHandler<RetiredEvent>(ApplyRetiredEvent); } public void Retire() {if (!_retired)thrownewInvalidOperationException();ApplyEvent(new RetiredEvent(_id)); }private voidApplyRetiredEvent(RetiredEvent @event) { _retired = true; }}This could be done following a convention insteadNote, this is the specific Event subtype – more later!

Allow Handlers to be Registeredpublic classAggregateRoot {protected voidRegisterHandler<TEvent>(AppliesEvent<TEvent> handler)whereTEvent : Event { }protected voidApplyEvent(Event @event) { }}The delegate signature needs to be defined

Create the Delegate Signaturepublic delegate voidAppliesEvent<TEvent>(TEvent @event)where TEvent : Event;public classAggregateRoot {protected voidRegisterHandler<TEvent>(AppliesEvent<TEvent> handler)whereTEvent : Event { }protected voidApplyEvent(Event @event) { }}

Need to Maintain the Registrypublic delegate voidAppliesEvent<TEvent>(TEvent @event)where TEvent : Event;public classAggregateRoot {private readonlyIDictionary<Type, Action<Event>> _handlerRegistry;protected voidRegisterHandler<TEvent>(AppliesEvent<TEvent> handler)whereTEvent : Event {var castHandler = DelegateAdjuster.CastArgument<Event, TEvent>(e => handler(e)); }protected voidApplyEvent(Event @event) { }}Will keep a list of handlers for each type of event.We’re storing the Action<Event>, but we want to call an Action<RetiredEvent>

Delegate Adjuster:From Greg Young’s Blogpublic class DelegateAdjuster{ public static Action<TBase> CastArgument<TBase, TDerived>(Expression<Action<TDerived>> source) whereTDerived : TBase{ if (typeof(TDerived) ==typeof(TBase)){ return (Action<TBase>)((Delegate)source.Compile());}ParameterExpressionsourceParameter = Expression.Parameter(typeof(TBase),"source");varresult = Expression.Lambda<Action<TBase>>(Expression.Invoke( source,Expression.Convert(sourceParameter, typeof(TDerived))),sourceParameter); return result.Compile();}}

Need to Maintain the Registrypublic delegate voidAppliesEvent<TEvent>(TEvent @event)where TEvent : Event;public classAggregateRoot {private readonlyIDictionary<Type, Action<Event>> _handlerRegistry;protected voidRegisterHandler<TEvent>(AppliesEvent<TEvent> handler)whereTEvent : Event {var castHandler = DelegateAdjuster.CastArgument<Event, TEvent>(e => handler(e)); _handlerRegistry.Add(typeof(TEvent), castHandler); }protected voidApplyEvent(Event @event) { }}Store the handler having downcast it

Need to Apply the Event Stillpublic classAggregateRoot {private readonlyIDictionary<Type, Action<Event>> _handlerRegistry;protected voidRegisterHandler<TEvent>(AppliesEvent<TEvent> handler)whereTEvent : Event {var castHandler = DelegateAdjuster.CastArgument<Event, TEvent>(e => handler(e)); _handlerRegistry.Add(typeof(TEvent), castHandler); }protected voidApplyEvent(Event @event) {Action<Event> handler;if (!_handlerRegistry.TryGetValue(@event.GetType(), out handler)) {throw newInvalidOperationException(); } handler(@event); }}If no handler for a mutation is registered, it’s a problemInvoke the handler

Need to Track Applied Eventspublic delegate voidAppliesEvent<TEvent>(TEvent @event)where TEvent : Event;public classAggregateRoot {private readonlyIDictionary<Type, Action<Event>> _handlerRegistry;private readonlyICollection<Event> _events;protected voidRegisterHandler<TEvent>(AppliesEvent<TEvent> handler)whereTEvent : Event {var castHandler = DelegateAdjuster.CastArgument<Event, TEvent>(e => handler(e)); _handlerRegistry.Add(typeof(TEvent), castHandler); }protected voidApplyEvent(Event @event) {Action<Event> handler;if (!_handlerRegistry.TryGetValue(@event.GetType(), out handler)) {throw newInvalidOperationException(); } handler(@event); _events.Add(@event); }}Track the events that are being appliedMake sure that the events are added.

All done now???public classCatalogItem : AggregateRoot{privatebool _retired;privateGuid_id;publicCatalogItem() {RegisterHandler<RetiredEvent>(ApplyRetiredEvent); } public void Retire() {if (!_retired)thrownewInvalidOperationException();ApplyEvent(new RetiredEvent(_id)); }private voidApplyRetiredEvent(RetiredEvent @event) { _retired = true; }}

Not Quite – pt. 1Need to Expose the events for persistence & publishingPut a GetChanges() method on the AggregateRoot base class

Not Quite – pt. 2Need to be able to rebuild the Aggregate from historyPut a LoadFromHistory(IEnumerable<Event> events) method on the AggregateRoot base classReapply the eventsDon’t track them as changes – overload apply eventprotected voidApplyEvent(Event @event, booltrackAsChange)if (add) _events.Add(@event);

Not Quite – pt. 3Possibly memento pattern for snapshotingSee Mark Nijhof’s blog & sample code on GitHubPossibly use a unit of work pattern for tracking changes

An Introduction To CQRS

More Related Content

Similar to An Introduction To CQRS

Recently uploaded

An Introduction To CQRS

Editor's Notes