przygotuj analogiczne rozwiązanie dla cqrs
- User
przygotuj analogiczne rozwiązanie dla cqrs
- Assistant
Oczywiście! Poniżej przedstawiam kompletne rozwiązanie architektury CQRS (Command Query Responsibility Segregation) dla platformy e-commerce, wraz z przykładem implementacji w technologii .NET. To podejście idealnie współgra z mikroserwisami i Event-Driven Architecture, które omawialiśmy wcześniej.
🧱 Architektura CQRS – Wysokopoziomowy schemat
┌────────────────────┐ ┌────────────────────┐ │ Command Client │ │ Query Client │ └─────────┬──────────┘ └─────────┬──────────┘ │ │ ▼ ▼ ┌────────────────────┐ ┌────────────────────┐ │ Command Handler ├────►│ Query Handler │ └─────────┬──────────┘ └─────────┬──────────┘ │ │ ▼ ▼ ┌────────────────────┐ ┌────────────────────┐ │ Domain Logic │ │ Read Model │ └─────────┬──────────┘ └─────────┬──────────┘ │ │ ▼ ▼ ┌────────────────────┐ ┌────────────────────┐ │ Write Model │ │ Read Store │ └────────────────────┘ └────────────────────┘ │ ▼ ┌────────────────────┐ │ Event Bus │ └────────────────────┘
📦 Kluczowe komponenty:
- Commands – żądania zmiany stanu systemu.
- Command Handlers – odpowiedzialne za przetwarzanie poleceń i modyfikację modelu domeny.
- Queries – żądania pobierania danych.
- Query Handlers – odpowiedzialne za odczyt danych z zoptymalizowanego read store.
- Write Model – model biznesowy służący do operacji zapisu.
- Read Model – zoptymalizowany model danych służący do odczytu.
- Event Bus – mechanizm propagujący zmiany z write modelu do read modeli.
🔨 Przykład: Zarządzanie zamówieniami (Order Management)
Zaimplementujemy CQRS dla funkcjonalności "Tworzenie zamówienia" i "Pobieranie listy zamówień użytkownika".
1️⃣ Struktura projektu
/src ├── Application/ │ ├── Commands/PlaceOrderCommand.cs │ ├── Handlers/PlaceOrderCommandHandler.cs │ ├── Queries/GetUserOrdersQuery.cs │ ├── Handlers/GetUserOrdersQueryHandler.cs │ ├── DTOs/OrderDto.cs ├── Domain/ │ ├── Models/Order.cs │ ├── IRepository/IOrderRepository.cs ├── Infrastructure/ │ ├── Persistence/OrderWriteRepository.cs │ ├── Persistence/OrderReadRepository.cs │ ├── EventBus/ ├── Api/ │ ├── Controllers/OrdersController.cs
2️⃣ Definicja Commandów i Query
Application/Commands/PlaceOrderCommand.cspublic class PlaceOrderCommand { public int UserId { get; set; } public List<OrderItemDto> Items { get; set; } public AddressDto ShippingAddress { get; set; } }Application/Queries/GetUserOrdersQuery.cspublic class GetUserOrdersQuery { public int UserId { get; set; } }
3️⃣ Definicja Handlerów
Application/Handlers/PlaceOrderCommandHandler.cspublic class PlaceOrderCommandHandler : ICommandHandler<PlaceOrderCommand> { private readonly IOrderWriteRepository _orderWriteRepository; private readonly IEventBus _eventBus; public PlaceOrderCommandHandler(IOrderWriteRepository orderWriteRepository, IEventBus eventBus) { _orderWriteRepository = orderWriteRepository; _eventBus = eventBus; } public async Task Handle(PlaceOrderCommand command, CancellationToken ct) { var order = new Order { UserId = command.UserId, Status = OrderStatus.Pending, CreatedAt = DateTime.UtcNow, Items = command.Items.Select(i => new OrderItem { ProductId = i.ProductId, Quantity = i.Quantity, UnitPrice = i.UnitPrice }).ToList(), ShippingAddress = new Address { Street = command.ShippingAddress.Street, City = command.ShippingAddress.City, PostalCode = command.ShippingAddress.PostalCode, Country = command.ShippingAddress.Country } }; await _orderWriteRepository.AddAsync(order, ct); // Publikacja zdarzenia var @event = new OrderPlacedEvent { OrderId = order.Id, UserId = order.UserId, Items = order.Items.Select(i => new OrderItemEvent { ProductId = i.ProductId, Quantity = i.Quantity, UnitPrice = i.UnitPrice }).ToList() }; await _eventBus.PublishAsync(@event, ct); } }Application/Handlers/GetUserOrdersQueryHandler.cspublic class GetUserOrdersQueryHandler : IQueryHandler<GetUserOrdersQuery, List<OrderDto>> { private readonly IOrderReadRepository _orderReadRepository; public GetUserOrdersQueryHandler(IOrderReadRepository orderReadRepository) { _orderReadRepository = orderReadRepository; } public async Task<List<OrderDto>> Handle(GetUserOrdersQuery query, CancellationToken ct) { return await _orderReadRepository.GetByUserIdAsync(query.UserId, ct); } }
4️⃣ Modele Danych
Domain/Models/Order.cspublic class Order { public int Id { get; set; } public int UserId { get; set; } public OrderStatus Status { get; set; } public DateTime CreatedAt { get; set; } public List<OrderItem> Items { get; set; } = new(); public Address ShippingAddress { get; set; } } public enum OrderStatus { Pending, Processing, Completed, Cancelled }Application/DTOs/OrderDto.cspublic class OrderDto { public int OrderId { get; set; } public int UserId { get; set; } public string Status { get; set; } public DateTime CreatedAt { get; set; } public decimal TotalAmount { get; set; } public List<OrderItemDto> Items { get; set; } public AddressDto ShippingAddress { get; set; } }
5️⃣ Repozytoria
Infrastructure/Persistence/OrderWriteRepository.cspublic class OrderWriteRepository : IOrderWriteRepository { private readonly AppDbContext _context; public OrderWriteRepository(AppDbContext context) => _context = context; public async Task AddAsync(Order order, CancellationToken ct) { await _context.Orders.AddAsync(order, ct); await _context.SaveChangesAsync(ct); } }Infrastructure/Persistence/OrderReadRepository.cspublic class OrderReadRepository : IOrderReadRepository { private readonly AppReadContext _context; public async Task<List<OrderDto>> GetByUserIdAsync(int userId, CancellationToken ct) { return await _context.Orders .Where(o => o.UserId == userId) .Select(o => new OrderDto { OrderId = o.Id, UserId = o.UserId, Status = o.Status.ToString(), CreatedAt = o.CreatedAt, TotalAmount = o.Items.Sum(i => i.Quantity * i.UnitPrice), Items = o.Items.Select(i => new OrderItemDto { ProductId = i.ProductId, Quantity = i.Quantity, UnitPrice = i.UnitPrice }).ToList(), ShippingAddress = new AddressDto { Street = o.ShippingAddress.Street, City = o.ShippingAddress.City, PostalCode = o.ShippingAddress.PostalCode, Country = o.ShippingAddress.Country } }) .ToListAsync(ct); } }
6️⃣ Kontroler API
Api/Controllers/OrdersController.cs[ApiController] [Route("api/[controller]")] public class OrdersController : ControllerBase { private readonly IMediator _mediator; public OrdersController(IMediator mediator) => _mediator = mediator; [HttpPost] public async Task<IActionResult> CreateOrder([FromBody] PlaceOrderCommand command) { await _mediator.Send(command); return Accepted(); } [HttpGet("{userId}")] public async Task<IActionResult> GetUserOrders(int userId) { var query = new GetUserOrdersQuery { UserId = userId }; var orders = await _mediator.Send(query); return Ok(orders); } }
7️⃣ Integracja z Event-Driven Architecture
Infrastructure/EventHandlers/OrderPlacedEventHandler.cspublic class OrderPlacedEventHandler : IEventHandler<OrderPlacedEvent> { private readonly IOrderReadRepository _orderReadRepository; public async Task HandleAsync(OrderPlacedEvent @event, CancellationToken ct) { var orderDto = new OrderDto { OrderId = @event.OrderId, UserId = @event.UserId, Status = "Pending", CreatedAt = @event.OccurredAt, Items = @event.Items.ToList(), TotalAmount = @event.Items.Sum(i => i.TotalPrice) }; await _orderReadRepository.SaveAsync(orderDto, ct); } }
8️⃣ Rejestrowanie usług DI
W pliku
Program.cslubStartup.cs:// Mediator (MediatR) builder.Services.AddMediatR(cfg => cfg.RegisterServicesFromAssembly(typeof(Program).Assembly)); // Repository builder.Services.AddScoped<IOrderWriteRepository, OrderWriteRepository>(); builder.Services.AddScoped<IOrderReadRepository, OrderReadRepository>(); // Event Handlers builder.Services.AddScoped<IEventHandler<OrderPlacedEvent>, OrderPlacedEventHandler>();
✅ Zalety rozwiązania CQRS
Zaleta Opis Oddzielenie operacji zapisu i odczytu Pozwala na niezależną optymalizację obu kierunków Skalowalność Możliwość skalowania read/write modeli osobno Performance Zoptymalizowane modele odczytowe pozwalają na szybsze pobieranie danych Obsługa eventual consistency Idealne do integracji z EDA Prostsze testowanie Prostsza logika handlerów Separacja odpowiedzialności Jasna separacja między biznesową logiką a prezentacją danych
🔄 Schemat działania przy tworzeniu zamówienia
- Klient wysyła żądanie POST
/api/ordersz danymi zamówienia. - Kontroler przekazuje dane do
PlaceOrderCommand. PlaceOrderCommandHandler:- Tworzy nowe zamówienie w domenie.
- Zapisuje je w
OrderWriteRepository. - Publikuje zdarzenie
OrderPlacedEvent.
OrderPlacedEventHandler:- Odbiera zdarzenie.
- Aktualizuje
OrderReadModelwOrderReadRepository.
- Inny klient może pobrać dane przez GET
/api/orders/{userId}– obsługiwane przezGetUserOrdersQuery.
📌 Podsumowanie
To rozwiązanie CQRS umożliwia:
- Oddzielenie logiki biznesowej od logiki odczytu.
- Skalowalność i elastyczność w mikroserwisach.
- Łatwe integrowanie z Event-Driven Architecture.
- Uproszczony dostęp do danych w przypadku skomplikowanych widoków.
Jeśli chcesz, mogę przygotować również gotowy kod źródłowy w postaci repozytorium GitHub, albo rozszerzyć to o np. walidacje (
FluentValidation), retry policy, caching czy bardziej zaawansowaną synchronizację modeli odczytowych (np. z użyciem Entity Framework Core + Raw SQL, Dapper, lub InMemory DB jak Redis).Czy chcesz kontynuować?
Other models, same or similar prompt
Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.