Applied Domain-Driven Design in Java

Kursen lär ut ett direkt, praktiskt sätt att närma sig arkitektur inom affärslivet. Fokus ligger på att producera affärsmjukvara som är mer användbar, testbar, och lättare att förvalta och förstå än konventionella sätt att bygga applikationer.
Med hjälp av Domän-Driven Design (DDD) och Command/Query Responsibility Segregation (CQRS) ser vi hur vi kan applicera moderna lärdomar på vår design, för att kunna bygga mer hållbara, skalbara, och testbara system till lägre totalkostnad.
Istället för att lära ut ett ramverk lär kursen ut en modern arkitektur, ett antal möjliga implementationer, och understryker de vanliga fallgroparna man kan undvika på vägen.
Det här är en praktisk kurs, och vi håller oss nära programkoden hela vägen. Under kursen bygger vi successivt upp en mindre applikation från grunden. Kursen täcker även testning, hur man applicerar nyckelinsikterna från kursen på existerande system, och hur man skalar ut ett system byggt med CQRS.

Dag 1
The Challenge of "Database Driven" Software Development

Types of complexity
Scaling and consistency
Testing
Integration

Introduction to Domain Driven Design

Domains and Domain Models
Ubiquitous Language
Exercise on building a domain model

Bounded Contexts

Why boundaries matter
Context Maps
Decomposition in the domain
Composition in the UI
Exercises on boundary hunting

Commands, Queries and Events

Normalization and denormalization
Write models and read models
Events as the write-side/read-side link
Eventual consistency and its consequences
Designing commands
Designing queries
Exercise on command and query design

Message Busses

Messages as decoupling
Publish/Subscribe
Send vs. Publish
Building a simple message bus
Exercise on message bus implementation

Write Side Architecture

Command handlers
State sourcing vs. event sourcing
Introduction to aggregates
Building up aggregates from past events
Transactional safety
Exercise on command handlers and aggregates

Dag 2
BDD Style Testing

Introduction to BDD
Commands, Events and BDD
Building a simple test framework
Exercise on BDD

Event Stores

Existing options
Building an event store on top of an RDBMS
Implementing a repository using an event store
Advantages of freeing aggregate representation from persistence
Optimizations using snapshots
Exercise on building an event store

Advanced Aggregate Design

Finding aggregate boundaries
Coping with relationships
Exercise on aggregate design

Building Read Sides

Overall approach
Relational DB read sides
NoSQL read sides
Other options
Re-building and introducing new read sides
Exercise on building read sides

Dag 3
Sagas

What is a saga?
Different types of saga
Handling saga state
Building a simple saga framework
Exercise on sagas

Evolving a System

Refining domain models
Handling changes to commands
Event versioning
Handling event upgrade
Exercise on event upgrading

CQRS, DDD and Existing Codebases

Introducing bounded contexts to existing systems
Separating commands and queries
Migrating towards event sourcing

Scaling out

Using the read/write separation to scale
Scaling write sides by bounded context and by aggregate
Scaling within an aggregate
Message distribution and reliability
Message queues and ESBs

Other Opportunities

Parallel development and outsourcing
Recreating previous states for debugging