#django微服务架构 - 从单体到分布式系统的演进

# order_service/models.py
from django.db import models

class Order(models.Model):
    STATUS_CHOICES = [
        ('pending', '待支付'),
        ('paid', '已支付'),
        ('shipped', '已发货'),
    ]
    # 只保存外部服务的ID，不做数据库层面的关联
    user_id = models.IntegerField()
    total_amount = models.DecimalField(max_digits=10, decimal_places=2)
    status = models.CharField(max_length=20, choices=STATUS_CHOICES, default='pending')
    created_at = models.DateTimeField(auto_now_add=True)

class OrderItem(models.Model):
    order = models.ForeignKey(Order, on_delete=models.CASCADE, related_name='items')
    product_id = models.IntegerField()
    quantity = models.PositiveIntegerField()
    unit_price = models.DecimalField(max_digits=10, decimal_places=2)

# gateway_app/views.py
from rest_framework.views import APIView
from rest_framework.response import Response
import requests
from django.conf import settings

class GatewayView(APIView):
    # 路由映射表，生产环境中可以存入数据库或注册中心（如 Consul）
    ROUTE_MAP = {
        '/api/users/': 'http://user-service:8000',
        '/api/products/': 'http://product-service:8000',
        '/api/orders/': 'http://order-service:8000',
    }

    def dispatch(self, request, *args, **kwargs):
        # 1. 匹配目标服务
        target_url = None
        for prefix, base in self.ROUTE_MAP.items():
            if request.path.startswith(prefix):
                target_url = f"{base}{request.path}"
                break
        if not target_url:
            return Response({'error': 'Route not found'}, status=404)

        # 2. 过滤并透传请求头
        headers = self._filter_headers(request.META)

        # 3. 发起转发请求，做好超时和exception-handling
        try:
            resp = requests.request(
                method=request.method,
                url=target_url,
                headers=headers,
                params=request.query_params,
                data=request.body,
                timeout=30
            )
            return Response(
                resp.json() if resp.content else None,
                status=resp.status_code
            )
        except requests.exceptions.Timeout:
            return Response({'error': 'Service timeout'}, status=504)
        except Exception as e:
            return Response({'error': 'Service unavailable'}, status=503)

    def _filter_headers(self, meta):
        """只保留业务相关的HTTP头，去掉django内部元信息"""
        headers = {}
        for k, v in meta.items():
            if k.startswith('HTTP_'):
                # 转换为标准的头部格式，如 HTTP_X_USER_ID -> X-User-Id
                key = k[5:].replace('_', '-').title()
                headers[key] = v
        return headers

# user_service_client.py
import requests
from django.conf import settings

class UserServiceClient:
    BASE_URL = settings.USER_SERVICE_URL

    @classmethod
    def get_user(cls, user_id):
        try:
            resp = requests.get(
                f"{cls.BASE_URL}/api/users/{user_id}/",
                timeout=5
            )
            resp.raise_for_status()
            return resp.json()
        except Exception as e:
            # 实际项目中可以添加降级逻辑（如返回缓存数据或默认值）
            return None

# message_queue.py
import redis
import json
import uuid
from datetime import datetime
from django.conf import settings

r = redis.from_url(settings.REDIS_URL)

class MessageQueue:
    @staticmethod
    def publish(event_type, data):
        """发布事件到频道和持久化队列"""
        event = {
            'id': str(uuid.uuid4()),
            'type': event_type,
            'data': data,
            'timestamp': datetime.utcnow().isoformat()
        }
        # Pub/Sub 用于即时通知
        r.publish('events', json.dumps(event))
        # 同时推入队列列表，保证消息不丢失（消费者轮询处理）
        r.lpush(f"queue:{event_type}", json.dumps(event))

    @staticmethod
    def subscribe(event_type, handler):
        """订阅事件（简化版，生产建议用 Celery 或 Kafka 消费者）"""
        pubsub = r.pubsub()
        pubsub.subscribe('events')
        for msg in pubsub.listen():
            if msg['type'] == 'message':
                event = json.loads(msg['data'])
                if event['type'] == event_type:
                    handler(event)

# order_service/views.py
from rest_framework.views import APIView
from rest_framework.response import Response
from .models import Order
from .message_queue import MessageQueue

class OrderCreateView(APIView):
    def post(self, request):
        # 1. 本地事务：创建订单
        order = Order.objects.create(
            user_id=request.user.id,
            total_amount=request.data['total_amount'],
            status='pending'
        )

        # 2. 发布事件，触发后续异步流程
        MessageQueue.publish('order_created', {
            'order_id': order.id,
            'user_id': order.user_id,
            'items': request.data['items']
        })
        return Response({'order_id': order.id}, status=201)

# order_service/saga.py
from .models import Order
from .user_service_client import UserServiceClient
from .product_service_client import ProductServiceClient

class OrderSaga:
    @staticmethod
    def execute(order_id):
        order = Order.objects.get(id=order_id)
        try:
            # 步骤1：预扣库存（内部由商品服务本地事务保证）
            ProductServiceClient.reserve_inventory(order.items)

            # 步骤2：扣减用户余额
            UserServiceClient.deduct_balance(order.user_id, order.total_amount)

            # 步骤3：更新订单状态
            order.status = 'paid'
            order.save()

        except Exception as e:
            # 任何一步失败，执行补偿
            OrderSaga.compensate(order_id)
            raise e

    @staticmethod
    def compensate(order_id):
        order = Order.objects.get(id=order_id)
        # 释放库存
        ProductServiceClient.release_inventory(order.items)
        # 如果余额已扣减，发起退款
        if order.status == 'paid':
            UserServiceClient.refund_balance(order.user_id, order.total_amount)
        # 最终关闭订单
        order.status = 'cancelled'
        order.save()