CQRS (Command Query Responsibility Segregation) — это архитектурный паттерн, который разделяет операции чтения и записи данных в приложении. Если вы столкнулись с ситуацией, когда ваше PHP-приложение начинает "задыхаться" под нагрузкой, или модель данных стала настолько сложной, что каждое изменение превращается в головную боль — самое время взглянуть на CQRS. Суть подхода заключается в простом принципе: разделение ответственности между командами (commands), которые меняют состояние системы, и запросами (queries), которые лишь извлекают данные. Такое разделение позволяет оптимизировать каждую сторону независимо, что особенно ценно для сложных бизнес-приложений на PHP.
Концепция была предложена Грегом Янгом, который развил идеи из CQS (Command-Query Separation) — принципа, сформулированного Бертраном Мейером еще в 1980-х годах. Янг расширил этот принцип до архитектурного уровня, применив его к системам с высокой нагрузкой и сложной бизнес-логикой. Традиционный CRUD-подход, используемый во многих PHP-приложениях, предполагает работу с одной и той же моделью данных как для чтения, так и для записи. Это удобно для небольших приложений, но может создавать проблемы при масштабировании:
| PHP | 1
2
3
4
5
| // Типичный CRUD-подход в PHP
class ProductRepository {
public function find($id) { /* получение данных */ }
public function save(Product $product) { /* сохранение данных */ }
} |
|
| PHP | 1
2
3
4
5
6
7
8
| // Разделение ответственности в CQRS
class ProductCommandHandler {
public function handle(CreateProductCommand $command) { /* обработка команды */ }
}
class ProductQueryHandler {
public function handle(GetProductQuery $query) { /* выполнение запроса */ }
} |
|
1. Разрыв между бизнес-требованиями и техническими моделями. CQRS позволяет моделировать команды в терминах, понятных бизнес-пользователям, а запросы оптимизировать для конкретных представлений.
2. Узкие места производительности. Чтение и запись данных часто имеют различные характеристики нагрузки. CQRS позволяет масштабировать их независимо.
3. Сложность доменной модели. В сложных PHP-приложениях модели начинают обрастать ответственностью как за бизнес-логику, так и за представление данных. CQRS позволяет разделить эти заботы.
4. Конфликты параллельного доступа. Особенно при высокой частоте операций записи, традиционные механизмы блокировок могут стать узким местом. CQRS в сочетании с Event Sourcing предлагает элегантное решение этой проблемы.
В PHP этот паттерн особенно полезен для проектов, перерастающих стандартные конфигурации LAMP или LEMP. Многие приложения на PHP изначально проектируются для средней нагрузки, но с ростом популярности начинают испытывать проблемы с производительностью. CQRS дает возможность масштабировать приложение без полного переписывания кодовой базы.
Когда стоит задуматься о CQRS для PHP-проекта? Я бы выделил несколько индикаторов:- Вы заметили, что формы и отчеты требуют все более сложных манипуляций с данными.
- Ваше приложение должно поддерживать высокую доступность при периодических пиках нагрузки.
- Доменная модель становится громоздкой из-за разных требований к чтению и записи.
- Требуется аудит всех изменений состояния системы.
Архитектурные основы
Чтобы по-настоящему оценить мощь CQRS, нужно сравнить его с традиционной моделью построения PHP-приложений. В классической трехслойной архитектуре (презентационный слой, бизнес-логика, доступ к данным) одна и та же модель данных используется как для чтения, так и для записи. Эта универсальность кажется удобной, но быстро превращается в ограничение при росте сложности приложения. Представьте интернет-магазин на PHP. В традиционной модели класс Product используется и для отображения товара покупателю, и для изменения его характеристик администратором, и для расчета стоимости заказа. Каждое новое требование делает этот класс все более раздутым и сложным.
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| // Традиционная модель в PHP
class Product {
private $id;
private $name;
private $price;
private $stock;
private $category;
private $attributes = [];
// Десятки методов для разных задач
public function calculateDiscountedPrice() { /* ... */ }
public function isAvailableForShipping() { /* ... */ }
public function updateInventory($quantity) { /* ... */ }
// ... и еще много методов
} |
|
Ключевым элементом CQRS являются команды и запросы. Команды — это объекты, представляющие намерение изменить состояние системы. Они называются в императивной форме, например CreateProductCommand, UpdateInventoryCommand. Запросы же описывают намерение получить данные, например GetProductQuery или ListProductsByCategoryQuery.
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| // Команда в CQRS
class CreateProductCommand {
public $name;
public $price;
public $initialStock;
public $categoryId;
public function __construct($name, $price, $initialStock, $categoryId) {
$this->name = $name;
$this->price = $price;
$this->initialStock = $initialStock;
$this->categoryId = $categoryId;
}
}
// Запрос в CQRS
class GetProductDetailsQuery {
public $productId;
public function __construct($productId) {
$this->productId = $productId;
}
} |
|
Обработка команд и запросов происходит в специализированных обработчиках. Обработчик команд реализует бизнес-логику изменения системы, а обработчик запросов оптимизирован для быстрого получения данных.
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| // Обработчик команды
class CreateProductCommandHandler {
private $repository;
public function __construct(ProductWriteRepository $repository) {
$this->repository = $repository;
}
public function handle(CreateProductCommand $command) {
// Проверка бизнес-правил
if ($command->price <= 0) {
throw new InvalidArgumentException("Price must be positive");
}
// Создание и сохранение продукта
$product = new ProductWriteModel();
$product->setName($command->name);
$product->setPrice($command->price);
$product->setStock($command->initialStock);
$product->setCategoryId($command->categoryId);
$this->repository->save($product);
return $product->getId();
}
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
| // Событие в системе с Event Sourcing
class ProductPriceChangedEvent {
public $productId;
public $oldPrice;
public $newPrice;
public $changedAt;
public $changedBy;
// Конструктор и геттеры
} |
|
Типичная ошибка новичков — думать, что CQRS требует полного дублирования данных. Это не так. Можно использовать одну и ту же базу данных с разными слоями абстракции для чтения и записи. Но на практике часто выгодно использовать разные хранилища: нормализованную реляционную БД для команд и денормализованную NoSQL для запросов.
Синхронизация между моделями может быть ахилессовой пятой CQRS. При создании или изменении данных через командную часть нужно обновить представление данных для запросной части. Это можно делать синхронно, но чаще используется асинхронный подход:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| // Слушатель события для обновления модели чтения
class ProductCreatedEventListener {
private $readRepository;
public function __construct(ProductReadRepository $readRepository) {
$this->readRepository = $readRepository;
}
public function handle(ProductCreatedEvent $event) {
$productReadModel = new ProductReadModel();
$productReadModel->setId($event->getProductId());
$productReadModel->setName($event->getName());
$productReadModel->setPrice($event->getPrice());
$productReadModel->setCategoryName($this->getCategoryName($event->getCategoryId()));
$this->readRepository->save($productReadModel);
}
private function getCategoryName($categoryId) {
// Получение имени категории
}
} |
|
Что лучше - PHP и MySQL или PHP и MySQL с использованием ООП и паттерна MVC?
знание в веб программирование можна сказать равно нулю... приходилось делать программы на языке вба.
хачут делать праграми для магазинов... Php и MySQL Event Scheduler
Можно ли как ни будь средствами php сделать событие в mysql? Т.е. мне нужно создать новую запись в таблице и через какое то определённое время она... Нужна информация по Event Sourcing
DDD, CQRS и Event Sourcing - это три термина, вокруг которых крутится моя дипломная работа. Ни об одном из них не только не имею понятия, но и не... Реализация паттерна Singleton
Добрый день. Необходимо реализовать класс Storage, объект которого будет единственным в программе. Для достижения данной цели было выбрано...
Реализация на PHP
Структура проекта с CQRS будет отличаться от традиционного MVC-приложения, хотя многие компоненты могут показаться знакомыми. Для начала определим базовую структуру каталогов PHP-проекта с CQRS:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| /src
/Domain
/Model # Доменные сущности
/Event # События домена
/Application
/Command # Команды
/CommandHandler # Обработчики команд
/Query # Запросы
/QueryHandler # Обработчики запросов
/DTO # Объекты передачи данных
/Infrastructure
/Repository # Репозитории для работы с хранилищем
/Persistence # Реализация хранилища
/UI
/Web # Веб-интерфейс
/API # API для внешних систем
/tests # Тесты |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
| // src/Application/Command/CommandInterface.php
namespace App\Application\Command;
interface CommandInterface
{
// Маркерный интерфейс для идентификации команд
}
// src/Application/Query/QueryInterface.php
namespace App\Application\Query;
interface QueryInterface
{
// Маркерный интерфейс для идентификации запросов
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
| // src/Application/CommandHandler/CommandHandlerInterface.php
namespace App\Application\CommandHandler;
use App\Application\Command\CommandInterface;
interface CommandHandlerInterface
{
public function handle(CommandInterface $command);
}
// src/Application/QueryHandler/QueryHandlerInterface.php
namespace App\Application\QueryHandler;
use App\Application\Query\QueryInterface;
interface QueryHandlerInterface
{
public function handle(QueryInterface $query);
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
| // src/Application/CommandBus.php
namespace App\Application;
use App\Application\Command\CommandInterface;
class CommandBus
{
private $handlers = [];
public function registerHandler(string $commandClass, callable $handler): void
{
$this->handlers[$commandClass] = $handler;
}
public function dispatch(CommandInterface $command)
{
$commandClass = get_class($command);
if (!isset($this->handlers[$commandClass])) {
throw new \RuntimeException("No handler registered for command $commandClass");
}
return call_user_func($this->handlers[$commandClass], $command);
}
}
// src/Application/QueryBus.php
namespace App\Application;
use App\Application\Query\QueryInterface;
class QueryBus
{
private $handlers = [];
public function registerHandler(string $queryClass, callable $handler): void
{
$this->handlers[$queryClass] = $handler;
}
public function dispatch(QueryInterface $query)
{
$queryClass = get_class($query);
if (!isset($this->handlers[$queryClass])) {
throw new \RuntimeException("No handler registered for query $queryClass");
}
return call_user_func($this->handlers[$queryClass], $query);
}
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
| // src/Application/Command/CreateProductCommand.php
namespace App\Application\Command;
class CreateProductCommand implements CommandInterface
{
public $id;
public $name;
public $price;
public $description;
public function __construct(string $id, string $name, float $price, string $description)
{
$this->id = $id;
$this->name = $name;
$this->price = $price;
$this->description = $description;
}
}
// src/Application/CommandHandler/CreateProductCommandHandler.php
namespace App\Application\CommandHandler;
use App\Application\Command\CommandInterface;
use App\Application\Command\CreateProductCommand;
use App\Domain\Model\Product;
use App\Infrastructure\Repository\ProductRepository;
class CreateProductCommandHandler implements CommandHandlerInterface
{
private $repository;
public function __construct(ProductRepository $repository)
{
$this->repository = $repository;
}
public function handle(CommandInterface $command)
{
if (!$command instanceof CreateProductCommand) {
throw new \InvalidArgumentException('Invalid command');
}
$product = new Product(
$command->id,
$command->name,
$command->price,
$command->description
);
$this->repository->save($product);
return $product->getId();
}
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
| // src/Application/Query/GetProductQuery.php
namespace App\Application\Query;
class GetProductQuery implements QueryInterface
{
public $id;
public function __construct(string $id)
{
$this->id = $id;
}
}
// src/Application/QueryHandler/GetProductQueryHandler.php
namespace App\Application\QueryHandler;
use App\Application\DTO\ProductDTO;
use App\Application\Query\GetProductQuery;
use App\Application\Query\QueryInterface;
use App\Infrastructure\Repository\ProductReadRepository;
class GetProductQueryHandler implements QueryHandlerInterface
{
private $repository;
public function __construct(ProductReadRepository $repository)
{
$this->repository = $repository;
}
public function handle(QueryInterface $query)
{
if (!$query instanceof GetProductQuery) {
throw new \InvalidArgumentException('Invalid query');
}
$product = $this->repository->findById($query->id);
if (!$product) {
return null;
}
return new ProductDTO(
$product->getId(),
$product->getName(),
$product->getPrice(),
$product->getDescription()
);
}
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
| // src/Domain/Model/Product.php
namespace App\Domain\Model;
class Product
{
private $id;
private $name;
private $price;
private $description;
public function __construct(string $id, string $name, float $price, string $description)
{
$this->id = $id;
$this->name = $name;
$this->price = $price;
$this->description = $description;
}
// Геттеры и методы изменения состояния
public function getId(): string
{
return $this->id;
}
public function getName(): string
{
return $this->name;
}
public function getPrice(): float
{
return $this->price;
}
public function getDescription(): string
{
return $this->description;
}
public function updateDetails(string $name, float $price, string $description): void
{
$this->name = $name;
$this->price = $price;
$this->description = $description;
}
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
| // src/Application/DTO/ProductDTO.php
namespace App\Application\DTO;
class ProductDTO
{
public $id;
public $name;
public $price;
public $description;
public function __construct(string $id, string $name, float $price, string $description)
{
$this->id = $id;
$this->name = $name;
$this->price = $price;
$this->description = $description;
}
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| // src/Infrastructure/Repository/ProductRepository.php
namespace App\Infrastructure\Repository;
use App\Domain\Model\Product;
interface ProductRepository
{
public function findById(string $id): ?Product;
public function save(Product $product): void;
public function remove(string $id): void;
}
// src/Infrastructure/Repository/ProductReadRepository.php
namespace App\Infrastructure\Repository;
use App\Domain\Model\Product;
interface ProductReadRepository
{
public function findById(string $id): ?Product;
public function findAll(): array;
public function findByName(string $name): array;
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
| // src/Infrastructure/Persistence/PdoProductRepository.php
namespace App\Infrastructure\Persistence;
use App\Domain\Model\Product;
use App\Infrastructure\Repository\ProductRepository;
use PDO;
class PdoProductRepository implements ProductRepository
{
private $pdo;
public function __construct(PDO $pdo)
{
$this->pdo = $pdo;
}
public function findById(string $id): ?Product
{
$stmt = $this->pdo->prepare('SELECT * FROM products WHERE id = :id');
$stmt->execute(['id' => $id]);
$data = $stmt->fetch(PDO::FETCH_ASSOC);
if (!$data) {
return null;
}
return new Product(
$data['id'],
$data['name'],
$data['price'],
$data['description']
);
}
public function save(Product $product): void
{
$stmt = $this->pdo->prepare('
INSERT INTO products (id, name, price, description)
VALUES (:id, :name, :price, :description)
ON DUPLICATE KEY UPDATE
name = :name, price = :price, description = :description
');
$stmt->execute([
'id' => $product->getId(),
'name' => $product->getName(),
'price' => $product->getPrice(),
'description' => $product->getDescription()
]);
}
public function remove(string $id): void
{
$stmt = $this->pdo->prepare('DELETE FROM products WHERE id = :id');
$stmt->execute(['id' => $id]);
}
} |
|
| YAML | 1
2
3
4
5
6
7
8
9
10
11
| # config/services.yaml (для Symfony)
services:
App\Application\CommandBus:
autowire: true
App\Application\QueryBus:
autowire: true
App\Application\CommandHandler\CreateProductCommandHandler:
autowire: true
tags: ['command_handler'] |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
| // src/Infrastructure/Symfony/CommandHandlerCompilerPass.php
namespace App\Infrastructure\Symfony;
use App\Application\CommandBus;
use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Reference;
class CommandHandlerCompilerPass implements CompilerPassInterface
{
public function process(ContainerBuilder $container)
{
if (!$container->has(CommandBus::class)) {
return;
}
$definition = $container->findDefinition(CommandBus::class);
$taggedServices = $container->findTaggedServiceIds('command_handler');
foreach ($taggedServices as $id => $tags) {
$handlerClass = $container->getDefinition($id)->getClass();
$reflection = new \ReflectionClass($handlerClass);
$methods = $reflection->getMethods(\ReflectionMethod::IS_PUBLIC);
foreach ($methods as $method) {
if ($method->getName() === 'handle' && $method->getNumberOfParameters() === 1) {
$params = $method->getParameters();
$commandType = $params[0]->getClass()->getName();
$definition->addMethodCall(
'registerHandler',
[$commandType, [new Reference($id), 'handle']]
);
break;
}
}
}
}
} |
|
Практические примеры
Давайте рассмотрим несколько реальных примеров применения CQRS в PHP-проектах разной сложности и назначения. Начнем с простого приложения для управления задачами (to-do list). Хотя этот пример может показаться тривиальным, он хорошо демонстрирует базовые принципы CQRS без излишних сложностей. Вот как будет выглядеть наше приложение с точки зрения основных компонентов CQRS:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
| // Определение команды для создания задачи
class CreateTaskCommand implements CommandInterface
{
public $taskId;
public $title;
public $description;
public $dueDate;
public $userId;
public function __construct(string $taskId, string $title, string $description,
\DateTimeImmutable $dueDate, string $userId)
{
$this->taskId = $taskId;
$this->title = $title;
$this->description = $description;
$this->dueDate = $dueDate;
$this->userId = $userId;
}
}
// Обработчик команды
class CreateTaskCommandHandler
{
private $writeRepository;
private $eventDispatcher;
public function __construct(TaskWriteRepository $writeRepository, EventDispatcher $eventDispatcher)
{
$this->writeRepository = $writeRepository;
$this->eventDispatcher = $eventDispatcher;
}
public function handle(CreateTaskCommand $command): void
{
// Создаем доменную модель задачи
$task = new Task(
$command->taskId,
$command->title,
$command->description,
$command->dueDate,
$command->userId,
new \DateTimeImmutable()
);
// Сохраняем в хранилище для записи
$this->writeRepository->save($task);
// Отправляем событие о создании задачи для обновления модели чтения
$this->eventDispatcher->dispatch(new TaskCreatedEvent($task));
}
}
// Запрос для получения списка задач пользователя
class GetUserTasksQuery implements QueryInterface
{
public $userId;
public $status;
public function __construct(string $userId, string $status = null)
{
$this->userId = $userId;
$this->status = $status;
}
}
// Обработчик запроса
class GetUserTasksQueryHandler
{
private $readRepository;
public function __construct(TaskReadRepository $readRepository)
{
$this->readRepository = $readRepository;
}
public function handle(GetUserTasksQuery $query): array
{
return $this->readRepository->findByUserIdAndStatus(
$query->userId,
$query->status
);
}
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
| // Интерфейс репозитория для записи
interface TaskWriteRepository
{
public function save(Task $task): void;
public function remove(string $id): void;
}
// Интерфейс репозитория для чтения
interface TaskReadRepository
{
public function findById(string $id): ?TaskReadModel;
public function findByUserIdAndStatus(string $userId, ?string $status): array;
}
// Реализация репозитория для записи с использованием MySQL
class MySqlTaskWriteRepository implements TaskWriteRepository
{
private $pdo;
public function __construct(\PDO $pdo)
{
$this->pdo = $pdo;
}
public function save(Task $task): void
{
$stmt = $this->pdo->prepare('
INSERT INTO tasks (id, title, description, due_date, user_id, created_at, status)
VALUES (:id, :title, :description, :dueDate, :userId, :createdAt, :status)
ON DUPLICATE KEY UPDATE
title = :title, description = :description, due_date = :dueDate, status = :status
');
$stmt->execute([
'id' => $task->getId(),
'title' => $task->getTitle(),
'description' => $task->getDescription(),
'dueDate' => $task->getDueDate()->format('Y-m-d H:i:s'),
'userId' => $task->getUserId(),
'createdAt' => $task->getCreatedAt()->format('Y-m-d H:i:s'),
'status' => $task->getStatus()
]);
}
// Остальные методы...
}
// Реализация репозитория для чтения с использованием Redis
class RedisTaskReadRepository implements TaskReadRepository
{
private $redis;
public function __construct(\Redis $redis)
{
$this->redis = $redis;
}
public function findById(string $id): ?TaskReadModel
{
$data = $this->redis->hGetAll('task:' . $id);
if (empty($data)) {
return null;
}
return $this->createTaskReadModel($data);
}
public function findByUserIdAndStatus(string $userId, ?string $status): array
{
$taskIds = $this->redis->sMembers('user_tasks:' . $userId);
if (empty($taskIds)) {
return [];
}
$tasks = [];
foreach ($taskIds as $taskId) {
$task = $this->findById($taskId);
// Фильтруем по статусу, если он указан
if ($task !== null && ($status === null || $task->status === $status)) {
$tasks[] = $task;
}
}
return $tasks;
}
// Остальные методы...
} |
|
Теперь давайте рассмотрим более сложный пример — систему управления контентом (CMS) с CQRS. В такой системе мы имеем дело с разными типами контента (статьи, страницы, медиафайлы), сложным управлением правами доступа и необходимостью поддерживать высокую производительность. Для CMS особенно важно оптимизировать чтение, так как обычно операции чтения многократно превышают операции записи. Вот фрагмент такой системы:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
| // Команда для публикации статьи
class PublishArticleCommand implements CommandInterface
{
public $articleId;
public $editorId;
public $publishDate;
// Конструктор и другие свойства...
}
// Обработчик команды публикации
class PublishArticleCommandHandler
{
private $articleRepository;
private $userRepository;
private $eventDispatcher;
// Конструктор с инъекцией зависимостей...
public function handle(PublishArticleCommand $command): void
{
// Проверяем права доступа редактора
$editor = $this->userRepository->findById($command->editorId);
if (!$editor->hasPermission('publish_articles')) {
throw new AccessDeniedException('Editor does not have permission to publish articles');
}
// Получаем статью
$article = $this->articleRepository->findById($command->articleId);
if (!$article) {
throw new EntityNotFoundException('Article not found');
}
// Проверяем, что статья готова к публикации
if (!$article->isReadyForPublishing()) {
throw new DomainException('Article is not ready for publishing');
}
// Публикуем статью
$article->publish($editor, $command->publishDate ?: new \DateTimeImmutable());
// Сохраняем изменения
$this->articleRepository->save($article);
// Отправляем событие для обновления модели чтения
$this->eventDispatcher->dispatch(new ArticlePublishedEvent($article));
}
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
| class ArticlePublishedEventListener
{
private $readRepository;
private $categoryRepository;
private $tagRepository;
// Конструктор с инъекцией зависимостей...
public function handle(ArticlePublishedEvent $event): void
{
$article = $event->getArticle();
// Создаем обогащенную модель для чтения
$articleReadModel = new ArticleReadModel();
$articleReadModel->id = $article->getId();
$articleReadModel->title = $article->getTitle();
$articleReadModel->content = $article->getContent();
$articleReadModel->publishDate = $article->getPublishDate()->format('Y-m-d H:i:s');
// Добавляем дополнительную информацию для оптимизации чтения
$articleReadModel->authorName = $article->getAuthor()->getFullName();
$articleReadModel->categoryName = $this->categoryRepository->getNameById($article->getCategoryId());
$articleReadModel->tags = $this->tagRepository->getTagNamesByIds($article->getTagIds());
// Сохраняем в хранилище для чтения
$this->readRepository->save($articleReadModel);
}
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
| // Профилирование запросов в CMS
class ProfiledQueryBus implements QueryBusInterface
{
private $decoratedBus;
private $profiler;
public function __construct(QueryBusInterface $decoratedBus, Profiler $profiler)
{
$this->decoratedBus = $decoratedBus;
$this->profiler = $profiler;
}
public function dispatch(QueryInterface $query)
{
$startTime = microtime(true);
$queryName = get_class($query);
try {
$result = $this->decoratedBus->dispatch($query);
$endTime = microtime(true);
$this->profiler->recordQueryExecution(
$queryName,
$endTime - $startTime,
true
);
return $result;
} catch (\Exception $e) {
$endTime = microtime(true);
$this->profiler->recordQueryExecution(
$queryName,
$endTime - $startTime,
false,
$e->getMessage()
);
throw $e;
}
}
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| class CachedArticleReadRepository implements ArticleReadRepository
{
private $decoratedRepository;
private $cache;
private $cacheTTL;
// Конструктор...
public function findById(string $id): ?ArticleReadModel
{
$cacheKey = 'article:' . $id;
// Проверяем, есть ли статья в кэше
if ($this->cache->has($cacheKey)) {
return $this->cache->get($cacheKey);
}
// Если нет в кэше, получаем из основного хранилища
$article = $this->decoratedRepository->findById($id);
// Сохраняем в кэш, если статья найдена
if ($article !== null) {
$this->cache->set($cacheKey, $article, $this->cacheTTL);
}
return $article;
}
// Другие методы с аналогичной логикой кэширования...
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| // Асинхронный обработчик команд с использованием очередей
class AsyncCommandBus implements CommandBusInterface
{
private $syncCommandBus;
private $queueService;
public function __construct(CommandBusInterface $syncCommandBus, QueueService $queueService)
{
$this->syncCommandBus = $syncCommandBus;
$this->queueService = $queueService;
}
public function dispatch(CommandInterface $command, bool $async = false)
{
// Если команда должна быть выполнена асинхронно
if ($async) {
return $this->queueService->enqueue('commands', serialize($command));
}
// Иначе выполняем синхронно
return $this->syncCommandBus->dispatch($command);
}
} |
|
Ошибки при внедрении CQRS
При внедрении CQRS в существующие проекты разработчики часто сталкиваются с типичными ошибками. Одна из них — чрезмерное усложнение системы. Начинающие разработчики могут создавать слишком много команд и обработчиков, что приводит к "взрыву классов":
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| // Неправильный подход: создание отдельной команды для каждого свойства
class UpdateArticleTitleCommand implements CommandInterface {}
class UpdateArticleContentCommand implements CommandInterface {}
class UpdateArticleAuthorCommand implements CommandInterface {}
class UpdateArticleCategoryCommand implements CommandInterface {}
// И т.д.
// Правильный подход: единая команда для обновления статьи с опциональными параметрами
class UpdateArticleCommand implements CommandInterface
{
public $articleId;
public $title;
public $content;
public $authorId;
public $categoryId;
public function __construct(string $articleId, array $updates = [])
{
$this->articleId = $articleId;
foreach ($updates as $property => $value) {
if (property_exists($this, $property)) {
$this->$property = $value;
}
}
}
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
| // Смешанный подход: использование CQRS только там, где оно оправдано
class UserController
{
private $commandBus;
private $queryBus;
private $userRepository; // Традиционный репозиторий для простых операций
// Пример для сложной операции с использованием CQRS
public function registerUser(Request $request)
{
$command = new RegisterUserCommand(
Uuid::uuid4()->toString(),
$request->get('email'),
$request->get('password')
);
$userId = $this->commandBus->dispatch($command);
return new JsonResponse(['id' => $userId], 201);
}
// Пример для простой операции без CQRS
public function getUserProfile($userId)
{
$user = $this->userRepository->findById($userId);
if (!$user) {
return new JsonResponse(['error' => 'User not found'], 404);
}
return new JsonResponse([
'id' => $user->getId(),
'email' => $user->getEmail(),
'name' => $user->getName()
]);
}
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
| class ArticlePublishedEventListener
{
// ... (предыдущий код)
public function handle(ArticlePublishedEvent $event): void
{
$article = $event->getArticle();
$articleId = $article->getId();
// Проверяем, не была ли уже обработана эта публикация
$processingKey = 'processing:article_published:' . $articleId;
if ($this->lockService->isLocked($processingKey)) {
// Событие уже обрабатывается или было обработано
return;
}
// Блокируем ключ для предотвращения повторной обработки
$this->lockService->lock($processingKey, 300); // 5 минут
try {
// Логика обновления модели для чтения
// ...
// Разблокируем ключ после успешной обработки
$this->lockService->unlock($processingKey);
} catch (\Exception $e) {
// Логируем ошибку для последующего ручного вмешательства
$this->logger->error('Failed to process ArticlePublishedEvent', [
'articleId' => $articleId,
'error' => $e->getMessage()
]);
// Сохраняем событие в таблицу неудачных событий для повторной обработки
$this->failedEventRepository->save($event);
// Разблокируем ключ, чтобы позволить повторную обработку
$this->lockService->unlock($processingKey);
throw $e;
}
}
} |
|
Оценка подхода
Когда же применение CQRS действительно оправдано? Опыт показывает, что CQRS наиболее эффективен в следующих сценариях:
1. Высокие требования к производительности чтения при сравнительно низкой частоте операций записи. Классический пример — новостные сайты, где тысячи пользователей читают контент, но лишь единицы авторов его создают.
2. Сложные бизнес-правила и валидации при изменении данных, но простые операции чтения. Например, финансовые системы, где транзакция может требовать множества проверок, а получение баланса — простая операция.
3. Асинхронность и распределенность системы, когда операции записи и чтения могут происходить на разных серверах или даже в разных датацентрах.
4. Необходимость в полной истории изменений данных для аудита или воссоздания состояний системы (особенно в сочетании с Event Sourcing).
Опытные PHP-разработчики знают, что не стоит внедрять CQRS в простые CRUD-приложения или небольшие проекты с простой бизнес-логикой — это только усложнит код без заметной отдачи.
Изменение метрик производительности после внедрения CQRS часто впечатляет. Разработчики, переведшие свои PHP-приложения на этот паттерн, отмечают:
| PHP | 1
2
3
4
5
6
7
8
9
| // До CQRS
// Запрос на получение страницы с товаром
// Среднее время: 320 мс
// Peak memory usage: 14MB
// После CQRS
// То же самое, но с отдельной оптимизированной моделью для чтения
// Среднее время: 105 мс
// Peak memory usage: 8MB |
|
Однако у CQRS есть свои ограничения и сложности, которые нужно учитывать перед внедрением:- Дополнительная сложность архитектуры. Вместо единой модели данных мы управляем двумя отдельными, что увеличивает объем кода и усложняет его поддержку.
- Необходимость синхронизации данных между моделями для чтения и записи. Это может добавить задержку между фактическим изменением данных и их доступностью для пользователя.
- Проблемы с обеспечением согласованности данных. В распределенных системах с CQRS достижение строгой согласованности может быть сложным или даже невозможным — часто приходится работать с моделью согласованности в конечном счете (eventual consistency).
Повышенная сложность отладки. Когда поток данных разделен между командами и запросами, отследить путь данных через систему становится сложнее.
| PHP | 1
2
3
4
5
6
7
8
9
10
11
| // Пример сложности при отладке в CQRS
// Для понимания, как данные попали в систему, нужно отследить:
// 1. Какая команда была отправлена
// 2. Как она была обработана
// 3. Какие события были сгенерированы
// 4. Как эти события обновили модель для чтения
// 5. Какие запросы использовались для получения данных
// В традиционной архитектуре достаточно отследить:
// 1. Какой метод репозитория был вызван
// 2. Как данные были изменены |
|
- Обычный трехслойный архитектурный стиль с оптимизацией запросов на уровне БД.
- Repository Pattern с отдельными методами для специфических операций чтения.
- Кэширование результатов запросов без изменения базовой архитектуры.
- Подход "тонкая база данных, толстый уровень приложения", где оптимизация происходит через создание выделенных сервисов для разных типов операций.
Реализация паттерна Синглтон
Задача 5. Синглтон
Что нужно сделать
Синглтон — это порождающий паттерн проектирования, который гарантирует, что у класса есть только один... Реализация паттерна Observer
Есть задача с помощью паттерна Observer сделать так чтобы каждый раз как курсор находится над консольным окном - оно как-то на это реагировало... Реализация паттерна состояние
Парни, кто шарит, помогите реализовать паттерн. "Игра перемещение по лабиринту". Как можно проще. Реализация паттерна в java
Помогите, пожалуйста, реализовать:
1) паттерн proxy
2) паттерн prototype
в коде программы, расположенной ниже:
package concert;
import... Реализация паттерна MVC
Доброго времени суток.
Допустим у меня есть класс Database в котором 2 метода:
class Database
{
public OleDbConnection DBConnect() ... Реализация паттерна Стратегия
У меня задание, нужно реализовать паттерн Стратегия на примере моей программы, читал про сам паттерн, но не совсем понимаю, как реализовать на моей... Реализация паттерна MVVM
Добрый день, форумчане. Ни разу не пользовался данным паттерном программирования, прочитал уже кучу статей, но ни одна из них не может мне ответить... Реализация паттерна репозиторий на UML
Всем привет.
С одногрупниками на курсовой проект проектируем АИС автомойки. Моей задачей является показать 3 стратегии применения паттерна... Реализация паттерна Factory method
Всем привет.
В одном видео наткнулся на реализацию фабричного метода через статический метод. Но поскольку речь шла об объекте, у которого были... Реализация паттерна Observer от Microsoft
Совершенно случайно, нашел что интерфейс для данного паттерна создали за нас. Может кому-то пригодится.
Пример реализации наблюдателя
Пример... Реализация паттерна MVC с подключённой БД
Решился в образовательных целях свделать программку, использующую БД PostgreSQL в качестве хранилища данных. Хочу применить паттерн... Реализация паттерна Entity-Component-System
Возникло желание попробовать реализовать паттерн Entity-Component-System. Изрядно начитавшись статей я взялся за дело.
Сначала я реализовал такую...
|
