Skip to content
The Chat Archive
qwen3-235b-a22b-no-thinking· Alibaba (Qwen) LMArena Human Preference 140K

przygotuj analogiczne rozwiązanie dla cqrs

  1. User

    przygotuj analogiczne rozwiązanie dla cqrs

  2. 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:

    1. Commands – żądania zmiany stanu systemu.
    2. Command Handlers – odpowiedzialne za przetwarzanie poleceń i modyfikację modelu domeny.
    3. Queries – żądania pobierania danych.
    4. Query Handlers – odpowiedzialne za odczyt danych z zoptymalizowanego read store.
    5. Write Model – model biznesowy służący do operacji zapisu.
    6. Read Model – zoptymalizowany model danych służący do odczytu.
    7. 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.cs

    public class PlaceOrderCommand
    {
        public int UserId { get; set; }
        public List<OrderItemDto> Items { get; set; }
        public AddressDto ShippingAddress { get; set; }
    }
    

    Application/Queries/GetUserOrdersQuery.cs

    public class GetUserOrdersQuery
    {
        public int UserId { get; set; }
    }
    

    3️⃣ Definicja Handlerów

    Application/Handlers/PlaceOrderCommandHandler.cs

    public 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.cs

    public 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.cs

    public 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.cs

    public 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.cs

    public 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.cs

    public 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.cs

    public 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.cs lub Startup.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

    ZaletaOpis
    Oddzielenie operacji zapisu i odczytuPozwala na niezależną optymalizację obu kierunków
    SkalowalnośćMożliwość skalowania read/write modeli osobno
    PerformanceZoptymalizowane modele odczytowe pozwalają na szybsze pobieranie danych
    Obsługa eventual consistencyIdealne do integracji z EDA
    Prostsze testowanieProstsza logika handlerów
    Separacja odpowiedzialnościJasna separacja między biznesową logiką a prezentacją danych

    🔄 Schemat działania przy tworzeniu zamówienia

    1. Klient wysyła żądanie POST /api/orders z danymi zamówienia.
    2. Kontroler przekazuje dane do PlaceOrderCommand.
    3. PlaceOrderCommandHandler:
      • Tworzy nowe zamówienie w domenie.
      • Zapisuje je w OrderWriteRepository.
      • Publikuje zdarzenie OrderPlacedEvent.
    4. OrderPlacedEventHandler:
      • Odbiera zdarzenie.
      • Aktualizuje OrderReadModel w OrderReadRepository.
    5. Inny klient może pobrać dane przez GET /api/orders/{userId} – obsługiwane przez GetUserOrdersQuery.

    📌 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ć?

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.