六边形架构（Hexagonal Architecture，也被称为端口与适配器架构）是一种软件架构风格，旨在将应用程序的核心逻辑与外部接口解耦。这种解耦能够改进系统的可测试性、可维护性以及跨团队协作时的服务稳定性。在使用Python Django框架的项目中，六边形架构能够为核心服务提供更好的稳健性和灵活性，也有助于清晰地定义团队边界。
六边形架构的核心思想
六边形架构基于以下几个要点：
- 应用核心：应用的业务逻辑被隔离在一个独立的模块中，不直接依赖具体的外部接口或框架。
- 端口：定义应用核心与外部世界交互的接口，分为输入端口（如API层、消息队列、命令行等）与输出端口（如数据库、外部服务等）。
- 适配器：负责实现端口，为应用核心提供具体的外部服务连接方式。
- 独立的测试性：通过模拟端口接口，可以轻松编写针对应用核心的小型测试，而不需要启动完整的应用。
在 Django 上实现六边形架构
Django 原生是一个 Model-View-Template（MVT）框架，某些开发者会倾向于将业务逻辑直接嵌入到 Views 或 Models 中。但在复杂系统或跨项目团队协作环境中，这种方式容易导致系统耦合、难以扩展和维护。使用六边形架构可以让核心业务逻辑与外部的 HTTP、数据库等技术细节分离。
核心模块组成
在 Django 项目中，可以通过以下步骤实现六边形架构：
- 核心业务模块：定义业务逻辑的核心，完全独立于 Django 的任何实现。可以存放在
core包下。
- 输入适配器（Input Adapters）：实现 HTTP API（views）、命令行接口（management commands）或其他方式，这些部分是框架相关的适配器。
- 输出适配器（Output Adapters）：如数据库查询（通过存储库模式）、调用外部服务的接口等。
- 端口接口（Ports）：定义抽象接口，位于外部适配器与核心模块之间，控制核心模块的输入与输出。
示例：订单管理系统
假设我们正在开发一个订单管理系统，其中的核心服务是订单创建和状态更新，同时需要支持：
- HTTP API 供前端调用；
- 调用外部支付服务完成支付。
通过六边形架构，可以按以下方式组织代码结构：
my_project/
├── core/
│ ├── domain/
│ │ ├── models.py # 实体与值对象（如订单、商品等）
│ │ ├── services.py # 核心业务逻辑（例如订单创建逻辑）
│ │ ├── exceptions.py # 自定义业务异常
│ ├── ports/
│ │ ├── payment_port.py # 输出端口：支付接口定义（抽象类）
│ │ └── repo_port.py # 输出端口：存储接口定义（抽象类）
├── adapters/
│ ├── input/
│ │ └── views.py # Django 的视图（输入适配器）
│ ├── output/
│ │ ├── repository.py # 数据库适配器（实现 repo_port）
│ │ └── payment.py # 支付服务适配器（实现 payment_port）
├── tests/
│ ├── unit/
│ │ ├── test_services.py # 独立测试核心逻辑
│ ├── integration/
│ │ ├── test_http.py # 测试 API 接口的集成测试
各模块的实现思路
核心模块（Core）
core/domain/models.py
定义核心领域模型，例如订单：
class Order:
def __init__(self, id, items, total_price, status='PENDING'):
self.id = id
self.items = items
self.total_price = total_price
self.status = status
def mark_as_paid(self):
if self.status != 'PENDING':
raise ValueError("Order cannot be marked as paid.")
self.status = 'PAID'
core/domain/services.py
定义核心业务逻辑：
from core.ports.repo_port import OrderRepository
from core.ports.payment_port import PaymentService
class OrderService:
def __init__(self, repo: OrderRepository, payment_service: PaymentService):
self.repo = repo
self.payment_service = payment_service
def create_order(self, items, total_price):
# 创建订单
order = Order(id=None, items=items, total_price=total_price)
self.repo.save(order)
return order
def pay_order(self, order_id):
# 支付订单
order = self.repo.get(order_id)
self.payment_service.process_payment(order)
order.mark_as_paid()
self.repo.save(order)
输出端口与适配器
core/ports/payment_port.py
定义支付服务的输出端口接口：
from abc import ABC, abstractmethod
class PaymentService(ABC):
@abstractmethod
def process_payment(self, order):
pass
adapters/output/payment.py
具体实现支付服务接口：
class StripePaymentService(PaymentService):
def process_payment(self, order):
# 调用 Stripe API 进行支付
print(f"Processing payment for order {order.id} via Stripe.")
return True
core/ports/repo_port.py
定义存储抽象接口：
from abc import ABC, abstractmethod
class OrderRepository(ABC):
@abstractmethod
def save(self, order):
pass
@abstractmethod
def get(self, order_id):
pass
adapters/output/repository.py
使用 Django ORM 实现存储适配器：
from core.ports.repo_port import OrderRepository
from my_app.models import Order as OrderModel
class DjangoOrderRepository(OrderRepository):
def save(self, order):
# 转换核心实体为 Django 模型并保存
OrderModel.objects.create(...)
def get(self, order_id):
# 从数据库获取订单并转化为核心实体
return order
输入适配器
通过 Django 的 Views 定义输入接口：
from django.http import JsonResponse
from core.domain.services import OrderService
from adapters.output.repository import DjangoOrderRepository
from adapters.output.payment import StripePaymentService
def create_order_view(request):
repo = DjangoOrderRepository()
payment_service = StripePaymentService()
service = OrderService(repo, payment_service)
items = request.json.get('items')
total_price = request.json.get('total_price')
order = service.create_order(items, total_price)
return JsonResponse({'order_id': order.id}, status=201)
六边形架构的实践价值
- 服务稳定性：跨团队协作时，核心模块中的业务逻辑完全独立，不会因其他接口的修改而导致核心逻辑不稳定。
- 清晰分工：团队可以独立开发适配器，而不需要干扰核心业务逻辑。
- 更好的测试：通过 Mock 端口接口，可以轻松编写核心逻辑的单元测试，而无须依赖外部依赖环境。
- 框架无关性：实现将 Django 的框架代码与业务核心解耦，未来可以切换为其他框架或接口形式。
这个示例展示了如何在 Django 项目中引入六边形架构，从而增强复杂系统的稳定性、可维护性和测试能力。这种架构特别适合需要长时间维护和多人协作的大型项目。
