Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
A Scala web application demonstrating event-sourcing best practices
branch: master

This branch is 6 commits behind eligosource:master

Fetching latest commit…

Cannot retrieve the latest commit at this time

Failed to load latest commit information.
doc/images
project
src/main
.gitignore
LICENSE
README.md

README.md

Overview

This project demonstrates how to implement an event-sourced web application based on the Eligosource Eventsourced library. It is based on former work that has been described in the articles

Compared to the old implementation, the whole service and persistence layer have been re-written and the domain events are now decoupled from the immutable domain model. The web UI and the web API remain unchanged.

The example web application uses the Eventsourced library for both event-sourcing and command-sourcing. Furthermore, it implements the CQRS pattern and follows domain-driven design principles.

Architecture

Legend:

Legend

  • The domain model is a rich, immutable domain model. It is annotated with JAXB annotations for XML and JSON binding.
  • The service layer implements the event-sourced and command-sourced actors (processors) together with service facades for asynchronous writes and synchronous, non-blocking reads of application state.
    • Processors manage application state via STM references.
    • For reading current state, services facades access STM references directly (concurrent reads).
    • For updating current state, services facades access STM references via processors where a single STM reference is updated by a single processor (single-writer-principle)
    • On the command-side of the implemented CQRS pattern is the InvoiceService that manages application state and serves consistent reads of invoices.
    • On the query side of the implemented CQRS pattern is the StatisticsService, a read model that serves eventually consistent reads about invoice update statistics.
    • The PaymentProcess is an example of a stateful, potentially long-running and event-sourced business process.
  • The web layer provides a RESTful service interface to application resources and supports HTML, XML and JSON representation formats. It is built on top of Jersey and Scalate. A Play-based version will follow (which supports asynchronous responses in contrast to Jersey).
  • The application configuration wires the pieces together.

Build

Clone the example application and compile it

git clone git://github.com/eligosource/eventsourced-example.git
cd eventsourced-example
sbt compile

Run

To start the example application run

sbt 'run-nobootcp org.eligosource.eventsourced.example.server.Webserver'

Then go to http://localhost:8080 and create some invoices.

The example application's RESTful service interface supports HTML, XML and JSON representation formats. Content negotiation is done via the Accept HTTP header. The following examples show how to get HTML and XML representations for invoice-3.

HTML

Click on http://localhost:8080/invoice/invoice-3. Provided you have created an invoice with id invoice-3 before, you should see something like

invoice-3

XML

curl -H "Accept: application/xml" http://localhost:8080/invoice/invoice-3

yields

<draft-invoice id="invoice-3" version="2">
    <total>12.8</total>
    <sum>12.8</sum>
    <discount>0</discount>
    <items>
        <item>
            <description>item-1</description>
            <count>1</count>
            <amount>4.1</amount>
        </item>
        <item>
            <description>item-2</description>
            <count>3</count>
            <amount>2.9</amount>
        </item>
    </items>
</draft-invoice>
Something went wrong with that request. Please try again.