DDD

Domain Driven Design

Domain-driven design (DDD) is an approach to software development that focuses on aligning the structure and behavior of software with the needs of the business domain. It emphasizes collaboration between developers, domain experts, and stakeholders to create a shared understanding of the problem domain and to design software that is tailored to the needs of that domain.

A simple example could be an e-commerce website. In this case, the domain is the products and customer orders. The domain-driven design would involve creating a model for the products, a model for the customer orders, and the necessary business logic to handle the creation of orders, payment processing, and so on.

Domain-Driven Design (DDD) is an approach to software development that emphasizes the importance of the business domain and domain logic. It focuses on creating a shared understanding of the domain among stakeholders and developers. The main idea is to align the software model closely with the business domain, facilitating better communication and understanding.

Key Concepts of DDD Domain: The subject area to which the user applies the program. It’s the business or real-world context where the software operates. Entity: An object that has a distinct identity that runs through time and different states. E.g., a Customer with a unique identifier. Value Object: An object that describes some characteristic or attribute but has no identity. E.g., an Address. Aggregate: A cluster of domain objects that can be treated as a single unit. It consists of an entity (the aggregate root) and possibly other entities and value objects. Repository: A mechanism for encapsulating storage, retrieval, and search behavior which emulates a collection of objects. Service: A stateless object that performs operations, typically containing business logic that doesn’t naturally fit within an entity or value object. Factory: An object responsible for creating other objects, especially complex aggregates. Implementing DDD in C++ Let’s walk through a basic implementation of these concepts using C++.

1. Entity

An entity has an identity that runs through different states. Let’s consider a Customer entity.

#include <string>

class Customer {
private:
    std::string id;
    std::string name;

public:
    Customer(const std::string& id, const std::string& name) : id(id), name(name) {}

    std::string getId() const {
        return id;
    }

    std::string getName() const {
        return name;
    }

    void setName(const std::string& newName) {
        name = newName;
    }

    bool operator==(const Customer& other) const {
        return id == other.id;
    }
};

2. Value Object

A value object doesn’t have an identity. Let’s consider an Address value object.

#include <string>

class Address {
private:
    std::string street;
    std::string city;
    std::string zipCode;

public:
    Address(const std::string& street, const std::string& city, const std::string& zipCode) 
        : street(street), city(city), zipCode(zipCode) {}

    std::string getStreet() const {
        return street;
    }

    std::string getCity() const {
        return city;
    }

    std::string getZipCode() const {
        return zipCode;
    }

    bool operator==(const Address& other) const {
        return street == other.street && city == other.city && zipCode == other.zipCode;
    }
};

3. Aggregate

An aggregate is a cluster of related entities and value objects. The aggregate root is the main entity that provides access to the aggregate.

#include <vector>

class Order {
private:
    std::string orderId;
    Customer customer;
    std::vector<Address> addresses;

public:
    Order(const std::string& orderId, const Customer& customer)
        : orderId(orderId), customer(customer) {}

    std::string getOrderId() const {
        return orderId;
    }

    Customer getCustomer() const {
        return customer;
    }

    void addAddress(const Address& address) {
        addresses.push_back(address);
    }

    std::vector<Address> getAddresses() const {
        return addresses;
    }
};

4. Repository

A repository handles data storage and retrieval. It’s an abstraction that mimics a collection of entities.

#include <unordered_map>

class CustomerRepository {
private:
    std::unordered_map<std::string, Customer> customers;

public:
    void addCustomer(const Customer& customer) {
        customers[customer.getId()] = customer;
    }

    std::optional<Customer> getCustomer(const std::string& id) const {
        auto it = customers.find(id);
        if (it != customers.end()) {
            return it->second;
        }
        return std::nullopt;
    }

    void removeCustomer(const std::string& id) {
        customers.erase(id);
    }
};

5. Service

A service contains business logic that doesn’t fit naturally into an entity or value object.

#include <string>
#include <iostream>

class CustomerService {
private:
    CustomerRepository& customerRepository;

public:
    CustomerService(CustomerRepository& customerRepository) 
        : customerRepository(customerRepository) {}

    void registerCustomer(const std::string& id, const std::string& name) {
        Customer customer(id, name);
        customerRepository.addCustomer(customer);
        std::cout << "Customer registered: " << name << std::endl;
    }

    void updateCustomerName(const std::string& id, const std::string& newName) {
        auto customerOpt = customerRepository.getCustomer(id);
        if (customerOpt.has_value()) {
            Customer customer = customerOpt.value();
            customer.setName(newName);
            customerRepository.addCustomer(customer);
            std::cout << "Customer updated: " << newName << std::endl;
        } else {
            std::cout << "Customer not found" << std::endl;
        }
    }
};

Putting It All Together

Here is how you might use these classes together:

#include "Customer.h"
#include "Address.h"
#include "Order.h"
#include "CustomerRepository.h"
#include "CustomerService.h"

int main() {
    CustomerRepository customerRepo;
    CustomerService customerService(customerRepo);

    // Register a new customer
    customerService.registerCustomer("1", "John Doe");

    // Update customer name
    customerService.updateCustomerName("1", "John Smith");

    // Fetch customer details
    auto customerOpt = customerRepo.getCustomer("1");
    if (customerOpt.has_value()) {
        Customer customer = customerOpt.value();
        std::cout << "Customer ID: " << customer.getId() << std::endl;
        std::cout << "Customer Name: " << customer.getName() << std::endl;
    }

    return 0;
}

Conclusion

In this article, we introduced the concepts of Domain-Driven Design (DDD) and how to use them in C++. DDD is a powerful approach to software design that emphasizes understanding and modeling the business domain. Using C++, you can implement DDD principles by creating classes and structures that reflect the business entities, value objects, aggregates, repositories, and services. This approach helps create software that is more aligned with business needs and easier to maintain and evolve.

By following the examples and concepts outlined here, you can start applying DDD principles in your C++ projects, leading to more robust and maintainable code.

Ddd

DDD