sequence

This article focuses on the AggregateRoot of GO.cQRS

AggregateRoot

//AggregateRoot is the interface that all aggregates should implement
type AggregateRoot interface {
	AggregateID() string
	OriginalVersion() int
	CurrentVersion() int
	IncrementVersion()
	Apply(events EventMessage, isNew bool)
	TrackChange(EventMessage)
	GetChanges() []EventMessage
	ClearChanges()
}
Copy the code

The AggregateRoot interface defines the AggregateID, OriginalVersion, CurrentVersion, IncrementVersion, Apply, TrackChange, GetChanges, and ClearChanges parties method

AggregateBase

// AggregateBase is a type that can be embedded in an AggregateRoot // implementation to handle common aggragate behaviour // // All required methods to implement an aggregate are here, to implement the // Aggregate root interface your aggregate will need to implement the Apply // method that will contain  behaviour specific to your aggregate. type AggregateBase struct { id string version int changes []EventMessage } // NewAggregateBase contructs a new AggregateBase. func NewAggregateBase(id string) *AggregateBase { return &AggregateBase{  id: id, changes: []EventMessage{}, version: 1, } } // AggregateID returns the AggregateID func (a *AggregateBase) AggregateID() string { return a.id } // OriginalVersion returns the version of the aggregate as it was when it was // instantiated or loaded from the repository. // // Importantly an aggregate with one event applied will be at version 0 // this allows the aggregates to match the version in the eventstore where // the first event will be version 0. func (a *AggregateBase) OriginalVersion() int { return a.version } // CurrentVersion returns the version of the aggregate as it was when it was // instantiated or loaded from the repository. // // Importantly an aggregate with one event applied will be at version 0 // this allows the aggregates to match the version in the eventstore where // the first event will be version 0. func (a *AggregateBase) CurrentVersion() int { return a.version + len(a.changes) } // IncrementVersion increments the aggregate version number by one. func (a *AggregateBase) IncrementVersion() { a.version++ } // TrackChange stores the EventMessage in the changes collection. // // Changes are new, unpersisted events that have been applied to the aggregate. func (a *AggregateBase) TrackChange(event EventMessage) { a.changes = append(a.changes, event) } // GetChanges returns the collection of new unpersisted events that have // been applied to the aggregate. func  (a *AggregateBase) GetChanges() []EventMessage { return a.changes } //ClearChanges removes all unpersisted events from the aggregate. func (a *AggregateBase) ClearChanges() { a.changes = []EventMessage{} }Copy the code

AggregateBase defines the ID, Version, and CHANGES attributes. AggregateID Returned ID of the method. The OriginalVersion method returns version; CurrentVersion returns version+len(a.changes); IncrementVersion Increments version. The TrackChange method adds events to changes. The GetChanges method returns changes; ClearChanges clears changes

EventMessage

// EventMessage is the interface that a command must implement. type EventMessage interface { // AggregateID returns the  ID of the Aggregate that the event relates to AggregateID() string // GetHeaders returns the key value collection of headers for the event. // // Headers are metadata about the event that do not form part of the // actual event but are still required to be persisted alongside the event. GetHeaders() map[string]interface{} // SetHeader sets the value of the header specified by the key SetHeader(string, interface{}) // Returns the actual event which is the payload of the event message. Event() interface{} // EventType returns a string descriptor of the command name EventType() string // Version returns the version of the event Version()  *int }Copy the code

The EventMessage interface defines the AggregateID, GetHeaders, SetHeader, Event, EventType, and Version methods

EventDescriptor

// EventDescriptor is an implementation of the event message interface.
type EventDescriptor struct {
	id      string
	event   interface{}
	headers map[string]interface{}
	version *int
}

// NewEventMessage returns a new event descriptor
func NewEventMessage(aggregateID string, event interface{}, version *int) *EventDescriptor {
	return &EventDescriptor{
		id:      aggregateID,
		event:   event,
		headers: make(map[string]interface{}),
		version: version,
	}
}

// EventType returns the name of the event type as a string.
func (c *EventDescriptor) EventType() string {
	return typeOf(c.event)
}

// AggregateID returns the ID of the Aggregate that the event relates to.
func (c *EventDescriptor) AggregateID() string {
	return c.id
}

// GetHeaders returns the headers for the event.
func (c *EventDescriptor) GetHeaders() map[string]interface{} {
	return c.headers
}

// SetHeader sets the value of the header specified by the key
func (c *EventDescriptor) SetHeader(key string, value interface{}) {
	c.headers[key] = value
}

// Event the event payload of the event message
func (c *EventDescriptor) Event() interface{} {
	return c.event
}

// Version returns the version of the event
func (c *EventDescriptor) Version() *int {
	return c.version
}
Copy the code

The EventDescriptor defines the ID, Event, headers, and Version attributes. Its EventType returns typeOf(c. vent); AggregateID Return ID; GetHeaders return headers; SetHeader will set the header; The Event method returns an Event; Version returns the Version

summary

The AggregateRoot interface of go. CQRS defines AggregateID, OriginalVersion, CurrentVersion, IncrementVersion, Apply, TrackChange, GetChanges, and Clear Methods Changes.

doc

  • go.cqrs