MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

Java领域驱动设计基础

2023-07-166.2k 阅读

一、领域驱动设计概述

领域驱动设计（Domain - Driven Design，DDD）是一种用于软件开发的架构方法，它强调将软件设计聚焦于核心业务领域。在复杂的业务场景中，传统的开发方式可能会导致代码结构混乱，业务逻辑难以维护和扩展。DDD 通过将业务领域分解为不同的子领域，识别出核心业务概念（即领域模型），并围绕这些模型构建软件系统，使代码能够更好地反映业务需求。

例如，在一个电商系统中，订单管理、商品管理、用户管理等可以看作是不同的子领域。每个子领域都有其独特的业务规则和操作，通过 DDD 可以将这些部分进行清晰的划分和设计。

二、Java 中的领域模型构建

  1. 实体（Entities）

    • 在 Java 中，实体是领域模型的核心部分，它具有唯一的标识（通常是一个 ID），并且其生命周期和业务状态在系统中是有意义的。例如，在一个用户管理子领域中，User 类可以被定义为一个实体。
    public class User {
    private Long id;
    private String username;
    private String password;

    public User(Long id, String username, String password) {
        this.id = id;
        this.username = username;
        this.password = password;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }
}
    • 这里 id 作为 User 实体的唯一标识，在系统中不同的 User 对象通过 id 来区分。即使两个 User 对象的 username 和 password 相同，但只要 id 不同，它们就是不同的实体。

  2. 值对象（Value Objects）

    • 值对象主要用于表示一些没有唯一标识，仅由其属性值来定义的对象。例如，在电商系统中，Address 可以作为一个值对象。
    public class Address {
    private String street;
    private String city;
    private String zipCode;

    public Address(String street, String city, String zipCode) {
        this.street = street;
        this.city = city;
        this.zipCode = zipCode;
    }

    public String getStreet() {
        return street;
    }

    public void setStreet(String street) {
        this.street = street;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getZipCode() {
        return zipCode;
    }

    public void setZipCode(String zipCode) {
        this.zipCode = zipCode;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass()!= o.getClass()) return false;
        Address address = (Address) o;
        return Objects.equals(street, address.street) &&
                Objects.equals(city, address.city) &&
                Objects.equals(zipCode, address.zipCode);
    }

    @Override
    public int hashCode() {
        return Objects.hash(street, city, zipCode);
    }
}
    • 两个 Address 对象如果它们的 street、city 和 zipCode 都相同，那么在业务上可以认为它们是同一个地址。这里通过重写 equals 和 hashCode 方法来实现基于属性值的相等性判断。

  3. 聚合（Aggregates）

    • 聚合是一组相关的实体和值对象的集合，它们作为一个整体进行操作。聚合有一个根实体，外部只能通过根实体来访问聚合内部的其他对象。以电商系统中的订单为例，Order 可以作为一个聚合根。
    import java.util.ArrayList;
import java.util.List;

public class Order {
    private Long id;
    private User user;
    private List<OrderItem> orderItems = new ArrayList<>();
    private Address shippingAddress;

    public Order(Long id, User user, Address shippingAddress) {
        this.id = id;
        this.user = user;
        this.shippingAddress = shippingAddress;
    }

    public Long getId() {
        return id;
    }

    public User getUser() {
        return user;
    }

    public List<OrderItem> getOrderItems() {
        return orderItems;
    }

    public Address getShippingAddress() {
        return shippingAddress;
    }

    public void addOrderItem(OrderItem orderItem) {
        orderItems.add(orderItem);
    }
}

class OrderItem {
    private Long id;
    private Product product;
    private int quantity;

    public OrderItem(Long id, Product product, int quantity) {
        this.id = id;
        this.product = product;
        this.quantity = quantity;
    }

    public Long getId() {
        return id;
    }

    public Product getProduct() {
        return product;
    }

    public int getQuantity() {
        return quantity;
    }
}

class Product {
    private Long id;
    private String name;
    private double price;

    public Product(Long id, String name, double price) {
        this.id = id;
        this.name = name;
        this.price = price;
    }

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}
    • 在这个例子中，Order 是聚合根，OrderItem、Product 等是聚合内部的实体或值对象。外部系统要操作订单中的订单项，只能通过 Order 的 addOrderItem 等方法，而不能直接访问 OrderItem。

三、领域服务（Domain Services）

  1. 概念与作用
    • 领域服务用于实现一些不属于特定实体或值对象的业务逻辑，这些逻辑通常涉及多个领域对象的交互。例如，在电商系统中，计算订单总价的逻辑，它涉及到 Order 中的多个 OrderItem 以及 Product 的价格信息，这就适合放在领域服务中实现。
  2. Java 实现示例 
    public class OrderService {
    public double calculateTotalPrice(Order order) {
        double totalPrice = 0;
        for (OrderItem orderItem : order.getOrderItems()) {
            Product product = orderItem.getProduct();
            totalPrice += product.getPrice() * orderItem.getQuantity();
        }
        return totalPrice;
    }
}
    • 在上述代码中，OrderService 的 calculateTotalPrice 方法实现了计算订单总价的业务逻辑。它通过遍历 Order 中的 OrderItem，获取每个 OrderItem 对应的 Product 的价格，并乘以数量后累加，得到订单的总价。

四、仓储（Repositories）

  1. 仓储的意义
    • 仓储在领域驱动设计中扮演着数据持久化和检索的角色。它为领域模型提供了一种抽象的数据访问方式，使得领域层不依赖于具体的数据存储技术（如关系型数据库、NoSQL 等）。以 User 实体为例，我们可以定义一个 UserRepository 来处理 User 对象的持久化和查询。
  2. Java 接口定义 
    public interface UserRepository {
    User findById(Long id);
    void save(User user);
    void delete(User user);
}
    • 这个接口定义了三个基本的操作：根据 id 查询用户、保存用户和删除用户。具体的实现可以根据不同的数据存储方式来编写。
  3. 基于关系型数据库的实现示例（使用 JDBC） 
    import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class JdbcUserRepository implements UserRepository {
    private static final String URL = "jdbc:mysql://localhost:3306/yourdatabase";
    private static final String USER = "yourusername";
    private static final String PASSWORD = "yourpassword";

    @Override
    public User findById(Long id) {
        String sql = "SELECT id, username, password FROM users WHERE id =?";
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             PreparedStatement statement = connection.prepareStatement(sql)) {
            statement.setLong(1, id);
            ResultSet resultSet = statement.executeQuery();
            if (resultSet.next()) {
                Long userId = resultSet.getLong("id");
                String username = resultSet.getString("username");
                String password = resultSet.getString("password");
                return new User(userId, username, password);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    @Override
    public void save(User user) {
        String sql = "INSERT INTO users (id, username, password) VALUES (?,?,?)";
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             PreparedStatement statement = connection.prepareStatement(sql)) {
            statement.setLong(1, user.getId());
            statement.setString(2, user.getUsername());
            statement.setString(3, user.getPassword());
            statement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void delete(User user) {
        String sql = "DELETE FROM users WHERE id =?";
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             PreparedStatement statement = connection.prepareStatement(sql)) {
            statement.setLong(1, user.getId());
            statement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
    • 这里 JdbcUserRepository 实现了 UserRepository 接口，使用 JDBC 来操作关系型数据库。通过这种方式，领域层的代码只依赖于 UserRepository 接口，而不关心具体是如何与数据库交互的，提高了代码的可维护性和可测试性。

五、领域事件（Domain Events）

  1. 领域事件的概念
    • 领域事件用于捕捉领域中发生的重要事件，这些事件通常会触发其他业务逻辑或系统操作。例如，在电商系统中，当订单状态变为“已支付”时，这就是一个领域事件。其他模块可能需要根据这个事件进行库存扣减、发送通知等操作。
  2. Java 实现领域事件示例
    • 首先定义领域事件接口：
    public interface DomainEvent {
    // 可以在这里定义一些通用的方法，如获取事件发生时间等
}
    • 然后定义具体的领域事件类，比如订单支付成功事件：
    import java.util.Date;

public class OrderPaidEvent implements DomainEvent {
    private Long orderId;
    private Date paidTime;

    public OrderPaidEvent(Long orderId, Date paidTime) {
        this.orderId = orderId;
        this.paidTime = paidTime;
    }

    public Long getOrderId() {
        return orderId;
    }

    public Date getPaidTime() {
        return paidTime;
    }
}
    • 接着可以定义事件监听器接口和具体的监听器。例如，库存扣减监听器：
    public interface DomainEventListener<T extends DomainEvent> {
    void handle(T event);
}

public class InventoryDeductionListener implements DomainEventListener<OrderPaidEvent> {
    @Override
    public void handle(OrderPaidEvent event) {
        // 根据订单 ID 进行库存扣减逻辑
        Long orderId = event.getOrderId();
        // 实际的库存扣减代码，这里假设存在一个 InventoryService 用于操作库存
        InventoryService inventoryService = new InventoryService();
        inventoryService.deduceInventoryByOrderId(orderId);
    }
}
    • 最后需要有一个事件发布机制，例如简单的基于内存的事件发布：
    import java.util.ArrayList;
import java.util.List;

public class DomainEventPublisher {
    private static List<DomainEventListener<?>> listeners = new ArrayList<>();

    public static void register(DomainEventListener<?> listener) {
        listeners.add(listener);
    }

    public static void publish(DomainEvent event) {
        for (DomainEventListener<?> listener : listeners) {
            if (listener.getClass().getGenericInterfaces()[0].equals(event.getClass())) {
                ((DomainEventListener<DomainEvent>) listener).handle(event);
            }
        }
    }
}
    • 在业务代码中，当订单支付成功时，可以发布事件：
    public class OrderPaymentService {
    public void payOrder(Order order) {
        // 支付逻辑
        // 支付成功后发布订单支付成功事件
        Date paidTime = new Date();
        OrderPaidEvent event = new OrderPaidEvent(order.getId(), paidTime);
        DomainEventPublisher.publish(event);
    }
}
    • 通过这种方式，当订单支付成功事件发生时，注册的库存扣减监听器会自动执行库存扣减操作。

六、分层架构与领域驱动设计的结合

  1. 分层架构概述
    • 常见的分层架构包括表现层（Presentation Layer）、应用层（Application Layer）、领域层（Domain Layer）和基础设施层（Infrastructure Layer）。表现层负责与用户交互，接收用户请求并返回响应；应用层协调领域层和基础设施层，处理应用逻辑；领域层包含核心业务逻辑和领域模型；基础设施层提供技术支持，如数据存储、消息队列等。
  2. Java 中分层架构与 DDD 的实现示例
    • 表现层（使用 Spring MVC 示例）
    import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/orders")
public class OrderController {
    private final OrderAppService orderAppService;

    @Autowired
    public OrderController(OrderAppService orderAppService) {
        this.orderAppService = orderAppService;
    }

    @PostMapping("/pay")
    public String payOrder(@RequestBody OrderDto orderDto) {
        // 将 OrderDto 转换为 Order 对象
        Order order = convertToOrder(orderDto);
        orderAppService.payOrder(order);
        return "Order paid successfully";
    }

    private Order convertToOrder(OrderDto orderDto) {
        // 实际的转换逻辑，这里简单示例
        User user = new User(orderDto.getUserId(), "", "");
        Address address = new Address(orderDto.getStreet(), orderDto.getCity(), orderDto.getZipCode());
        Order order = new Order(orderDto.getOrderId(), user, address);
        // 添加订单项等逻辑
        return order;
    }
}

class OrderDto {
    private Long orderId;
    private Long userId;
    private String street;
    private String city;
    private String zipCode;

    // 省略 getters 和 setters
}
    • 应用层
    import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class OrderAppService {
    private final OrderService orderService;
    private final UserRepository userRepository;
    private final OrderRepository orderRepository;

    @Autowired
    public OrderAppService(OrderService orderService, UserRepository userRepository, OrderRepository orderRepository) {
        this.orderService = orderService;
        this.userRepository = userRepository;
        this.orderRepository = orderRepository;
    }

    public void payOrder(Order order) {
        // 检查用户是否存在等逻辑
        User user = userRepository.findById(order.getUser().getId());
        if (user == null) {
            throw new RuntimeException("User not found");
        }
        // 调用领域服务支付订单
        orderService.payOrder(order);
        // 保存订单
        orderRepository.save(order);
    }
}
    • 领域层
    public class OrderService {
    public void payOrder(Order order) {
        // 实际的支付逻辑，例如调用支付网关
        System.out.println("Processing payment for order " + order.getId());
        // 支付成功后更新订单状态等逻辑
        // 发布订单支付成功领域事件
        Date paidTime = new Date();
        OrderPaidEvent event = new OrderPaidEvent(order.getId(), paidTime);
        DomainEventPublisher.publish(event);
    }
}
    • 基础设施层
    import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

public class JdbcOrderRepository implements OrderRepository {
    private static final String URL = "jdbc:mysql://localhost:3306/yourdatabase";
    private static final String USER = "yourusername";
    private static final String PASSWORD = "yourpassword";

    @Override
    public void save(Order order) {
        String sql = "INSERT INTO orders (id, user_id, shipping_street, shipping_city, shipping_zip_code) VALUES (?,?,?,?,?)";
        try (Connection connection = DriverManager.getConnection(URL, USER, PASSWORD);
             PreparedStatement statement = connection.prepareStatement(sql)) {
            statement.setLong(1, order.getId());
            statement.setLong(2, order.getUser().getId());
            statement.setString(3, order.getShippingAddress().getStreet());
            statement.setString(4, order.getShippingAddress().getCity());
            statement.setString(5, order.getShippingAddress().getZipCode());
            statement.executeUpdate();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}
    • 通过这种分层架构与 DDD 的结合，不同层次的职责清晰，领域层专注于核心业务逻辑，表现层和应用层负责与外部交互和协调，基础设施层提供技术支持，使得整个系统具有良好的可维护性和扩展性。

七、Java 中领域驱动设计的最佳实践

  1. 代码结构组织
    • 按照领域模型的划分来组织代码结构。例如，将与用户管理相关的实体、值对象、领域服务、仓储等放在一个名为 user 的包下，将订单管理相关的放在 order 包下。这样可以使代码结构清晰，易于理解和维护。
  2. 测试驱动开发（TDD）与 DDD 的结合
    • 在领域驱动设计中，采用测试驱动开发可以更好地保证代码质量。先编写测试用例，定义领域模型和领域服务的行为，然后再实现代码。例如，对于 OrderService 的 calculateTotalPrice 方法，可以先编写如下测试用例（使用 JUnit）：
    import org.junit.jupiter.api.Test;
import static org.junit.jupiter.api.Assertions.*;

public class OrderServiceTest {
    @Test
    public void testCalculateTotalPrice() {
        User user = new User(1L, "user1", "password1");
        Address address = new Address("123 Main St", "City1", "12345");
        Order order = new Order(1L, user, address);

        Product product1 = new Product(1L, "Product1", 10.0);
        OrderItem orderItem1 = new OrderItem(1L, product1, 2);
        order.addOrderItem(orderItem1);

        Product product2 = new Product(2L, "Product2", 5.0);
        OrderItem orderItem2 = new OrderItem(2L, product2, 3);
        order.addOrderItem(orderItem2);

        OrderService orderService = new OrderService();
        double totalPrice = orderService.calculateTotalPrice(order);
        assertEquals(35.0, totalPrice);
    }
}
    • 然后根据测试用例来实现 calculateTotalPrice 方法，这样可以确保方法的实现符合预期的业务逻辑。
  3. 持续集成与领域驱动设计
    • 在使用领域驱动设计进行开发时，持续集成（CI）非常重要。通过设置 CI 流程，每次代码提交时自动运行单元测试、集成测试等。例如，使用 Jenkins 或 GitLab CI/CD 等工具，当开发人员将代码推送到代码仓库时，CI 工具会自动拉取代码，编译项目，并运行测试用例。如果测试不通过，开发人员可以及时发现并修复问题，保证代码的质量和稳定性。

通过以上对 Java 领域驱动设计基础的详细阐述，包括领域模型构建、领域服务、仓储、领域事件、分层架构结合以及最佳实践等方面，希望能帮助开发人员在复杂业务场景下更好地运用 DDD 来构建健壮、可维护和可扩展的 Java 应用系统。在实际项目中，还需要根据具体的业务需求和团队情况，灵活运用这些概念和技术，不断优化系统设计。