DDD 很难，推荐一套小白也能轻松落地的方案！-51CTO.COM

DDD是微服务中经常用到的一种架构方式，在实际工作中，我们该如何快速落地一个 DDD工程呢？这篇文章，我们将手把手带你落地一个 DDD项目，不管你有没有 DDD经验，都可以轻松使用。

在开始我们的文章之前，我们还是要简单的了解下 DDD是什么，帮助我们下面更好地理解代码工程。

一、什么是DDD？

DDD，全称 Domain-Driven Design，翻译为领域驱动设计，它是一种软件开发方法论，由埃里克·埃文斯（Eric Evans）在其2003年出版的同名书籍中提出。DDD旨在通过密切关注复杂软件系统的核心业务领域，将业务需求与技术实现紧密结合，从而提高软件的可维护性、可扩展性和灵活性。

1. DDD 的核心理念

DDD 以领域为核心，强调将业务领域作为软件开发的核心，致力于深入理解业务需求和业务规则，通过建模来反映实际业务问题。

2. 统一语言

DDD使得开发团队和业务专家共同使用的一种准确、一致的语言（Ubiquitous Language），用于描述业务领域中的概念、流程和规则，减少沟通障碍，提高理解一致性。

3. 战略设计与战术设计

DDD 分为战略设计和战术设计两部分：

战略设计：关注整个系统的高层次结构和模块划分，定义不同的子域（Subdomain）和上下文边界（Bounded Context）。
战术设计：关注特定上下文内的细节，实现领域模型和相关组件。

说实话，DDD的理论确实很烧脑，我们会在后续的文章中慢慢拆解。不管怎样，在对 DDD有了简单的了解之后，我们要进入今天的核心部分：DDD代码实操。

本文目标：使用DDD + SpringBoot + JPA + 双数据源（MySQL + DynamoDB）实现对 user表进行添加和查询功能，完全适合小白操作。

二、项目整体结构

首先，我们先看下整个工程建的主要模块以及模块之间的依赖关系：

domain：核心领域模型和业务逻辑。
repository：仓储接口定义。
application：应用服务层，协调领域对象和仓储。
infrastructure：基础设施层，包括具体的仓储实现（MySQL 和 DynamoDB）、配置等。
config：独立的配置模块（可选，视项目复杂程度而定）。
api（或 web）：入口层，如 REST API 控制器，主要处理外部接口请求。

模块结构如下：

ddd-project/
├── build.gradle
├── settings.gradle
├── domain/
│   └── build.gradle
├── repository/
│   └── build.gradle
├── application/
│   └── build.gradle
├── infrastructure/
│   ├── build.gradle
│   ├── persistence-mysql/
│   │   └── build.gradle
│   └── persistence-dynamodb/
│       └── build.gradle
├── config/
│   └── build.gradle
└── api/
    └── build.gradle

三、项目模块详解

1. Gradle 配置

(1) 根项目 settings.gradle

在根项目的 settings.gradle 中，包含所有子模块：

rootProject.name = 'ddd-project'

include 'domain'
include 'repository'
include 'application'
include 'infrastructure'
include 'infrastructure:persistence-mysql'
include 'infrastructure:persistence-dynamodb'
include 'config'
include 'api'

(2) 根项目 build.gradle

根项目的 build.gradle 通常用于定义全局的插件和依赖管理。

plugins {
    id 'java'
    id 'org.springframework.boot' version '3.0.0' apply false
    id 'io.spring.dependency-management' version '1.1.0' apply false
}

allprojects {
    group = 'com.example'
    version = '1.0.0'
    
    repositories {
        mavenCentral()
    }
}

subprojects {
    apply plugin:'java'
    
    sourceCompatibility = '17'
    targetCompatibility = '17'

    dependencies {
        // 通用依赖，可以在此处添加
        implementation 'org.springframework.boot:spring-boot-starter'
        testImplementation 'org.springframework.boot:spring-boot-starter-test'
    }

    // 统一的测试任务配置等（可选）
}

2. 各子模块配置

(1) domain 模块

功能：定义核心领域模型和业务逻辑。

domain/build.gradle:

dependencies {
    // 无需依赖其他模块，专注于领域逻辑
}

示例代码：

// domain/src/main/java/com/example/domain/User.java
package com.example.domain;

publicclass User {
    private String id;
    private String name;
    private String email;

    // 构造函数、Getters 和 Setters

    public User() {}

    public User(String id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    // getters and setters
    public String getId() {
        return id;
    }

    // ... 其他 getters 和 setters
}

(2) repository 模块

功能：定义仓储接口，供应用层和基础设施层引用。

repository/build.gradle:

dependencies {
    implementation project(':domain')
}

示例代码：

// repository/src/main/java/com/example/repository/UserRepository.java
package com.example.repository;

import com.example.domain.User;
import java.util.Optional;
import java.util.List;

public interface UserRepository {
    void save(User user);
    Optional<User> findById(String id);
}

(3) application 模块

功能：实现应用服务，协调领域模型和仓储接口。

application/build.gradle:

dependencies {
    implementation project(':domain')
    implementation project(':repository')
    implementation 'org.springframework.boot:spring-boot-starter'
}

示例代码：

// application/src/main/java/com/example/application/UserService.java
package com.example.application;

import com.example.domain.User;
import com.example.repository.UserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Optional;

@Service
publicclass UserService {

    privatefinal UserRepository userRepository;

    @Autowired
    public UserService(UserRepository userRepository){
        this.userRepository = userRepository;
    }

    public void createUser(User user){
        userRepository.save(user);
    }

    public Optional<User> getUserById(String id){
        return userRepository.findById(id);
    }
}

(4) infrastructure 模块

功能：实现基础设施组件，包括具体的仓储实现。

infrastructure/build.gradle:

dependencies {
    implementation project(':repository')
    implementation 'org.springframework.boot:spring-boot-starter'
}

① infrastructure:persistence-mysql子模块

功能：实现 MySQL 的具体仓储。

infrastructure/persistence-mysql/build.gradle:

plugins {
    id 'org.springframework.boot'
    id 'io.spring.dependency-management'
}

dependencies {
    implementation project(':domain')
    implementation project(':repository')
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    runtimeOnly 'mysql:mysql-connector-java'
    
    // 可选：MapStruct 用于对象映射
    implementation 'org.mapstruct:mapstruct:1.5.5.Final'
    annotationProcessor 'org.mapstruct:mapstruct-processor:1.5.5.Final'
}

示例代码：


// infrastructure/persistence-mysql/src/main/java/com/example/infrastructure/persistence/mysql/UserEntity.java
package com.example.infrastructure.persistence.mysql;

import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;

@Entity
@Table(name = "users")
publicclass UserEntity {
    @Id
    private String id;
    private String name;
    private String email;

    // 构造函数、Getters 和 Setters

    public UserEntity() {}

    public UserEntity(String id, String name, String email) {
        this.id = id;
        this.name = name;
        this.email = email;
    }

    // getters and setters
}

// infrastructure/persistence-mysql/src/main/java/com/example/infrastructure/persistence/mysql/ JpaUserRepository.java
package com.example.infrastructure.persistence.mysql;

import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface JpaUserRepository extends JpaRepository<UserEntity, String> {
}

// infrastructure/persistence-mysql/src/main/java/com/example/infrastructure/persistence/mysql/MySQLUserRepository.java
package com.example.infrastructure.persistence.mysql;

import com.example.domain.User;
import com.example.repository.UserRepository;
import org.springframework.stereotype.Repository;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Optional;
import java.util.List;
import java.util.stream.Collectors;

@Repository
publicclass MySQLUserRepository implements UserRepository {

    privatefinal JpaUserRepository jpaUserRepository;

    @Autowired
    public MySQLUserRepository(JpaUserRepository jpaUserRepository){
        this.jpaUserRepository = jpaUserRepository;
    }

    @Override
    public void save(User user) {
        UserEntity entity = new UserEntity(user.getId(), user.getName(), user.getEmail());
        jpaUserRepository.save(entity);
    }

    @Override
    public Optional<User> findById(String id) {
        Optional<UserEntity> entityOpt = jpaUserRepository.findById(id);
        return entityOpt.map(entity -> new User(entity.getId(), entity.getName(), entity.getEmail()));
    }
}

② infrastructure:persistence-dynamodb 子模块

功能：实现 DynamoDB 的具体仓储。

infrastructure/persistence-dynamodb/build.gradle:

plugins {
    id 'org.springframework.boot'
    id 'io.spring.dependency-management'
}

dependencies {
    implementation project(':domain')
    implementation project(':repository')
    implementation 'software.amazon.awssdk:dynamodb:2.20.0'
    implementation 'com.fasterxml.jackson.core:jackson-databind:2.14.0'
    implementation 'org.springframework.boot:spring-boot-starter'
}

示例代码：

// infrastructure/persistence-dynamodb/src/main/java/com/example/infrastructure/persistence/dynamodb/DynamoDBUserRepository.java
package com.example.infrastructure.persistence.dynamodb;

import com.example.domain.User;
import com.example.repository.UserRepository;
import org.springframework.stereotype.Repository;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.services.dynamodb.model.*;

import org.springframework.beans.factory.annotation.Autowired;
import com.fasterxml.jackson.databind.ObjectMapper;

import java.util.Optional;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Repository
publicclass DynamoDBUserRepository implements UserRepository {

    privatestaticfinal String TABLE_NAME = "Users";

    privatefinal DynamoDbClient dynamoDbClient;
    privatefinal ObjectMapper objectMapper;

    @Autowired
    public DynamoDBUserRepository(DynamoDbClient dynamoDbClient){
        this.dynamoDbClient = dynamoDbClient;
        this.objectMapper = new ObjectMapper();
    }

    @Override
    public void save(User user) {
        try {
            String json = objectMapper.writeValueAsString(user);
            Map<String, Object> map = objectMapper.readValue(json, Map.class);
            Map<String, AttributeValue> item = map.entrySet().stream()
                    .collect(Collectors.toMap(
                            Map.Entry::getKey,
                            e -> AttributeValue.builder().s(e.getValue().toString()).build()
                    ));

            PutItemRequest request = PutItemRequest.builder()
                    .tableName(TABLE_NAME)
                    .item(item)
                    .build();

            dynamoDbClient.putItem(request);
        } catch (Exception e) {
            thrownew RuntimeException("Failed to save user to DynamoDB", e);
        }
    }

    @Override
    public Optional<User> findById(String id) {
        GetItemRequest request = GetItemRequest.builder()
                .tableName(TABLE_NAME)
                .key(Map.of("id", AttributeValue.builder().s(id).build()))
                .build();

        GetItemResponse response = dynamoDbClient.getItem(request);
        if (response.hasItem()) {
            try {
                String json = objectMapper.writeValueAsString(response.item());
                User user = objectMapper.readValue(json, User.class);
                return Optional.of(user);
            } catch (Exception e) {
                thrownew RuntimeException("Failed to parse user from DynamoDB", e);
            }
        }
        return Optional.empty();
    }
}

③ DynamoDB 客户端配置

在 infrastructure:persistence-dynamodb 子模块中配置 DynamoDB 客户端 Bean。

// infrastructure/persistence-dynamodb/src/main/java/com/example/infrastructure/persistence/dynamodb/DynamoDBConfig.java
package com.example.infrastructure.persistence.dynamodb;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import software.amazon.awssdk.services.dynamodb.DynamoDbClient;
import software.amazon.awssdk.regions.Region;

@Configuration
publicclass DynamoDBConfig {
    @Bean
    public DynamoDbClient dynamoDbClient() {
        return DynamoDbClient.builder()
                .region(Region.US_EAST_1) // 根据实际情况选择区域
                .build();
    }
}

(5) config 模块（可选）

功能：集中管理项目配置，例如选择使用的仓储实现、数据库配置等。

config/build.gradle:

dependencies {
    implementation project(':application')
    implementation project(':infrastructure:persistence-mysql')
    implementation project(':infrastructure:persistence-dynamodb')
    implementation 'org.springframework.boot:spring-boot-starter'
}

示例代码：

// config/src/main/java/com/example/config/RepositoryConfig.java
package com.example.config;

import com.example.repository.UserRepository;
import com.example.infrastructure.persistence_mysql.MySQLUserRepository;
import com.example.infrastructure.persistence_dynamodb.DynamoDBUserRepository;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
publicclass RepositoryConfig {

    @Value("${app.repository.type}")
    private String repositoryType;

    privatefinal MySQLUserRepository mySQLUserRepository;
    privatefinal DynamoDBUserRepository dynamoDBUserRepository;

    @Autowired
    public RepositoryConfig(MySQLUserRepository mySQLUserRepository, DynamoDBUserRepository dynamoDBUserRepository){
        this.mySQLUserRepository = mySQLUserRepository;
        this.dynamoDBUserRepository = dynamoDBUserRepository;
    }

    @Bean
    public UserRepository userRepository() {
        if ("mysql".equalsIgnoreCase(repositoryType)) {
            return mySQLUserRepository;
        } elseif ("dynamodb".equalsIgnoreCase(repositoryType)) {
            return dynamoDBUserRepository;
        } else {
            thrownew IllegalArgumentException("Unsupported repository type: " + repositoryType);
        }
    }
}

**application.properties**（在 api 模块或根模块）

# application.properties
app.repository.type=mysql
# 或者
# app.repository.type=dynamodb

(6) api 模块

功能：作为应用的入口，处理外部请求（如 REST API）。

api/build.gradle:

plugins {
    id 'org.springframework.boot'
    id 'io.spring.dependency-management'
}

dependencies {
    implementation project(':application')
    implementation project(':config')
    implementation 'org.springframework.boot:spring-boot-starter-web'
}

示例代码：

// api/src/main/java/com/example/api/UserController.java
package com.example.api;

import com.example.application.UserService;
import com.example.domain.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/users")
publicclass UserController {

    privatefinal UserService userService;

    @Autowired
    public UserController(UserService userService){
        this.userService = userService;
    }

    @PostMapping
    public void createUser(@RequestBody User user){
        userService.createUser(user);
    }

    @GetMapping("/{id}")
    public Optional<User> getUserById(@PathVariable String id){
        return userService.getUserById(id);
    }
}

4. 模块间依赖关系图

domain
   ↑
repository
   ↑
application
   ↑
infrastructure
   ↑
config
   ↑
api

domain 是最底层，其他模块依赖于它。
repository 依赖于 **domain**。
application 依赖于 repository 和 **domain**。
infrastructure 依赖于 repository 和 **domain**，实现具体仓储。
config 依赖于 application 和 **infrastructure**，进行配置管理。
api 依赖于 application 和 **config**，作为应用入口。

四、实施步骤详解

1. 创建各个模块

使用 Gradle 命令或 IDE 创建各个模块。例如，使用命令行：

mkdir ddd-project
cd ddd-project
gradle init --type basic
# 创建子模块目录
mkdir domain repository application infrastructure
mkdir infrastructure/persistence-mysql infrastructure/persistence-dynamodb
mkdir config api

然后，在各个子模块目录下创建相应的 build.gradle 文件并添加内容，如上所示。

2. 配置依赖关系

确保每个子模块的 build.gradle 文件中正确地声明依赖关系。例如，在 application 模块的 build.gradle 中：

dependencies {
    implementation project(':domain')
    implementation project(':repository')
    implementation 'org.springframework.boot:spring-boot-starter'
}

类似地，在其他模块中声明所需的依赖。

3. 配置 SpringBoot

在 api 模块中，添加 SpringBoot应用的主类：

// api/src/main/java/com/example/api/MyDddProjectApplication.java
package com.example.api;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication(scanBasePackages = "com.example")
public class MyDddProjectApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyDddProjectApplication.class, args);
    }
}

说明：使用 @SpringBootApplication 注解并设置 scanBasePackages 为 com.example，确保 Spring 能扫描到所有子模块中的组件。

4. 配置应用属性

在 api 模块中创建 src/main/resources/application.properties，并添加必要的配置：

# MySQL 配置
spring.datasource.url=jdbc:mysql://localhost:3306/mydb
spring.datasource.username=root
spring.datasource.password=secret
spring.jpa.hibernate.ddl-auto=update
spring.jpa.show-sql=true

# 仓储选择
app.repository.type=mysql
# 或者
# app.repository.type=dynamodb

# DynamoDB 配置（如适用）
# aws.accessKeyId=YOUR_ACCESS_KEY
# aws.secretAccessKey=YOUR_SECRET_KEY
# aws.region=us-east-1

5. 构建和运行

在根项目目录下，运行以下命令以构建和运行应用：

./gradlew build
./gradlew :api:bootRun

确保你的 MySQL 和 DynamoDB（如果选择使用）都已正确配置和运行。

五、项目优化

1. 使用 Spring Profiles

为了更灵活地在不同环境（如开发、测试、生产）中选择仓储实现，可以使用 Spring Profiles。

示例：

在 MySQLUserRepository 和 DynamoDBUserRepository 上添加 @Profile 注解。

// MySQLUserRepository.java
@Repository
@Profile("mysql")
public class MySQLUserRepository implements UserRepository {
    // ...
}

// DynamoDBUserRepository.java
@Repository
@Profile("dynamodb")
public class DynamoDBUserRepository implements UserRepository {
    // ...
}

在 application.properties 中指定活跃配置：

spring.profiles.active=mysql
# 或者
# spring.profiles.active=dynamodb

2. 使用 MapStruct进行对象映射

手动在仓储实现中转换领域对象和持久化对象可能繁琐，使用 MapStruct 可以简化这一过程。

示例：

添加 MapStruct 依赖（已在 persistence-mysql 模块中添加）。

定义映射接口：

// infrastructure/persistence-mysql/src/main/java/com/example/infrastructure/persistence/mysql/UserMapper.java
package com.example.infrastructure.persistence.mysql;

import com.example.domain.User;
import org.mapstruct.Mapper;
import org.mapstruct.factory.Mappers;

@Mapper
public interface UserMapper {
    UserMapper INSTANCE = Mappers.getMapper(UserMapper.class);

    UserEntity toEntity(User user);
    User toDomain(UserEntity entity);
}

在 MySQLUserRepository 中使用 UserMapper 进行转换：

// MySQLUserRepository.java
package com.example.infrastructure.persistence.mysql;

import com.example.domain.User;
import com.example.repository.UserRepository;
import org.springframework.stereotype.Repository;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.Optional;
import java.util.List;
import java.util.stream.Collectors;

@Repository
@Profile("mysql")
publicclass MySQLUserRepository implements UserRepository {

    privatefinal JpaUserRepository jpaUserRepository;
    privatefinal UserMapper userMapper = UserMapper.INSTANCE;

    @Autowired
    public MySQLUserRepository(JpaUserRepository jpaUserRepository){
        this.jpaUserRepository = jpaUserRepository;
    }

    @Override
    public void save(User user) {
        UserEntity entity = userMapper.toEntity(user);
        jpaUserRepository.save(entity);
    }

    @Override
    public Optional<User> findById(String id) {
        Optional<UserEntity> entityOpt = jpaUserRepository.findById(id);
        return entityOpt.map(userMapper::toDomain);
    }
}

3. 增加测试模块

为每个模块编写单元测试和集成测试，确保各部分功能正常。

4. 使用依赖注入选择仓储实现

在 config 模块中动态选择仓储实现，或使用工厂模式进一步封装。

六、总结

本文，我们没有讲解 DDD那些烧脑的理论知识，而是按照 DDD 的分层原则详细地落地了一个user添加和查询功能，并实现支持多种持久化机制（MySQL 和 DynamoDB）的仓储层设计。只要你有过 MVC 的 web开发经验，应该可以快速理解上述 DDD的代码工程。

对于 DDD模块化设计带来的好处，可以总结为以下几点：

高内聚、低耦合：每个模块都有明确的职责，模块之间通过接口进行通信，降低了耦合度。
易于扩展：未来添加新的持久化机制（如 PostgreSQL、Redis 等）时，只需新增相应的基础设施子模块，实现仓储接口即可。
团队协作：不同团队或开发者可以并行开发不同模块，减少冲突和依赖问题。
可维护性：清晰的模块边界和职责分离，使得代码更易于理解和维护。