El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
HOME Els meus cursos Finalitzats
◄ Anterior
◄

Disseny Basat en Domini

Següent ►
►

El Disseny Basat en Domini (DDD, per les seves sigles en anglès) és una metodologia de desenvolupament de programari que posa èmfasi en la col·laboració entre experts en el domini i desenvolupadors per crear un model de domini que reflecteixi amb precisió les necessitats del negoci. En aquest mòdul, explorarem com aplicar els principis de DDD utilitzant F#.

Continguts

  1. Introducció al Disseny Basat en Domini
  2. Entitats i Valors
  3. Agregats i Repositoris
  4. Serveis de Domini
  5. Esdeveniments de Domini
  6. Exemple Pràctic
  7. Exercicis

Introducció al Disseny Basat en Domini

El DDD es basa en la creació d'un model de domini que reflecteixi les regles i la lògica del negoci. Aquest model es construeix a partir de la col·laboració entre desenvolupadors i experts en el domini.

Conceptes Clau

  • Model de Domini: Representació conceptual del domini del problema.
  • Ubiquitous Language: Un llenguatge comú utilitzat per tots els membres de l'equip per descriure el domini.
  • Context Limitat: Una part del model de domini que té un límit clar i definit.

Entitats i Valors

Entitats

Les entitats són objectes que tenen una identitat única i un cicle de vida. En F#, les entitats es poden definir utilitzant tipus de registre.

type CustomerId = CustomerId of Guid

type Customer = {
    Id: CustomerId
    Name: string
    Email: string
}

Valors

Els valors són objectes que no tenen identitat i es defineixen per les seves propietats. En F#, els valors es poden definir utilitzant tipus de registre o tipus de discriminació.

type Address = {
    Street: string
    City: string
    ZipCode: string
}

Agregats i Repositoris

Agregats

Un agregat és un conjunt d'entitats i valors que es tracten com una unitat. L'agregat té una entitat arrel que és responsable de la consistència de l'agregat.

type OrderId = OrderId of Guid

type Order = {
    Id: OrderId
    Customer: Customer
    Items: List<OrderItem>
}

Repositoris

Els repositoris són responsables de l'emmagatzematge i la recuperació d'agregats. En F#, els repositoris es poden definir utilitzant interfícies.

type IOrderRepository =
    abstract member GetById: OrderId -> Order option
    abstract member Save: Order -> unit

Serveis de Domini

Els serveis de domini encapsulen la lògica del domini que no pertany a cap entitat o valor específic. En F#, els serveis de domini es poden definir utilitzant mòduls o classes.

module OrderService =
    let placeOrder (order: Order) =
        // Lògica per processar la comanda
        ()

Esdeveniments de Domini

Els esdeveniments de domini representen fets significatius que han ocorregut en el domini. En F#, els esdeveniments de domini es poden definir utilitzant tipus de discriminació.

type OrderPlaced = {
    OrderId: OrderId
    CustomerId: CustomerId
    Items: List<OrderItem>
}

Exemple Pràctic

A continuació, es mostra un exemple pràctic d'aplicació del DDD en F#.

Definició del Model de Domini

type CustomerId = CustomerId of Guid
type OrderId = OrderId of Guid

type Customer = {
    Id: CustomerId
    Name: string
    Email: string
}

type OrderItem = {
    ProductId: Guid
    Quantity: int
}

type Order = {
    Id: OrderId
    Customer: Customer
    Items: List<OrderItem>
}

type OrderPlaced = {
    OrderId: OrderId
    CustomerId: CustomerId
    Items: List<OrderItem>
}

Implementació del Repositori

type IOrderRepository =
    abstract member GetById: OrderId -> Order option
    abstract member Save: Order -> unit

type InMemoryOrderRepository() =
    let mutable orders = Map.empty<OrderId, Order>
    interface IOrderRepository with
        member _.GetById(orderId) = Map.tryFind orderId orders
        member _.Save(order) = orders <- Map.add order.Id order orders

Implementació del Servei de Domini

module OrderService =
    let placeOrder (repository: IOrderRepository) (order: Order) =
        repository.Save(order)
        // Generar esdeveniment de domini
        let event = { OrderId = order.Id; CustomerId = order.Customer.Id; Items = order.Items }
        event

Exercicis

  1. Definir Entitats i Valors: Defineix les entitats i valors per a un sistema de gestió de biblioteques.
  2. Crear un Repositori: Implementa un repositori per a gestionar les comandes en un sistema de comerç electrònic.
  3. Implementar un Servei de Domini: Crea un servei de domini per a processar les devolucions de productes en un sistema de comerç electrònic.

Solucions

  1. Definir Entitats i Valors
type BookId = BookId of Guid
type MemberId = MemberId of Guid

type Book = {
    Id: BookId
    Title: string
    Author: string
}

type Member = {
    Id: MemberId
    Name: string
    Email: string
}
  1. Crear un Repositori
type IOrderRepository =
    abstract member GetById: OrderId -> Order option
    abstract member Save: Order -> unit

type InMemoryOrderRepository() =
    let mutable orders = Map.empty<OrderId, Order>
    interface IOrderRepository with
        member _.GetById(orderId) = Map.tryFind orderId orders
        member _.Save(order) = orders <- Map.add order.Id order orders
  1. Implementar un Servei de Domini
module ReturnService =
    let processReturn (repository: IOrderRepository) (orderId: OrderId) =
        match repository.GetById(orderId) with
        | Some order ->
            // Lògica per processar la devolució
            ()
        | None -> failwith "Order not found"

Conclusió

En aquest mòdul, hem explorat els conceptes clau del Disseny Basat en Domini i com aplicar-los utilitzant F#. Hem vist com definir entitats, valors, agregats, repositoris, serveis de domini i esdeveniments de domini. També hem treballat amb un exemple pràctic per consolidar els conceptes apresos. Amb aquests coneixements, estàs preparat per aplicar DDD en els teus projectes de F#.

◄ Anterior
◄
Següent ►
►
El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència
© Copyright 2024. Tots els drets reservats