跳至主要內容

39. 领域驱动设计DDD在电商物流行业的实践（二）：代码实现与架构原则应用

Kenyon大约 18 分钟

39. 领域驱动设计DDD在电商物流行业的实践（二）：代码实现与架构原则应用

文 / Kenyon，资深软件架构师，15年软件开发和技术管理经验，从程序员做到企业技术高管，专注技术管理、架构设计、AI技术应用和落地。

由于公众号推流的原因，请在关注页右上角加星标，这样才能及时收到新文章的推送。

摘要：本文详细介绍了如何利用DDD在电商物流行业实践，通过前端React + Ant Design和后端Spring Boot的具体代码示例，展示了如何将DDD的核心概念（如限界上下文、聚合根、领域事件等）落地到实际项目中，同时重点应用了SOLID原则、高内聚低耦合、KISS、迪米特法则等架构设计原则，构建了一个可扩展、可维护的系统。

引言

大家好，我是Kenyon，本文是关于如何利用DDD在电商物流行业实践系列文章的第二篇文章，在上一篇领域驱动设计DDD在电商物流行业的实践（一）：领域识别
原创的文章中，我们重点介绍了订单、产品和仓储这几个模块是如何运用领域驱动设计（DDD）来完成系统设计的，包括领域的识别、限界上下文的界定、领域对象的分析和抽取等内容。今天，我们将会进入实战阶段，通过具体的代码示例来展示如何将DDD的设计理念落地到实际项目中。

本文将基于实际的项目和代码，详细的介绍前端和后端的实现细节，重点展示架构设计原则在代码中的应用，确保在实现业务的基础上，依然能很好地保持好系统的可扩展性和可维护性。

一、项目整体架构

1. 技术栈选择

根据上一篇文章里面讲述到的项目需求和以及目前的技术发展趋势，我们选择了以下的技术栈作为项目代码实现的基础：

分类技术版本选型理由
前端框架React19.x前端框架里面算是最成熟和稳定的框架了，国内外的流行度都比较高，而且其生态相当丰富，特别适合构建复杂的单页应用
构建工具Vite6.x前端快速的开发服务器和构建工具，其热加载和易用性非常显著，可以大幅提升开发的效率
UI组件库Ant Design5.x阿里开发的前端UI框架，提供了丰富的UI组件，符合企业级应用的设计规范
后端框架Spring Boot3.5.9Java生态里面的核武器，可以大幅简化后端的开发，并且提供了完整的生态支持
开发语言Java17稳定可靠，适合大型企业应用开发
API通信RESTful API-标准化的API设计规范，特别适合完成前后端分离的架构
数据存储MySQL8.0+常规开发中最常用的关系型数据库，适合存储结构化数据
消息队列Kafka3.x以性能著称的消息队列中间件，在事件驱动架构中必不可少，支持异步通信，可以削峰填谷，特别适合处理高并发的场景

2. 项目结构

基于DDD的分层架构的思想以及KISS法则，我们给整个项目的MVP版本设计了以下的项目结构：

ecommerce-logistics-erp/
├── backend/            # 后端代码
│   ├── src/            # 源代码
│   │   ├── main/
│   │   │   ├── java/
│   │   │   │   └── site/hexaarch/ecommerce/logistics/
│   │   │   │       ├── application/        # 应用层
│   │   │   │       ├── domain/             # 领域层
│   │   │   │       ├── infrastructure/     # 基础设施层
│   │   │   │       ├── interfaces/         # 接口层
│   │   │   │       └── EcommerceLogisticsApplication.java # 应用入口
│   │   │   └── resources/
│   │   │       └── application.yml        # 配置文件
│   │   └── test/       # 测试代码
│   └── pom.xml         # Maven配置
└── frontend/           # 前端代码
    ├── public/         # 静态资源
    ├── src/            # 源代码
    │   ├── assets/     # 资源文件
    │   ├── components/ # 通用组件
    │   ├── pages/      # 页面组件
    │   │   ├── customer/            # 客户管理
    │   │   ├── finance/             # 财务管理
    │   │   ├── home/                # 首页
    │   │   ├── logistics/           # 物流管理
    │   │   ├── order/               # 订单管理
    │   │   ├── platform-integration/ # 平台集成
    │   │   ├── product/             # 产品管理
    │   │   ├── purchase/            # 采购管理
    │   │   └── warehouse/           # 仓储管理
    │   ├── services/   # API服务
    │   ├── App.jsx     # 应用入口
    │   └── routes.jsx  # 路由配置
    └── package.json    # 依赖配置

二、前端实现

1. 核心架构设计

参考SOLID原则，前端采用了以下设计：

单一职责原则（SRP）

每个页面组件只负责一个明确的功能，比如：

  • OrderList.jsx只负责订单列表的展示和管理
  • OrderDetail.jsx只负责单个订单的详情展示和操作
  • CreateOrder.jsx只负责订单的创建功能

开闭原则（OCP）

通过组件化的设计，实现代码的复用以及可扩展性：

  • 通用组件（如Layout、Form等）可在多个页面复用
  • 页面组件通过props接收参数，便于扩展功能

依赖倒置原则（DIP）

通过API服务层抽象后端依赖：

  • 所有后端API调用通过services/api.js统一管理
  • 页面组件依赖API服务接口，而非具体实现

2. 路由配置

基于React Router DOM实现的路由配置，可以清晰地划分各个限界上下文以及其访问路径：

// routes.jsx
import React from 'react';
import { Routes, Route } from 'react-router-dom';

// 页面组件
import Home from './pages/home/Home';
import OrderList from './pages/order/OrderList';
import OrderDetail from './pages/order/OrderDetail';
import CreateOrder from './pages/order/CreateOrder';
import LogisticsList from './pages/logistics/LogisticsList';
import LogisticsDetail from './pages/logistics/LogisticsDetail';
import CreateLogistics from './pages/logistics/CreateLogistics';
// 其他页面组件...

const AppRoutes = () => {
  return (
    <Routes>
      <Route path="/" element={<Home />} />
      <Route path="/orders" element={<OrderList />} />
      <Route path="/orders/:id" element={<OrderDetail />} />
      <Route path="/orders/create" element={<CreateOrder />} />
      <Route path="/logistics" element={<LogisticsList />} />
      <Route path="/logistics/:id" element={<LogisticsDetail />} />
      <Route path="/logistics/create" element={<CreateLogistics />} />
      {/* 其他路由配置... */}
    </Routes>
  );
};

export default AppRoutes;

3. API服务层设计

采用集中式的API管理和封装，便于做统一的请求以及响应的处理还有后续跟后端的集成：

// services/api.js
import axios from 'axios';

// 创建axios实例
const api = axios.create({
  baseURL: 'http://localhost:8080/api',
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json'
  }
});

// 响应拦截器
api.interceptors.response.use(
  response => {
    // 后端统一返回的格式是 { code: 200, message: 'success', data: {} }
    if (response.data.code === 200) {
      return response.data.data;
    } else {
      // 处理错误
      throw new Error(response.data.message || '请求失败');
    }
  },
  error => {
    throw error;
  }
);

// 订单相关API
export const orderApi = {
  createOrder: (orderData) => api.post('/orders', orderData),
  getOrderById: (id) => api.get(`/orders/${id}`),
  updateOrderStatus: (id, status) => api.put(`/orders/${id}/status`, null, { params: { status } }),
  getOrdersByCustomer: (customerId) => api.get(`/orders/customer/${customerId}`)
};

// 其他模块API...

4. 订单管理模块实现

以订单管理为例，展示DDD概念在前端的应用：

订单详情页实现（精简版）

// pages/order/OrderDetail.jsx
import React, { useState, useEffect } from 'react';
import { useParams, Link } from 'react-router-dom';
import { Typography, Descriptions, Table, Button, Card, Space, Tag, Modal, Select, message } from 'antd';
import { ArrowLeftOutlined, SyncOutlined } from '@ant-design/icons';
import { orderApi } from '../../services/api';

const { Title } = Typography;
const { Option } = Select;

const OrderDetail = () => {
  const { id } = useParams();
  const [order, setOrder] = useState(null);
  const [loading, setLoading] = useState(true);
  const [statusModalVisible, setStatusModalVisible] = useState(false);
  const [selectedStatus, setSelectedStatus] = useState('');

  // 获取订单详情
  const fetchOrderDetail = async () => {
    setLoading(true);
    try {
      // 使用模拟数据
      const mockOrder = {
        id,
        orderNumber: `ORD-2024-${String(id).padStart(6, '0')}`,
        customerName: '张三',
        orderStatus: 'PROCESSING',
        totalAmount: 1280.50,
        orderItems: [
          { id: 'item-001', productName: 'iPhone 15 Pro', sku: 'SKU001', quantity: 1, unitPrice: 999.99, totalPrice: 999.99 },
          { id: 'item-002', productName: 'AirPods Pro 2', sku: 'SKU002', quantity: 1, unitPrice: 280.51, totalPrice: 280.51 }
        ]
      };
      setOrder(mockOrder);
      setSelectedStatus(mockOrder.orderStatus);
    } catch (error) {
      console.error('获取订单详情失败:', error);
    } finally {
      setLoading(false);
    }
  };

  useEffect(() => {
    fetchOrderDetail();
  }, [id]);

  // 订单状态映射
  const statusMap = {
    PENDING: { text: '待处理', color: 'blue' },
    PROCESSING: { text: '处理中', color: 'processing' },
    SHIPPED: { text: '已发货', color: 'green' },
    COMPLETED: { text: '已完成', color: 'success' },
    CANCELLED: { text: '已取消', color: 'error' }
  };

  // 处理订单状态变更
  const handleStatusChange = async () => {
    try {
      // 模拟更新成功
      setOrder(prev => ({
        ...prev,
        orderStatus: selectedStatus
      }));
      message.success('订单状态更新成功');
      setStatusModalVisible(false);
    } catch (error) {
      message.error('更新订单状态失败');
    }
  };

  // 处理订单同步
  const handleSyncOrder = async () => {
    message.loading('正在同步订单...');
    setTimeout(() => {
      message.success('订单同步成功');
    }, 1000);
  };

  if (loading) return <div>加载中...</div>;
  if (!order) return <div>订单不存在</div>;

  return (
    <div>
      <div style={{ display: 'flex', justifyContent: 'space-between', marginBottom: 16 }}>
        <Title level={4}>
          <Button type="text" icon={<ArrowLeftOutlined />}><Link to="/orders">返回列表</Link></Button>
          订单详情
        </Title>
        <Button icon={<SyncOutlined />} onClick={handleSyncOrder}>同步订单</Button>
      </div>

      {/* 订单基本信息 */}
      <Card style={{ marginBottom: 16 }}>
        <Descriptions column={2} bordered>
          <Descriptions.Item label="订单编号">{order.orderNumber}</Descriptions.Item>
          <Descriptions.Item label="订单状态">
            <Tag color={statusMap[order.orderStatus].color}>{statusMap[order.orderStatus].text}</Tag>
          </Descriptions.Item>
        </Descriptions>
      </Card>

      {/* 订单商品 */}
      <Card title="订单商品" style={{ marginBottom: 16 }}>
        <Table
          columns={[
            { title: '产品名称', dataIndex: 'productName' },
            { title: 'SKU', dataIndex: 'sku', width: 100 },
            { title: '数量', dataIndex: 'quantity', width: 80 },
            { title: '单价', dataIndex: 'unitPrice', width: 100, render: (text) => `¥${text.toFixed(2)}` },
            { title: '小计', dataIndex: 'totalPrice', width: 100, render: (text) => `¥${text.toFixed(2)}` }
          ]}
          dataSource={order.orderItems}
          rowKey="id"
          pagination={false}
        />
      </Card>

      {/* 操作按钮 */}
      <div style={{ textAlign: 'right', marginTop: 24 }}>
        <Button type="primary" onClick={() => setStatusModalVisible(true)}>更新状态</Button>
      </div>

      {/* 状态更新弹窗 */}
      <Modal
        title="更新订单状态"
        open={statusModalVisible}
        onOk={handleStatusChange}
        onCancel={() => setStatusModalVisible(false)}
      >
        <Select
          style={{ width: '100%' }}
          value={selectedStatus}
          onChange={setSelectedStatus}
          placeholder="请选择订单状态"
        >
          {Object.entries(statusMap).map(([key, value]) => (
            <Option key={key} value={key}>{value.text}</Option>
          ))}
        </Select>
      </Modal>
    </div>
  );
};

export default OrderDetail;

5. 前端架构设计原则应用

单一职责原则（SRP）

  • 每个页面组件只负责一个明确的功能，如订单详情页只处理订单相关的操作
  • API服务层与页面组件分离，API服务只负责与后端通信
  • 组件粒度合理，避免过大的组件

开闭原则（OCP）

  • 通过组件化设计实现可扩展性，如通用的Modal、Form等组件可在多个页面复用
  • 页面组件通过props接收参数，便于功能扩展
  • API服务层通过接口抽象，便于后续替换实现

依赖倒置原则（DIP）

  • 页面组件依赖API服务接口，而非具体实现
  • 通过服务层抽象后端依赖，便于后续切换后端实现

高内聚低耦合

  • 组件内部功能紧密相关，如订单详情页只处理订单相关的逻辑
  • 组件间通过props和事件通信，减少直接依赖
  • API服务层集中管理后端调用，减少页面组件与后端的直接耦合

KISS原则

  • 代码实现简洁明了，避免过度设计
  • 使用模拟数据简化前端开发，无需等待后端API实现
  • 界面设计简洁，符合用户操作习惯

迪米特法则

  • 组件只与直接依赖的组件通信，如页面组件只与API服务通信
  • 减少组件间的间接依赖，提高系统的可维护性

三、后端实现

1. 架构设计

后端主要是使用Spring Boot来作为系统的实现方式，代码结构层面参考DDD的分层架构思想，采用了以下的分层结构，其中：

  1. **接口层(Interface Layer)**负责处理HTTP请求和响应，包含相关的DTO；
  2. **应用层(Application Layer)**负责协调领域对象完成业务操作，包含相关的服务类；
  3. **领域层(Domain Layer)**负责实现领域模型的管理和业务的逻辑，包含相关的实体类、值对象、聚合根等；
  4. **基础设施层(Infrastructure Layer)**负责提供技术支持，如持久化、消息传递等，包含相关的仓库类、消息监听器等。

2. 应用入口代码示例

/**
 * Spring Boot应用程序主类，作为电商物流ERP系统的入口点。
 *
 * @author kenyon
 */
@SpringBootApplication
@ComponentScan(basePackages = {
    "site.hexaarch.ecommerce.logistics.application",
    "site.hexaarch.ecommerce.logistics.domain",
    "site.hexaarch.ecommerce.logistics.infrastructure",
    "site.hexaarch.ecommerce.logistics.interfaces"
})
public class EcommerceLogisticsApplication {

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

}

3. 配置文件

# application.yml
spring:
  application:
    name: ecommerce-logistics-erp
  datasource:
    url: jdbc:mysql://localhost:3306/ecommerce_logistics_erp?useSSL=false&serverTimezone=UTC
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true
  kafka:
    bootstrap-servers: localhost:9092
    consumer:
      group-id: ecommerce-logistics-group
      auto-offset-reset: earliest
    producer:
      key-serializer: org.apache.kafka.common.serialization.StringSerializer
      value-serializer: org.apache.kafka.common.serialization.StringSerializer

server:
  port: 8080
  servlet:
    context-path: /api

# 自定义配置
ecommerce:
  logistics:
    order:
      sync:
        enabled: true
    logistics:
      tracking:
        enabled: true

4. 后端架构设计原则应用

单一职责原则（SRP）

  • 每个类只负责一个明确的功能，如OrderService只处理订单相关的业务逻辑、LogisticsService只处理物流相关的业务逻辑等；
  • 分层清晰，接口层只处理HTTP请求，应用层协调业务操作，领域层包含核心业务逻辑，基础设施层提供技术支持；

开闭原则（OCP）

  • 通过接口抽象实现可扩展性，如Repository接口可支持不同的持久化实现，目前是用JPA实现，后续可以增加其他的实现方式；
  • 使用策略模式支持不同的业务规则实现，如不同的物流渠道策略、不同的订单状态策略、不同的支付渠道策略等；

依赖倒置原则（DIP）

  • 高层模块依赖抽象，如应用层依赖Repository接口，而非具体实现；
  • 通过手动注入或者是Spring的DI依赖注入实现代码的解耦，便于测试和替换实现；

高内聚低耦合

  • 领域模型内部功能紧密相关，如订单聚合包含订单、订单项、地址和支付等；
  • 层与层之间通过接口通信，减少直接依赖；
  • 限界上下文之间通过事件通信，减少直接耦合；

KISS原则

  • 代码实现简洁明了，避免过度设计；
  • 使用Spring Boot自动配置简化开发；
  • 业务逻辑实现清晰，便于理解和维护；

迪米特法则

  • 模块只与直接依赖的模块通信，如领域服务只与聚合根和领域对象通信；
  • 减少模块间的间接依赖，提高系统的可维护性；

四、DDD核心概念在代码中的应用

1. 限界上下文

在代码实现中，我们通过包结构来体现限界上下文：

backend/src/main/java/site/hexaarch/ecommerce/logistics/
├── application/        # 应用层
│   ├── order/          # 订单应用服务
│   ├── logistics/      # 物流应用服务
│   ├── warehouse/      # 仓储应用服务
│   └── product/        # 产品应用服务
├── domain/             # 领域层
│   ├── order/          # 订单子域
│   │   ├── aggregate/  # 聚合
│   │   ├── entity/     # 实体
│   │   ├── event/      # 领域事件
│   │   └── repository/ # 仓储接口
│   ├── logistics/      # 物流子域
│   ├── warehouse/      # 仓储子域
│   └── product/        # 产品子域
├── infrastructure/     # 基础设施层
│   ├── persistence/    # 持久化
│   ├── messaging/      # 消息传递
│   └── external/       # 外部系统集成
└── interfaces/         # 接口层
    ├── controller/     # 控制器
    └── dto/            # 数据传输对象

2. 领域模型实现

订单聚合根

/**
 * 订单聚合根
 */
@Entity
@Table(name = "orders")
@Data
public class Order {
    @Id
    @GeneratedValue(strategy = GenerationType.UUID)
    private String id;
    
    private String orderNumber;
    private String customerId;
    private String customerName;
    
    @Enumerated(EnumType.STRING)
    private OrderStatus orderStatus;
    
    private BigDecimal totalAmount;
    
    @Embedded
    private ShippingAddress shippingAddress;
    
    @Embedded
    private PaymentInfo paymentInfo;
    
    @OneToMany(mappedBy = "order", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<OrderItem> orderItems;
    
    private LocalDateTime createdAt;
    private LocalDateTime updatedAt;
    
    // 业务方法
    public void updateStatus(OrderStatus newStatus) {
        OrderStatus oldStatus = this.orderStatus;
        this.orderStatus = newStatus;
        this.updatedAt = LocalDateTime.now();
        
        // 发布领域事件
        // 实际项目中通过事件发布器发布
    }
    
    public void cancel() {
        if (this.orderStatus == OrderStatus.COMPLETED) {
            throw new IllegalArgumentException("已完成的订单不能取消");
        }
        this.updateStatus(OrderStatus.CANCELLED);
    }
    
    // 其他业务方法...
}

订单状态值对象

/**
 * 订单状态值对象
 */
public enum OrderStatus {
    PENDING("待处理"),
    PROCESSING("处理中"),
    SHIPPED("已发货"),
    COMPLETED("已完成"),
    CANCELLED("已取消");
    
    private final String description;
    
    OrderStatus(String description) {
        this.description = description;
    }
    
    public String getDescription() {
        return description;
    }
}

3. 仓储接口与实现

订单仓储接口

/**
 * 订单仓储接口
 */
public interface OrderRepository {
    Order save(Order order);
    Optional<Order> findById(String id);
    Optional<Order> findByOrderNumber(String orderNumber);
    void deleteById(String id);
}

订单仓储实现

/**
 * 订单仓储实现
 */
@Repository
public class OrderRepositoryImpl implements OrderRepository {
    
    @PersistenceContext
    private EntityManager entityManager;
    
    @Override
    public Order save(Order order) {
        if (order.getId() == null) {
            entityManager.persist(order);
        } else {
            order = entityManager.merge(order);
        }
        return order;
    }
    
    @Override
    public Optional<Order> findById(String id) {
        return Optional.ofNullable(entityManager.find(Order.class, id));
    }
    
    @Override
    public Optional<Order> findByOrderNumber(String orderNumber) {
        return entityManager.createQuery("SELECT o FROM Order o WHERE o.orderNumber = :orderNumber", Order.class)
                .setParameter("orderNumber", orderNumber)
                .getResultList()
                .stream()
                .findFirst();
    }
    
    @Override
    public void deleteById(String id) {
        Order order = entityManager.find(Order.class, id);
        if (order != null) {
            entityManager.remove(order);
        }
    }
}

4. 应用服务实现

/**
 * 订单应用服务
 */
@Service
public class OrderApplicationService {
    
    private final OrderRepository orderRepository;
    private final ApplicationEventPublisher eventPublisher;
    
    public OrderApplicationService(OrderRepository orderRepository, ApplicationEventPublisher eventPublisher) {
        this.orderRepository = orderRepository;
        this.eventPublisher = eventPublisher;
    }
    
    @Transactional
    public OrderDto createOrder(OrderCreateDto createDto) {
        // 创建订单
        Order order = new Order();
        order.setOrderNumber(generateOrderNumber());
        order.setCustomerId(createDto.getCustomerId());
        order.setCustomerName(createDto.getCustomerName());
        order.setOrderStatus(OrderStatus.PENDING);
        order.setTotalAmount(createDto.getTotalAmount());
        // 设置其他属性...
        order.setCreatedAt(LocalDateTime.now());
        order.setUpdatedAt(LocalDateTime.now());
        
        // 保存订单
        Order savedOrder = orderRepository.save(order);
        
        // 发布订单创建事件
        // eventPublisher.publishEvent(new OrderCreatedEvent(savedOrder.getId()));
        
        // 转换为DTO
        return convertToDto(savedOrder);
    }
    
    @Transactional
    public void updateOrderStatus(String orderId, OrderStatus status) {
        Order order = orderRepository.findById(orderId)
                .orElseThrow(() -> new IllegalArgumentException("订单不存在"));
        
        OrderStatus oldStatus = order.getOrderStatus();
        order.updateStatus(status);
        
        orderRepository.save(order);
        
        // 发布订单状态变更事件
        // eventPublisher.publishEvent(new OrderStatusChangedEvent(orderId, oldStatus, status));
    }
    
    private String generateOrderNumber() {
        return "ORD-" + LocalDateTime.now().format(java.time.format.DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
    }
    
    private OrderDto convertToDto(Order order) {
        OrderDto dto = new OrderDto();
        dto.setId(order.getId());
        dto.setOrderNumber(order.getOrderNumber());
        dto.setCustomerName(order.getCustomerName());
        dto.setOrderStatus(order.getOrderStatus());
        dto.setTotalAmount(order.getTotalAmount());
        return dto;
    }
}

5. 控制器实现

/**
 * 订单控制器
 */
@RestController
@RequestMapping("/orders")
public class OrderController {
    
    private final OrderApplicationService orderApplicationService;
    
    public OrderController(OrderApplicationService orderApplicationService) {
        this.orderApplicationService = orderApplicationService;
    }
    
    @PostMapping
    public ResponseEntity<OrderDto> createOrder(@RequestBody OrderCreateDto createDto) {
        OrderDto orderDto = orderApplicationService.createOrder(createDto);
        return new ResponseEntity<>(Result.success(orderDto), HttpStatus.CREATED);
    }
    
    @GetMapping("/{id}")
    public ResponseEntity<OrderDto> getOrderById(@PathVariable String id) {
        // 实际实现中通过应用服务获取订单
        return ResponseEntity.ok(Result.success(orderDto));
    }
    
    @PutMapping("/{id}/status")
    public ResponseEntity<Void> updateOrderStatus(@PathVariable String id, @RequestParam String status) {
        orderApplicationService.updateOrderStatus(id, OrderStatus.valueOf(status));
        return ResponseEntity.ok(Result.success()).build();
    }
}

6. 领域事件实现

/**
 * 订单状态变更事件
 */
public class OrderStatusChangedEvent {
    private final String orderId;
    private final OrderStatus oldStatus;
    private final OrderStatus newStatus;
    private final LocalDateTime timestamp;
    
    public OrderStatusChangedEvent(String orderId, OrderStatus oldStatus, OrderStatus newStatus) {
        this.orderId = orderId;
        this.oldStatus = oldStatus;
        this.newStatus = newStatus;
        this.timestamp = LocalDateTime.now();
    }
    
    // Getter方法...
}

7. 事件监听器

/**
 * 订单状态变更事件监听器
 */
@Component
public class OrderStatusChangedEventListener {
    
    private final LogisticsService logisticsService;
    
    public OrderStatusChangedEventListener(LogisticsService logisticsService) {
        this.logisticsService = logisticsService;
    }
    
    @EventListener
    public void handleOrderStatusChanged(OrderStatusChangedEvent event) {
        // 当订单状态变更为已发货时，创建物流单
        if (event.getNewStatus().name().equals("SHIPPED")) {
            logisticsService.createLogisticsOrder(event.getOrderId());
        }
    }
}

五、前后端集成与通信

1. API设计

基于RESTful API设计原则，我们设计了以下API结构：

模块API路径方法功能描述
订单管理/ordersPOST创建订单
订单管理/orders/GET获取订单详情
订单管理/orders/{id}/statusPUT更新订单状态
订单管理/ordersGET获取订单列表
物流管理/logisticsPOST创建物流单
物流管理/logistics/GET获取物流单详情
物流管理/logistics/{id}/trackingPUT更新物流状态
仓储管理/warehousesPOST创建仓库
仓储管理/warehouses/GET获取仓库详情
产品管理/productsPOST创建产品
产品管理/products/GET获取产品详情

2. 前端API调用

前端通过API服务层统一管理后端API调用：

// services/api.js
import axios from 'axios';

// 创建axios实例
const api = axios.create({
  baseURL: 'http://localhost:8080/api',
  timeout: 10000,
  headers: {
    'Content-Type': 'application/json'
  }
});

// 响应拦截器
api.interceptors.response.use(
  response => {
    if (response.data.code === 200) {
      return response.data.data;
    } else {
      throw new Error(response.data.message || '请求失败');
    }
  },
  error => {
    throw error;
  }
);

// 订单相关API
export const orderApi = {
  createOrder: (orderData) => api.post('/orders', orderData),
  getOrderById: (id) => api.get(`/orders/${id}`),
  updateOrderStatus: (id, status) => api.put(`/orders/${id}/status`, null, { params: { status } }),
  getOrdersByCustomer: (customerId) => api.get(`/orders/customer/${customerId}`)
};

// 其他模块API...

六、后续规划

因为个人的时间和精力有限，目前项目只实现了核心功能，后续会根据需求和时间进行功能完善和优化。

1. 目前已完成的工作

  • 基于DDD设计了电商物流ERP系统的架构
  • 应用了SOLID原则、高内聚低耦合等架构设计原则
  • 实现了前端React + Ant Design的核心功能
  • 搭建了后端Spring Boot的基础架构
  • 完成了各个模块展示相关的功能的实现

2. 后续规划

  1. 后端功能实现：

    • 完成所有模块的业务逻辑实现
    • 集成数据库和消息队列

  2. 前端功能完善：

    • 实现与后端API的集成
    • 优化用户界面和交互体验
    • 添加数据可视化功能

  3. 平台集成：

    • 实现与Amazon、eBay、Shopify等电商平台的对接
    • 实现订单和产品信息的自动同步

  4. 性能优化：

    • 前端性能优化
    • 后端性能优化
    • 数据库优化

  5. 测试与部署：

    • 完成单元测试和集成测试
    • 实现CI/CD流程

  6. 人工智能支持：

    • 集成AI模型，提供智能推荐、预测以及数字员工等功能

七、总结

本文通过实际的项目和代码，详细地介绍了日常各种的架构设计原则和模式，以及如何将它们应用到实际项目中。比如我们采用了前端React + Ant Design和后端Spring Boot的技术栈，加上领域驱动设计（DDD）的设计理念把一个电商物流的ERP系统从概念到落地的全过程都给展示了出来，并且在具体的模块和代码里面又应用了SOLID原则、高内聚低耦合、KISS、迪米特法则等架构设计原则，构建了一个可扩展、可维护的系统。

文章讲述到的项目的代码可以在GitHub仓库中找到。

在后续的工作中，我们将继续完善系统功能，优化系统性能，确保系统能够满足业务需求的同时，保持良好的可维护性和可扩展性。欢迎大家一起参与到项目的开发和维护中，共同推动这个ERP系统的发展。

互动话题：在实现电商物流ERP系统的过程中，你认为哪个模块的设计最具挑战性？为什么？欢迎在评论区分享你的观点。

工具附录：

关于作者

Kenyon，资深软件架构师，15年的软件开发和技术管理经验，从程序员做到企业技术高管。多年企业数字化转型和软件架构设计经验，善于帮助企业构建高质量、可维护的软件系统，目前专注技术管理、架构设计、AI技术应用和落地；全网统一名称"六边形架构"，欢迎关注交流。

原创不易，转载请联系授权，如果觉得有帮助，请点赞、收藏、转发三连支持！

快来关注我吧！
快来关注我吧！