别院牧志知识库 别院牧志知识库
首页
  • 基础

    • 全栈之路
    • 😎Awesome资源
  • 进阶

    • Python 工匠系列
    • 高阶知识点
  • 指南教程

    • Socket 编程
    • 异步编程
    • PEP 系列
  • Python 面试题
  • 2025 面试记录
  • 2022 面试记录
  • 2021 面试记录
  • 2020 面试记录
  • 2019 面试记录
  • 数据库索引原理
  • 基金

    • 基金知识
    • 基金经理
  • 细读经典

    • 德隆-三个知道
    • 孔曼子-摊大饼理论
    • 配置者说-躺赢之路
    • 资水-建立自己的投资体系
    • 反脆弱
  • Git 参考手册
  • 提问的智慧
  • 分类
  • 标签
  • 归档
GitHub (opens new window)
首页
  • 基础

    • 全栈之路
    • 😎Awesome资源
  • 进阶

    • Python 工匠系列
    • 高阶知识点
  • 指南教程

    • Socket 编程
    • 异步编程
    • PEP 系列
  • Python 面试题
  • 2025 面试记录
  • 2022 面试记录
  • 2021 面试记录
  • 2020 面试记录
  • 2019 面试记录
  • 数据库索引原理
  • 基金

    • 基金知识
    • 基金经理
  • 细读经典

    • 德隆-三个知道
    • 孔曼子-摊大饼理论
    • 配置者说-躺赢之路
    • 资水-建立自己的投资体系
    • 反脆弱
  • Git 参考手册
  • 提问的智慧
  • 分类
  • 标签
  • 归档
GitHub (opens new window)
  • 工作
  • 规范

  • Linux

  • 数据库

  • Git

  • 👨‍💻Web

  • 英语

  • Docker

  • 编辑器

  • 网络

  • 前端

  • 存储

  • 备忘录

    • 面试准备
    • 工作记录
    • 开发记录文档
    • bzsy 记录白皮书
    • 订单超时取消场景详解:基于死信队列的优雅实现
    • 支付系统策略模式实现代码
    • 如何开始你的单元测试
    • 以程序员的视角看中国——西安篇
    • 💻工作
    • 备忘录
    佚名
    2025-06-04
    目录

    支付系统策略模式实现代码

    根据需求描述,我们使用策略模式来实现支付系统中的不同购买行为(新购、升级、续费)。策略模式适用于需要根据不同条件选择不同算法的场景,这里每种购买行为都有独立的支付金额和有效期计算逻辑,因此策略模式是合适的选择。

    # 实现方案

    1. 定义抽象策略接口 PurchaseStrategy,包含计算支付金额和有效期的抽象方法
    2. 实现三种具体策略:
      • NewPurchaseStrategy:处理新购逻辑
      • UpgradeStrategy:处理升级逻辑
      • RenewalStrategy:处理续费逻辑
    3. 使用上下文类 PurchaseContext 来执行策略

    # 代码实现

    from abc import ABC, abstractmethod
    from datetime import datetime, timedelta
    
    class PurchaseStrategy(ABC):
        """购买策略抽象接口"""
        @abstractmethod
        def calculate_amount(self, context: dict) -> float:
            pass
        
        @abstractmethod
        def calculate_expiration(self, context: dict) -> datetime:
            pass
    
    class NewPurchaseStrategy(PurchaseStrategy):
        """新购策略"""
        def calculate_amount(self, context: dict) -> float:
            # 新购直接使用服务价格
            return context['service_price']
        
        def calculate_expiration(self, context: dict) -> datetime:
            # 新购默认一年有效期
            return context['current_time'] + timedelta(days=365)
    
    class UpgradeStrategy(PurchaseStrategy):
        """升级策略"""
        def calculate_amount(self, context: dict) -> float:
            # 计算差价 = (新服务价格 - 旧服务价格) * 剩余时间比例
            time_used = (context['current_time'] - context['original_start_time']).days
            total_duration = 365  # 假设原服务一年期
            remaining_ratio = 1 - time_used / total_duration
            return (context['new_service_price'] - context['original_service_price']) * remaining_ratio
        
        def calculate_expiration(self, context: dict) -> datetime:
            # 新到期时间 = 当前时间 + 剩余时间 + 新服务时长
            original_remaining = context['original_expiration'] - context['current_time']
            new_duration = timedelta(days=365)  # 新服务一年
            return context['current_time'] + original_remaining + new_duration
    
    class RenewalStrategy(PurchaseStrategy):
        """续费策略"""
        def calculate_amount(self, context: dict) -> float:
            # 续费价格 = 服务价格 × 续费年限
            return context['service_price'] * context['renewal_years']
        
        def calculate_expiration(self, context: dict) -> datetime:
            # 在原始到期时间上增加续费年限
            return context['original_expiration'] + timedelta(days=365 * context['renewal_years'])
    
    class PurchaseContext:
        """购买上下文,执行具体策略"""
        def __init__(self, strategy: PurchaseStrategy):
            self._strategy = strategy
        
        def execute_calculation(self, context: dict) -> dict:
            """执行策略计算"""
            return {
                "amount": self._strategy.calculate_amount(context),
                "expiration": self._strategy.calculate_expiration(context)
            }
    
    # 示例使用
    if __name__ == "__main__":
        # 公共参数
        current_time = datetime.now()
        original_start_time = current_time - timedelta(days=100)  # 假设100天前购买
        original_expiration = original_start_time + timedelta(days=365)  # 原服务有效期
        
        # 新购示例
        new_purchase_context = {
            'current_time': current_time,
            'service_price': 100.0
        }
        context = PurchaseContext(NewPurchaseStrategy())
        result = context.execute_calculation(new_purchase_context)
        print(f"新购结果: 金额={result['amount']}, 到期时间={result['expiration']}")
        
        # 升级示例
        upgrade_context = {
            'current_time': current_time,
            'original_start_time': original_start_time,
            'original_expiration': original_expiration,
            'original_service_price': 80.0,
            'new_service_price': 120.0
        }
        context = PurchaseContext(UpgradeStrategy())
        result = context.execute_calculation(upgrade_context)
        print(f"升级结果: 金额={result['amount']:.2f}, 到期时间={result['expiration']}")
        
        # 续费示例
        renewal_context = {
            'original_expiration': original_expiration,
            'service_price': 90.0,
            'renewal_years': 2  # 续费两年
        }
        context = PurchaseContext(RenewalStrategy())
        result = context.execute_calculation(renewal_context)
        print(f"续费结果: 金额={result['amount']}, 到期时间={result['expiration']}")
    
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    96
    97

    # 策略说明

    1. 新购策略:

      • 支付金额:直接使用服务价格
      • 有效期:从当前时间开始计算一年
    2. 升级策略:

      • 支付金额:计算新旧服务差价 × 剩余时间比例
      • 有效期:原始剩余时间 + 新服务时长(一年)
    3. 续费策略:

      • 支付金额:服务价格 × 续费年限
      • 有效期:在原始到期时间上增加续费年限

    # 策略模式选择理由

    • 扩展性:新增购买类型只需添加新策略类
    • 解耦:将业务逻辑与客户端代码分离
    • 复用性:共用计算接口,便于统一管理

    此实现严格遵循需求描述,对时间计算使用天数为单位(按 365 天/年),实际生产环境可根据业务需求调整时间计算精度。

    编辑 (opens new window)
    #设计模式#项目#支付系统
    上次更新: 2025-06-04, 07:40:06
    订单超时取消场景详解:基于死信队列的优雅实现
    如何开始你的单元测试

    ← 订单超时取消场景详解:基于死信队列的优雅实现 如何开始你的单元测试→

    最近更新
    01
    Flask 运行周期及工作原理
    06-05
    02
    Python 中 OOM(内存泄漏)问题的定位与分析
    05-30
    03
    MySQL 的 MVCC 与锁机制的关联和区别
    05-28
    更多文章>
    Theme by Vdoing | Copyright © 2019-2025 IMOYAO | 别院牧志
    • 跟随系统
    • 浅色模式
    • 深色模式
    • 阅读模式