🎨 设计支付网关

# TCC 三阶段实现
class PaymentService:
    
    # 阶段 1: Try - 资源预留
    def try_payment(self, order_id, amount):
        # 1. 冻结用户账户余额
        account_service.freeze_balance(order_id, amount)
        # 2. 创建支付记录（状态：TRYING）
        payment_record.create(status="TRYING")
        return True
    
    # 阶段 2: Confirm - 确认提交
    def confirm_payment(self, order_id):
        # 1. 扣减已冻结的余额
        account_service.deduct_frozen(order_id)
        # 2. 更新支付记录（状态：SUCCESS）
        payment_record.update(order_id, status="SUCCESS")
    
    # 阶段 3: Cancel - 回滚取消
    def cancel_payment(self, order_id):
        # 1. 解冻账户余额
        account_service.unfreeze_balance(order_id)
        # 2. 更新支付记录（状态：CANCEL）
        payment_record.update(order_id, status="CANCEL")
                        

# 幂等性实现代码
def create_payment(self, request):
    # 生成幂等键
    idempotent_key = f"idem:{request.merchant_id}:{request.order_no}"
    
    # Redis 原子操作获取锁
    acquired = redis.set(idempotent_key, "1", nx=True, ex=3600)
    if not acquired:
        # 已存在，返回之前的结果（幂等）
        return self.get_previous_result(request.order_no)
    
    try:
        # 数据库唯一索引兜底
        payment = Payment.objects.create(
            merchant_id=request.merchant_id,
            order_no=request.order_no,
            amount=request.amount
        )
        return self.process_payment(payment)
    except IntegrityError:
        # 唯一索引冲突，返回已存在的订单
        return self.get_existing_payment(request.order_no)
    finally:
        # 释放锁（异步任务处理）
        pass
                        

# 熔断器实现
class CircuitBreaker:
    def __init__(self, failure_threshold=5, recovery_timeout=60):
        self.failure_count = 0
        self.failure_threshold = failure_threshold
        self.state = "CLOSED"  # CLOSED/OPEN/HALF_OPEN
        self.last_failure_time = None
        self.recovery_timeout = recovery_timeout
    
    def execute(self, channel, payment_func):
        if self.state == "OPEN":
            # 检查是否可以进入半开状态
            if time.now() - self.last_failure_time > self.recovery_timeout:
                self.state = "HALF_OPEN"
            else:
                raise CircuitBreakerOpenError("通道已熔断")
        
        try:
            result = payment_func()
            if self.state == "HALF_OPEN":
                self.state = "CLOSED"  # 成功，恢复通道
                self.failure_count = 0
            return result
        except Exception as e:
            self.failure_count += 1
            self.last_failure_time = time.now()
            if self.failure_count >= self.failure_threshold:
                self.state = "OPEN"  # 失败过多，打开熔断
            raise e

# 智能路由选择
def select_channel(payment_request):
    channels = get_available_channels(payment_request)
    # 按优先级排序：权重 > 成功率 > 响应时间
    sorted_channels = sorted(
        channels, 
        key=lambda c: (c.weight, c.success_rate, -c.avg_response_time),
        reverse=True
    )
    for channel in sorted_channels:
        if channel.circuit_breaker.state != "OPEN":
            return channel
    raise NoAvailableChannelError("所有通道不可用")
                        

# 回调通知重试机制
class NotifyService:
    # 重试策略：指数退避
    RETRY_DELAYS = [1, 5, 30, 120, 600, 1800]  # 秒
    MAX_RETRIES = 6
    
    def send_notify(self, order):
        notify_record = NotifyRecord.create(
            order_id=order.id,
            notify_url=order.notify_url,
            status="PENDING"
        )
        # 发送到消息队列
        mq.send("payment.notify", {
            "order_id": order.id,
            "notify_record_id": notify_record.id
        })
    
    def process_notify(self, message):
        notify_record = NotifyRecord.get(message.notify_record_id)
        
        for attempt in range(1, self.MAX_RETRIES + 1):
            try:
                response = http.post(
                    notify_record.notify_url,
                    data=self.build_notify_data(notify_record),
                    timeout=10
                )
                if response.status_code == 200:
                    notify_record.update(status="SUCCESS")
                    return
            except Exception as e:
                # 记录失败日志
                notify_record.add_log(f"第{attempt}次失败：{e}")
            
            # 等待下次重试（指数退避）
            if attempt < self.MAX_RETRIES:
                delay = self.RETRY_DELAYS[attempt - 1]
                # 加入随机抖动，避免雪崩
                jitter = random.uniform(0, delay * 0.2)
                time.sleep(delay + jitter)
        
        # 所有重试失败，标记为失败并告警
        notify_record.update(status="FAILED")
        alert_service.send(f"回调通知失败：{notify_record.order_id}")
                        

# 多级缓存实现
class CacheService:
    def get_merchant_config(self, merchant_id):
        # 1. 本地缓存（L1）
        config = local_cache.get(f"merchant:{merchant_id}")
        if config:
            return config
        
        # 2. Redis 缓存（L2）
        config = redis.get(f"merchant:{merchant_id}")
        if config:
            local_cache.set(f"merchant:{merchant_id}", config, ttl=60)
            return config
        
        # 3. 数据库查询
        config = db.query("SELECT * FROM merchant_config WHERE merchant_id = ?", merchant_id)
        if config:
            redis.set(f"merchant:{merchant_id}", config, ex=300)
            local_cache.set(f"merchant:{merchant_id}", config, ttl=60)
        return config

# 限流实现（令牌桶）
class RateLimiter:
    def __init__(self, capacity, refill_rate):
        self.capacity = capacity  # 桶容量
        self.tokens = capacity
        self.refill_rate = refill_rate  # 每秒补充令牌数
        self.last_refill = time.now()
    
    def try_acquire(self):
        # 补充令牌
        now = time.now()
        elapsed = now - self.last_refill
        self.tokens = min(self.capacity, self.tokens + elapsed * self.refill_rate)
        self.last_refill = now
        
        if self.tokens >= 1:
            self.tokens -= 1
            return True
        return False  # 限流