Modelling
Messaging and Ecotone In Depth
Lesson 2: Tactical DDD
DDD PHP
Not having code for Lesson 2?
git checkout lesson-2Aggregate
An Aggregate is an entity or group of entities that is always kept in a consistent state.
Aggregates are very explicitly present in the Command Model, as that is where change is initiated and business behaviour is placed.
Let's create our first Aggregate
Product.1
namespace App\Domain\Product;
2
​
3
use Ecotone\Modelling\Attribute\Aggregate;
4
use Ecotone\Modelling\Attribute\AggregateIdentifier;
5
use Ecotone\Modelling\Attribute\CommandHandler;
6
use Ecotone\Modelling\Attribute\QueryHandler;
7
​
8
#[Aggregate]
9
class Product
10
{
11
#[AggregateIdentifier]
12
private int $productId;
13
​
14
private int $cost;
15
​
16
private function __construct(int $productId, int $cost)
17
{
18
$this->productId = $productId;
19
$this->cost = $cost;
20
}
21
​
22
#[CommandHandler]
23
public static function register(RegisterProductCommand $command) : self
24
{
25
return new self($command->getProductId(), $command->getCost());
26
}
27
​
28
#[QueryHandler]
29
public function getCost(GetProductPriceQuery $query) : int
30
{
31
return $this->cost;
32
}
33
}
Copied!
- 1.
Aggregateannotation marks class to be known as Aggregate - 2.
AggregateIdentififermarks properties as identifiers of specific Aggregate instance. Each Aggregate must contains at least one identifier. - 3.
CommandHandlerenables command handling on specific method just as we did in Lesson 1. If method is static, it's treated as factory method and must return new aggregate instance. Rule applies as long as we use State-Stored Aggregate instead of Event Sourcing Aggregate. - 4.
QueryHandlerenables query handling on specific method just as we did in Lesson 1.
Now remove
App\Domain\Product\ProductService as it contains handlers for same command and query classes.
Before we will run our test scenario, we need to register Repository.Usually you will mark
services as Query Handlers not aggregates. Ecotonedoes not block possibility to place Query Handler on Aggregate. It's up to you, where do you want to place Query Handler.Repository
Repositories are used for retrieving and saving the aggregate to persistent storage.
We will build in memory implementation for now.
1
namespace App\Domain\Product;
2
​
3
use Ecotone\Modelling\Attribute\Repository;
4
use Ecotone\Modelling\StandardRepository;
5
​
6
#[Repository] // 1
7
class InMemoryProductRepository implements StandardRepository // 2
8
{
9
/**
10
* @var Product[]
11
*/
12
private $products = [];
13
​
14
// 3
15
public function canHandle(string $aggregateClassName): bool
16
{
17
return $aggregateClassName === Product::class;
18
}
19
​
20
// 4
21
public function findBy(string $aggregateClassName, array $identifiers): ?object
22
{
23
if (!array_key_exists($identifiers["productId"], $this->products)) {
24
return null;
25
}
26
​
27
return $this->products[$identifiers["productId"]];
28
}
29
​
30
// 5
31
public function save(array $identifiers, object $aggregate, array $metadata, ?int $expectedVersion): void
32
{
33
$this->products[$identifiers["productId"]] = $aggregate;
34
}
35
}
Copied!
- 1.
Repositoryannotation marks class to be known toEcotoneas Repository. - 2.We need to implement some methods in order to allow
Ecotone, retrieve and save Aggregate. Based on implemented interface,Ecotoneknowns, if Aggregate is state-stored or event sourced. - 3.
canHandletells which classes can be handled by this specific repository - 4.
findByreturn found aggregate instance or null. As there may be more, than single indentifier per aggregate, identifiers are array. - 5.
savesaves passed aggregate instance. You do not need to bother right what is$metadataand$expectedVersion
Laravel
Symfony
Lite
1
# As default auto wire of Laravel creates new service instance each time
2
# service is requested from Depedency Container, we need to register
3
# ProductService as singleton.
4
​
5
# Go to bootstrap/QuickStartProvider.php and register our ProductService
6
​
7
namespace Bootstrap;
8
​
9
use App\Domain\Product\InMemoryProductRepository;
10
use Illuminate\Support\ServiceProvider;
11
​
12
class QuickStartProvider extends ServiceProvider
13
{
14
public function register()
15
{
16
$this->app->singleton(InMemoryProductRepository::class, function(){
17
return new InMemoryProductRepository();
18
});
19
}
20
(...)
Copied!
1
Everything is set up by the framework, please continue...
Copied!
1
Everything is set up, please continue...
Copied!
Let's run our testing command:
1
bin/console ecotone:quickstart
2
Running example...
3
100
4
Good job, scenario ran with success!
Copied!
Have you noticed, what are we missing here? Our
Event Handler was not called, as we do not publish ProductWasRegistered event at this moment. Event Publishing
In order to automatically publish events recorded within Aggregate, we need to add method annotated with
AggregateEvents. This will tell Ecotone where to get the events from.
Ecotone comes with default implementation, that can be used as trait WithAggregateEvents.1
use Ecotone\Modelling\WithAggregateEvents;
2
​
3
#[Aggregate]
4
class Product
5
{
6
use WithAggregateEvents;
7
​
8
#[AggregateIdentifier]
9
private int $productId;
10
​
11
private int $cost;
12
​
13
private function __construct(int $productId, int $cost)
14
{
15
$this->productId = $productId;
16
$this->cost = $cost;
17
​
18
$this->recordThat(new ProductWasRegisteredEvent($productId));
19
}
20
(...)
Copied!
You may implement your own method for returning events, if you do not want to couple with framework.
Let's run our testing command:
1
bin/console ecotone:quickstart
2
Running example...
3
Product with id 1 was registered!
4
100
5
Good job, scenario ran with success!
Copied!
Congratulations, we have just finished Lesson 2.
In this lesson we learnt how to make use of Aggregates and Repositories.
Now we will learn about Converters and Metadata
Last modified 10mo ago
Export as PDF
Copy link