// Spring Modulith項目依賴配置
// pom.xml
<dependency>
    <groupId>org.springframework.modulith</groupId>
    <artifactId>spring-modulith-starter-core</artifactId>
    <version>1.0.0</version>
</dependency>
// 或者使用Gradle
// build.gradle
dependencies {
    implementation 'org.springframework.modulith:spring-modulith-starter-core:1.0.0'
    // 測試支持
    testImplementation 'org.springframework.modulith:spring-modulith-starter-test:1.0.0'
}

// 使用Java包結(jié)構定義模塊邊界
// com.example.application.moduleA - 模塊A
// com.example.application.moduleB - 模塊B
// 模塊A的公共API接口
package com.example.application.moduleA;
public interface CustomerService {
    Customer findCustomerById(String customerId);
    void updateCustomer(Customer customer);
}
// 模塊A的內(nèi)部實現(xiàn)
package com.example.application.moduleA.internal;
import com.example.application.moduleA.CustomerService;
import org.springframework.stereotype.Service;
@Service
class CustomerServiceImpl implements CustomerService {
    // 實現(xiàn)省略...
}

// 典型的模塊化應用包結(jié)構
com.example.application
├── moduleA         // 客戶管理模塊
│   ├── Customer.java
│   ├── CustomerService.java
│   ├── CustomerController.java
│   └── internal    // 模塊內(nèi)部實現(xiàn)
│       ├── CustomerServiceImpl.java
│       └── CustomerRepository.java
├── moduleB         // 訂單處理模塊
│   ├── Order.java
│   ├── OrderService.java
│   ├── OrderController.java
│   └── internal    // 模塊內(nèi)部實現(xiàn)
│       ├── OrderServiceImpl.java
│       └── OrderRepository.java
└── shared          // 共享組件
    └── EventBus.java

// 使用事件進行模塊間通信
// 在模塊A中定義和發(fā)布事件
package com.example.application.moduleA;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
@Service
public class CustomerService {
    private final ApplicationEventPublisher eventPublisher;
    public CustomerService(ApplicationEventPublisher eventPublisher) {
        this.eventPublisher = eventPublisher;
    }
    public void registerCustomer(Customer customer) {
        // 業(yè)務邏輯...
        // 發(fā)布事件通知其他模塊
        eventPublisher.publishEvent(new CustomerRegisteredEvent(customer.getId()));
    }
}
// 在模塊B中監(jiān)聽和處理事件
package com.example.application.moduleB;
import com.example.application.moduleA.CustomerRegisteredEvent;
import org.springframework.context.event.EventListener;
import org.springframework.stereotype.Component;
@Component
public class CustomerRegistrationHandler {
    @EventListener
    public void handleCustomerRegistration(CustomerRegisteredEvent event) {
        // 處理客戶注冊事件
        String customerId = event.getCustomerId();
        // 業(yè)務邏輯...
    }
}

// 使用Spring Modulith的測試支持
// 模塊隔離測試示例
import org.junit.jupiter.api.Test;
import org.springframework.modulith.test.ApplicationModuleTest;
import org.springframework.modulith.test.Scenario;
// 僅測試moduleA模塊，不加載其他模塊
@ApplicationModuleTest(value = "moduleA")
class CustomerModuleTest {
    @Test
    void shouldRegisterCustomer(Scenario scenario) {
        // 準備測試數(shù)據(jù)
        Customer customer = new Customer("customer-1", "John Doe");
        // 執(zhí)行測試，驗證事件發(fā)布
        scenario.stimulate(() -> customerService.registerCustomer(customer))
                .andWaitForEventOfType(CustomerRegisteredEvent.class)
                .toArise();
        // 其他斷言...
    }
}
// 模塊間依賴驗證
import org.junit.jupiter.api.Test;
import org.springframework.modulith.core.ApplicationModules;
import org.springframework.modulith.docs.Documenter;
class ModuleDependencyTest {
    @Test
    void verifyModuleDependencies() {
        // 加載應用模塊結(jié)構
        ApplicationModules modules = ApplicationModules.of(Application.class);
        // 驗證模塊依賴關系
        modules.verify();
        // 生成模塊文檔
        new Documenter(modules).writeDocumentation();
    }
}

// 模塊化持久層設計示例
// 模塊A的數(shù)據(jù)模型和倉庫
package com.example.application.moduleA.internal;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import org.springframework.data.repository.CrudRepository;
@Entity
@Table(name = "customers")
class CustomerEntity {
    @Id
    private String id;
    private String name;
    private String email;
    // 其他屬性...
}
interface CustomerRepository extends CrudRepository<CustomerEntity, String> {
    // 查詢方法...
}
// 模塊B的數(shù)據(jù)模型和倉庫
package com.example.application.moduleB.internal;
import jakarta.persistence.Entity;
import jakarta.persistence.Id;
import jakarta.persistence.Table;
import org.springframework.data.repository.CrudRepository;
@Entity
@Table(name = "orders")
class OrderEntity {
    @Id
    private String id;
    private String customerId; // 外鍵引用，但不直接依賴CustomerEntity
    private String productId;
    // 其他屬性...
}
interface OrderRepository extends CrudRepository<OrderEntity, String> {
    // 查詢方法...
}

// 從模塊化單體提取微服務的演進示例
// 第一步：將模塊事件適配為分布式事件
package com.example.application.moduleA;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Service;
@Service
public class CustomerService {
    private final ApplicationEventPublisher eventPublisher;
    private final MessageBrokerClient messageBroker; // 新增消息代理客戶端
    public void registerCustomer(Customer customer) {
        // 業(yè)務邏輯...
        // 發(fā)布應用內(nèi)事件
        CustomerRegisteredEvent event = new CustomerRegisteredEvent(customer.getId());
        eventPublisher.publishEvent(event);
        // 同時發(fā)布到消息代理，為微服務遷移做準備
        messageBroker.publish("customer-events", event);
    }
}
// 第二步：將模塊API轉(zhuǎn)換為HTTP/REST接口
package com.example.application.moduleA;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/api/customers")
public class CustomerApiController {
    private final CustomerService customerService;
    @PostMapping
    public CustomerDto registerCustomer(@RequestBody CustomerRegistrationRequest request) {
        // 調(diào)用服務方法
        Customer customer = customerService.registerCustomer(request.toCustomer());
        return CustomerDto.fromCustomer(customer);
    }
    @GetMapping("/{id}")
    public CustomerDto getCustomerById(@PathVariable String id) {
        Customer customer = customerService.findCustomerById(id);
        return CustomerDto.fromCustomer(customer);
    }
}