引言：设计模式与重构的内在联系

在软件开发领域，设计模式（Design Patterns）和代码重构（Refactoring）是两个核心概念，它们看似独立，实则紧密相连。设计模式提供了一套经过验证的解决方案，用于解决常见的软件设计问题；而重构则是通过一系列小步修改来改善代码的内部结构，而不改变其外部行为。两者结合使用，能够显著提升代码的可维护性、可扩展性和可读性。

本文将深入探讨设计模式与重构之间的关联，并通过详细的示例展示如何通过重构引入设计模式来解决代码中的”坏味道”（Code Smells）。我们将从理论基础出发，逐步分析实际案例，提供完整的代码示例和重构步骤，帮助读者掌握这一重要技能。

第一部分：设计模式与重构的基本概念

1.1 设计模式概述

设计模式是软件工程中反复出现的问题的通用解决方案模板。它们源于经验丰富的开发者对常见问题的总结和提炼。设计模式通常分为三大类：

  • 创建型模式：关注对象的创建机制（如工厂模式、单例模式）
  • 结构型模式：关注对象之间的组合（如适配器模式、装饰器模式）
  • 行为型模式：关注对象之间的交互和职责分配（如策略模式、观察者模式）

设计模式不是具体的代码实现，而是描述了一种解决问题的思路和结构。使用设计模式的好处包括：

  • 提高代码的可重用性
  • 降低模块间的耦合度
  • 使代码更易于理解和维护
  • 提供通用的词汇表，便于团队沟通

1.2 重构的概念与原则

重构是在不改变软件可观察行为的前提下，对代码内部结构进行调整的过程。重构的目标是改善代码的设计，使其更易于理解、修改和扩展。

重构的关键原则包括：

  • 小步前进：每次只做微小的修改，并确保每一步都不会破坏现有功能
  • 测试驱动：拥有可靠的测试套件是安全重构的前提
  • 持续进行：重构应该是开发过程中的常规活动，而非一次性任务
  • 保持行为不变：重构只改变代码的内部结构，不改变外部行为

常见的重构技术包括：

  • 提取方法（Extract Method）
  • 提取类（Extract Class）
  • 移动方法（Move Method）
  • 替换条件表达式为多态（Replace Conditional with Polymorphism）

1.3 设计模式与重构的关联

设计模式与重构之间存在着天然的联系：

  1. 重构是引入设计模式的桥梁：设计模式通常需要特定的代码结构才能发挥作用。通过重构，我们可以将现有代码调整为适合应用设计模式的结构。

  2. 设计模式为重构提供目标：当代码出现某些坏味道时，设计模式提供了具体的改进方向。例如，当发现大量的条件分支时，可以考虑使用策略模式或状态模式。

  3. 两者都关注代码质量：设计模式和重构都致力于创建更灵活、更易维护的代码。

  4. 迭代过程：重构和设计模式的使用往往是一个迭代过程：先通过重构识别问题，然后应用设计模式解决问题，再通过重构优化实现。

第二部分：代码坏味道识别

在深入探讨如何通过重构引入设计模式之前，我们需要先了解常见的代码坏味道。这些坏味道是代码中可能存在的问题信号，提示我们需要进行重构。

2.1 常见代码坏味道

  1. 重复代码（Duplicated Code）：相同的代码结构在多个地方出现
  2. 过长函数（Long Method）：函数代码行数过多，难以理解
  3. 过大的类（Large Class）：类承担了过多的职责
  4. 过长参数列表（Long Parameter List）：函数参数过多
  5. 发散式变化（Divergent Change）：一个类因不同原因被多次修改
  6. 霰弹式修改（Shotgun Surgery）：一个需求变更导致多处代码修改
  7. 依恋情结（Feature Envy）：函数过度依赖其他对象的数据
  8. 数据泥团（Data Clumps）：多个数据项总是同时出现
  9. switch语句（Switch Statements）：复杂的switch或if-else链
  10. 平行继承体系（Parallel Inheritance Hierarchies）：每增加一个类，都需要增加另一个类
  11. 过度设计/设计不足：过早使用复杂模式或完全不考虑设计

2.2 识别坏味道的重要性

识别坏味道是重构的第一步。这些信号表明代码可能存在设计问题，需要改进。例如：

  • “switch语句”坏味道往往提示我们可以使用策略模式或状态模式
  • “过大的类”可能意味着需要使用组合模式或职责链模式
  • “重复代码”可能需要模板方法模式或策略模式

第三部分：通过重构引入设计模式的策略

3.1 重构引入设计模式的一般步骤

  1. 识别坏味道：通过代码审查或工具检测发现潜在问题
  2. 选择合适的设计模式：根据问题类型选择适当的设计模式
  3. 准备重构环境：确保有可靠的测试覆盖
  4. 小步重构：通过一系列小的、安全的重构步骤引入模式
  5. 验证结果：确保重构后功能不变，且解决了原有问题

3.2 关键重构技术

在引入设计模式时，以下重构技术特别有用：

  • 提取接口（Extract Interface）：为设计模式创建抽象
  • 提取类（Extract Class）：分离职责
  • 移动方法/字段（Move Method/Field）：调整对象职责
  • 替换条件为多态（Replace Conditional with Polymorphism）：消除switch/if-else
  • 引入参数对象（Introduce Parameter Object）：简化参数列表
  • 提取方法对象（Extract Method Object）：将方法转换为对象

第四部分：实战案例 - 使用策略模式解决条件分支问题

4.1 案例背景：电商系统折扣计算

假设我们有一个电商系统，需要根据不同的客户类型计算折扣。初始代码如下：

# 重构前的代码 - 充满条件分支的坏味道 class Order: def __init__(self, customer_type, amount): self.customer_type = customer_type self.amount = amount def calculate_discount(self): """计算折扣 - 存在大量条件分支的坏味道""" if self.customer_type == "regular": return self.amount * 0.05 # 5%折扣 elif self.customer_type == "premium": return self.amount * 0.1 # 10%折扣 elif self.customer_type == "vip": return self.amount * 0.15 # 15%折扣 elif self.customer_type == "employee": return self.amount * 0.2 # 20%折扣 else: return 0 # 无折扣 def get_final_price(self): """获取最终价格""" discount = self.calculate_discount() return self.amount - discount

4.2 识别坏味道

这段代码存在以下问题：

  1. switch/if-else坏味道：复杂的条件分支
  2. 违反开闭原则：添加新客户类型需要修改现有代码
  3. 单一职责问题：Order类承担了折扣计算的职责
  4. 可测试性差：难以单独测试不同的折扣策略

4.3 重构步骤

步骤1：提取折扣策略接口

首先，我们提取一个折扣策略接口，这是引入策略模式的第一步。

from abc import ABC, abstractmethod # 步骤1：提取策略接口 class DiscountStrategy(ABC): """折扣策略接口""" @abstractmethod def calculate_discount(self, amount: float) -> float: """计算折扣金额""" pass

步骤2：创建具体策略实现

为每种客户类型创建具体策略类：

# 步骤2：创建具体策略实现 class RegularCustomerDiscount(DiscountStrategy): """普通客户折扣策略""" def calculate_discount(self, amount: float) -> float: return amount * 0.05 class PremiumCustomerDiscount(DiscountStrategy): """高级客户折扣策略""" def calculate_discount(self, amount: float) -> float: return amount * 0.1 class VipCustomerDiscount(DiscountStrategy): """VIP客户折扣策略""" def calculate_discount(self, amount: float) -> float: return amount * 0.15 class EmployeeDiscount(DiscountStrategy): """员工折扣策略""" def calculate_discount(self, amount: float) -> float: return amount * 0.2

步骤3：创建策略工厂

为了方便创建策略实例，可以添加一个工厂：

# 步骤3：创建策略工厂（可选，但推荐） class DiscountStrategyFactory: """折扣策略工厂""" _strategies = { "regular": RegularCustomerDiscount, "premium": PremiumCustomerDiscount, "vip": VipCustomerDiscount, "employee": EmployeeDiscount } @classmethod def get_strategy(cls, customer_type: str) -> DiscountStrategy: """获取对应的折扣策略""" strategy_class = cls._strategies.get(customer_type) if not strategy_class: raise ValueError(f"Unknown customer type: {customer_type}") return strategy_class()

步骤4：重构Order类

现在我们可以重构Order类，使用策略模式：

# 步骤4：重构Order类 class Order: def __init__(self, customer_type: str, amount: float): self.amount = amount # 使用工厂获取策略，避免直接依赖具体类 self.discount_strategy = DiscountStrategyFactory.get_strategy(customer_type) def calculate_discount(self) -> float: """计算折扣 - 现在委托给策略对象""" return self.discount_strategy.calculate_discount(self.amount) def get_final_price(self) -> float: """获取最终价格""" discount = self.calculate_discount() return self.amount - discount

4.4 重构后的代码优势

重构后的代码具有以下优势：

  1. 消除条件分支：复杂的if-else被简单的对象调用替代
  2. 符合开闭原则：添加新客户类型只需新增策略类，无需修改现有代码
  3. 职责分离：折扣计算逻辑从Order类中分离出来
  4. 易于扩展：可以轻松添加新的折扣策略
  5. 易于测试：每个策略可以独立测试

4.5 使用示例

# 使用示例 if __name__ == "__main__": # 创建不同类型的订单 regular_order = Order("regular", 1000) premium_order = Order("premium", 1000) vip_order = Order("vip", 1000) employee_order = Order("employee", 1000) print(f"普通客户: 原价1000, 折扣{regular_order.calculate_discount()}, 最终价格{regular_order.get_final_price()}") print(f"高级客户: 原价1000, 折扣{premium_order.calculate_discount()}, 最终价格{premium_order.get_final_price()}") print(f"VIP客户: 原价1000, 折扣{vip_order.calculate_discount()}, 最终价格{vip_order.get_final_price()}") print(f"员工: 原价1000, 折扣{employee_order.calculate_discount()}, 最终价格{employee_order.get_final_price()}") # 添加新客户类型非常简单 class NewCustomerDiscount(DiscountStrategy): """新客户折扣策略""" def calculate_discount(self, amount: float) -> float: return amount * 0.08 # 只需在工厂中注册新策略 DiscountStrategyFactory._strategies["new"] = NewCustomerDiscount new_customer_order = Order("new", 1000) print(f"新客户: 原价1000, 折扣{new_customer_order.calculate_discount()}, 最终价格{new_customer_order.get_final_price()}")

第五部分：实战案例 - 使用模板方法模式消除重复代码

5.1 案例背景：数据处理流程

假设我们有一个数据处理系统，需要处理不同格式的数据（CSV、JSON、XML），但处理流程基本相同：

# 重构前 - 重复代码的坏味道 class CSVDataProcessor: def process(self, file_path): # 1. 读取数据 print(f"Reading CSV file: {file_path}") data = self.read_csv(file_path) # 2. 验证数据 print("Validating data...") validated_data = self.validate_data(data) # 3. 转换数据 print("Transforming data...") transformed_data = self.transform_data(validated_data) # 4. 保存结果 print("Saving results...") self.save_results(transformed_data) def read_csv(self, file_path): return f"CSV data from {file_path}" def validate_data(self, data): return f"Validated {data}" def transform_data(self, data): return f"Transformed {data}" def save_results(self, data): print(f"Saved: {data}") class JSONDataProcessor: def process(self, file_path): # 1. 读取数据 print(f"Reading JSON file: {file_path}") data = self.read_json(file_path) # 2. 验证数据 print("Validating data...") validated_data = self.validate_data(data) # 3. 转换数据 print("Transforming data...") transformed_data = self.transform_data(validated_data) # 4. 保存结果 print("Saving results...") self.save_results(transformed_data) def read_json(self, file_path): return f"JSON data from {file_path}" def validate_data(self, data): return f"Validated {data}" def transform_data(self, data): return f"Transformed {data}" def save_results(self, data): print(f"Saved: {data}") class XMLDataProcessor: def process(self, file_path): # 1. 读取数据 print(f"Reading XML file: {file_path}") data = self.read_xml(file_path) # 2. 验证数据 print("Validating data...") validated_data = self.validate_data(data) # 3. 转换数据 print("Transforming data...") transformed_data = self.transform_data(validated_data) # 4. 保存结果 print("Saving results...") self.save_results(transformed_data) def read_xml(self, file_path): return f"XML data from {file_path}" def validate_data(self, data): return f"Validated {data}" def transform_data(self, data): return f"Transformed {data}" def save_results(self, data): print(f"Saved: {data}")

5.2 识别坏味道

这段代码存在明显的重复代码坏味道：

  1. process方法几乎完全相同：只有读取数据的部分不同
  2. 验证、转换、保存逻辑重复：这些方法在不同类中完全相同
  3. 违反DRY原则：相同的代码结构在多处重复

5.3 重构步骤

步骤1：创建抽象基类

首先创建一个抽象基类，定义模板方法：

from abc import ABC, abstractmethod # 步骤1：创建抽象基类 class DataProcessor(ABC): """数据处理器抽象基类 - 模板方法模式""" def process(self, file_path): """ 模板方法：定义数据处理的固定流程 这个方法不能被子类重写，定义了算法的骨架 """ # 1. 读取数据 data = self.read_data(file_path) # 2. 验证数据 validated_data = self.validate_data(data) # 3. 转换数据 transformed_data = self.transform_data(validated_data) # 4. 保存结果 self.save_results(transformed_data) @abstractmethod def read_data(self, file_path): """抽象方法：子类必须实现具体的读取逻辑""" pass def validate_data(self, data): """钩子方法：提供默认实现，子类可以选择重写""" print("Validating data...") return f"Validated {data}" def transform_data(self, data): """钩子方法：提供默认实现，子类可以选择重写""" print("Transforming data...") return f"Transformed {data}" def save_results(self, data): """钩子方法：提供默认实现，子类可以选择重写""" print("Saving results...") print(f"Saved: {data}")

步骤2：创建具体实现类

现在创建具体的处理器类，只需实现不同的部分：

# 步骤2：创建具体实现类 class CSVDataProcessor(DataProcessor): def read_data(self, file_path): print(f"Reading CSV file: {file_path}") return f"CSV data from {file_path}" class JSONDataProcessor(DataProcessor): def read_data(self, file_path): print(f"Reading JSON file: {file_path}") return f"JSON data from {file_path}" class XMLDataProcessor(DataProcessor): def read_data(self, file_path): print(f"Reading XML file: {file_path}") return f"XML data from {file_path}"

步骤3：添加钩子方法（可选）

如果需要，可以添加钩子方法让子类定制流程：

# 步骤3：扩展基类，添加钩子方法 class AdvancedDataProcessor(ABC): """扩展版的模板方法，支持钩子""" def process(self, file_path): """扩展的模板方法，支持钩子控制流程""" # 1. 读取数据 data = self.read_data(file_path) # 2. 验证数据（如果需要） if self.should_validate(): data = self.validate_data(data) # 3. 转换数据（如果需要） if self.should_transform(): data = self.transform_data(data) # 4. 保存结果 self.save_results(data) @abstractmethod def read_data(self, file_path): pass def validate_data(self, data): print("Validating data...") return f"Validated {data}" def transform_data(self, data): print("Transforming data...") return f"Transformed {data}" def save_results(self, data): print("Saving results...") print(f"Saved: {data}") # 钩子方法 - 子类可以重写这些方法来改变流程 def should_validate(self): """是否执行验证步骤""" return True def should_transform(self): """是否执行转换步骤""" return True class FastDataProcessor(AdvancedDataProcessor): """快速处理器，跳过验证和转换""" def read_data(self, file_path): print(f"Quick reading file: {file_path}") return f"Quick data from {file_path}" def should_validate(self): return False # 跳过验证 def should_transform(self): return False # 跳过转换

5.4 重构后的代码优势

  1. 消除重复代码：共同的流程逻辑只在基类中存在一份
  2. 强制一致性：所有处理器遵循相同的处理流程
  3. 易于扩展：添加新处理器只需实现read_data方法
  4. 灵活定制：通过钩子方法可以定制流程
  5. 符合单一职责：基类负责流程控制，子类负责具体实现

5.5 使用示例

# 使用示例 if __name__ == "__main__": print("=== 使用模板方法模式重构后 ===") # CSV处理 csv_processor = CSVDataProcessor() csv_processor.process("data.csv") print() # JSON处理 json_processor = JSONDataProcessor() json_processor.process("data.json") print() # XML处理 xml_processor = XMLDataProcessor() xml_processor.process("data.xml") print() # 快速处理（跳过验证和转换） fast_processor = FastDataProcessor() fast_processor.process("data.csv")

第六部分：实战案例 - 使用工厂模式解决对象创建复杂性

6.1 案例背景：日志系统

假设我们有一个日志系统，需要根据不同的环境创建不同类型的日志记录器：

# 重构前 - 复杂的对象创建逻辑 class Logger: def __init__(self, environment, enable_file_logging=False, enable_console_logging=True, log_level="INFO", file_path=None): self.environment = environment self.enable_file_logging = enable_file_logging self.enable_console_logging = enable_console_logging self.log_level = log_level self.file_path = file_path # 复杂的初始化逻辑 if environment == "development": if enable_console_logging: self.console_logger = ConsoleLogger("DEBUG") if enable_file_logging: if not file_path: file_path = "app_debug.log" self.file_logger = FileLogger(file_path, "DEBUG") elif environment == "production": if enable_console_logging: self.console_logger = ConsoleLogger("WARNING") if enable_file_logging: if not file_path: file_path = "app_production.log" self.file_logger = FileLogger(file_path, "WARNING") elif environment == "test": if enable_console_logging: self.console_logger = ConsoleLogger("ERROR") if enable_file_logging: if not file_path: file_path = "app_test.log" self.file_logger = FileLogger(file_path, "ERROR") else: raise ValueError(f"Unknown environment: {environment}") def log(self, message): if hasattr(self, 'console_logger'): self.console_logger.log(message) if hasattr(self, 'file_logger'): self.file_logger.log(message) class ConsoleLogger: def __init__(self, level): self.level = level def log(self, message): print(f"[{self.level}] {message}") class FileLogger: def __init__(self, file_path, level): self.file_path = file_path self.level = level def log(self, message): # 实际会写入文件，这里简化 print(f"Writing to {self.file_path}: [{self.level}] {message}")

6.2 识别坏味道

这段代码的问题：

  1. 构造函数过长：参数过多，逻辑复杂
  2. 违反单一职责：Logger类负责创建和管理子记录器
  3. 难以测试：创建逻辑复杂，难以模拟
  4. 违反开闭原则：添加新环境需要修改Logger类
  5. 条件分支复杂：大量的if-else用于创建对象

6.3 重构步骤

步骤1：提取工厂方法

首先将创建逻辑提取到单独的工厂类中：

# 步骤1：创建工厂类 class LoggerFactory: """日志记录器工厂""" @staticmethod def create_logger(environment, enable_file_logging=False, enable_console_logging=True, file_path=None): """创建日志记录器""" # 确定日志级别 log_level = LoggerFactory._get_log_level(environment) # 创建控制台记录器 console_logger = None if enable_console_logging: console_logger = ConsoleLogger(log_level) # 创建文件记录器 file_logger = None if enable_file_logging: if not file_path: file_path = LoggerFactory._get_default_file_path(environment) file_logger = FileLogger(file_path, log_level) # 创建组合记录器 return Logger(console_logger, file_logger) @staticmethod def _get_log_level(environment): """获取环境对应的日志级别""" levels = { "development": "DEBUG", "production": "WARNING", "test": "ERROR" } return levels.get(environment, "INFO") @staticmethod def _get_default_file_path(environment): """获取默认文件路径""" paths = { "development": "app_debug.log", "production": "app_production.log", "test": "app_test.log" } return paths.get(environment, "app.log")

步骤2：简化Logger类

# 步骤2：简化Logger类 class Logger: def __init__(self, console_logger=None, file_logger=None): self.console_logger = console_logger self.file_logger = file_logger def log(self, message): if self.console_logger: self.console_logger.log(message) if self.file_logger: self.file_logger.log(message)

步骤3：使用工厂创建对象

# 步骤3：使用工厂创建对象 # 使用示例 logger = LoggerFactory.create_logger( environment="production", enable_file_logging=True, enable_console_logging=True ) logger.log("This is a log message")

6.4 进一步优化：抽象工厂模式

如果需要创建一系列相关的对象，可以使用抽象工厂模式：

from abc import ABC, abstractmethod # 抽象工厂 class LoggerFactory(ABC): @abstractmethod def create_console_logger(self): pass @abstractmethod def create_file_logger(self): pass def create_logger(self): return Logger(self.create_console_logger(), self.create_file_logger()) # 具体工厂 class DevelopmentLoggerFactory(LoggerFactory): def create_console_logger(self): return ConsoleLogger("DEBUG") def create_file_logger(self): return FileLogger("app_debug.log", "DEBUG") class ProductionLoggerFactory(LoggerFactory): def create_console_logger(self): return ConsoleLogger("WARNING") def create_file_logger(self): return FileLogger("app_production.log", "WARNING") # 使用 factory = ProductionLoggerFactory() logger = factory.create_logger() logger.log("Production log message")

第七部分：综合案例 - 从坏味道到设计模式的完整流程

7.1 案例背景：订单处理系统

让我们看一个更复杂的案例，展示完整的重构流程。

初始代码（多种坏味道）：

# 重构前 - 充满各种坏味道的订单处理系统 class OrderProcessor: def __init__(self, order_type): self.order_type = order_type def process_order(self, order_data): # 坏味道1：过长函数 # 坏味道2：重复代码 # 坏味道3：switch语句 # 验证订单 if not order_data: raise ValueError("Order data cannot be empty") # 根据订单类型处理 if self.order_type == "domestic": # 国内订单处理 print("Processing domestic order...") # 验证地址 if not self.validate_domestic_address(order_data.get("address")): raise ValueError("Invalid domestic address") # 计算运费 shipping_cost = self.calculate_domestic_shipping(order_data.get("weight")) # 处理支付 payment_result = self.process_payment(order_data.get("payment"), "domestic") # 发货 shipping_result = self.ship_domestic(order_data.get("address"), order_data.get("items")) return { "shipping_cost": shipping_cost, "payment": payment_result, "shipping": shipping_result } elif self.order_type == "international": # 国际订单处理 print("Processing international order...") # 验证地址 if not self.validate_international_address(order_data.get("address")): raise ValueError("Invalid international address") # 计算运费（更复杂） shipping_cost = self.calculate_international_shipping( order_data.get("weight"), order_data.get("country") ) # 处理支付（需要额外验证） payment_result = self.process_payment(order_data.get("payment"), "international") # 海关申报 customs_result = self.process_customs(order_data.get("items"), order_data.get("country")) # 发货 shipping_result = self.ship_international(order_data.get("address"), order_data.get("items")) return { "shipping_cost": shipping_cost, "payment": payment_result, "customs": customs_result, "shipping": shipping_result } elif self.order_type == "express": # 快递订单处理 print("Processing express order...") # 验证地址 if not self.validate_domestic_address(order_data.get("address")): raise ValueError("Invalid address") # 计算运费（加急） shipping_cost = self.calculate_express_shipping(order_data.get("weight")) # 处理支付 payment_result = self.process_payment(order_data.get("payment"), "express") # 加急发货 shipping_result = self.ship_express(order_data.get("address"), order_data.get("items")) return { "shipping_cost": shipping_cost, "payment": payment_result, "shipping": shipping_result } # 重复的验证方法 def validate_domestic_address(self, address): # 实际验证逻辑 return bool(address) def validate_international_address(self, address): # 实际验证逻辑 return bool(address) # 重复的运费计算方法 def calculate_domestic_shipping(self, weight): return weight * 2 def calculate_international_shipping(self, weight, country): return weight * 5 + 10 def calculate_express_shipping(self, weight): return weight * 3 + 5 # 重复的支付处理方法 def process_payment(self, payment_info, order_type): print(f"Processing {order_type} payment...") return f"Payment processed for {order_type}" # 重复的发货方法 def ship_domestic(self, address, items): return f"Domestic shipment to {address}" def ship_international(self, address, items): return f"International shipment to {address}" def ship_express(self, address, items): return f"Express shipment to {address}" def process_customs(self, items, country): return f"Customs declaration for {country}"

7.2 识别坏味道

这段代码存在多种坏味道：

  1. 过长函数：process_order方法超过50行
  2. 重复代码：地址验证、支付处理等逻辑重复
  3. switch语句：大量的if-elif分支
  4. 过大类：OrderProcessor承担了所有职责
  5. 依恋情结：方法过度依赖order_data
  6. 数据泥团：order_data中的字段经常一起使用

7.3 重构策略

我们将使用多种设计模式结合：

  1. 策略模式：处理不同订单类型的处理逻辑
  2. 模板方法模式：定义订单处理的通用流程
  3. 工厂模式：创建不同的处理器
  4. 组合模式：处理海关申报等可选步骤

7.4 重构步骤

步骤1：定义领域对象

# 步骤1：定义领域对象，消除数据泥团 from dataclasses import dataclass from typing import List, Optional @dataclass class Address: street: str city: str country: str postal_code: str @dataclass class OrderItem: name: str quantity: int weight: float @dataclass class PaymentInfo: method: str amount: float currency: str = "USD" @dataclass class Order: order_id: str order_type: str address: Address items: List[OrderItem] payment: PaymentInfo weight: Optional[float] = None def calculate_total_weight(self): if self.weight: return self.weight return sum(item.weight * item.quantity for item in self.items)

步骤2：创建策略接口和实现

# 步骤2：使用策略模式处理不同订单类型 from abc import ABC, abstractmethod class OrderProcessingStrategy(ABC): """订单处理策略接口""" @abstractmethod def validate_address(self, address: Address) -> bool: pass @abstractmethod def calculate_shipping_cost(self, order: Order) -> float: pass @abstractmethod def process_payment(self, order: Order) -> str: pass @abstractmethod def ship_order(self, order: Order) -> str: pass def needs_customs_processing(self) -> bool: """钩子方法：是否需要海关处理""" return False def process_customs(self, order: Order) -> Optional[str]: """钩子方法：海关处理""" return None class DomesticOrderStrategy(OrderProcessingStrategy): """国内订单策略""" def validate_address(self, address: Address) -> bool: print("Validating domestic address...") return bool(address and address.country == "USA") def calculate_shipping_cost(self, order: Order) -> float: weight = order.calculate_total_weight() return weight * 2.0 def process_payment(self, order: Order) -> str: print("Processing domestic payment...") return f"Domestic payment processed: {order.payment.amount} {order.payment.currency}" def ship_order(self, order: Order) -> str: return f"Domestic shipment to {order.address.city}" class InternationalOrderStrategy(OrderProcessingStrategy): """国际订单策略""" def validate_address(self, address: Address) -> bool: print("Validating international address...") return bool(address and address.country != "USA") def calculate_shipping_cost(self, order: Order) -> float: weight = order.calculate_total_weight() base_cost = weight * 5.0 # 根据国家增加额外费用 if order.address.country in ["Canada", "Mexico"]: return base_cost + 5.0 return base_cost + 10.0 def process_payment(self, order: Order) -> str: print("Processing international payment with additional verification...") return f"International payment processed: {order.payment.amount} {order.payment.currency}" def ship_order(self, order: Order) -> str: return f"International shipment to {order.address.country}" def needs_customs_processing(self) -> bool: return True def process_customs(self, order: Order) -> str: items_desc = ", ".join([item.name for item in order.items]) return f"Customs declaration for {order.address.country}: {items_desc}" class ExpressOrderStrategy(OrderProcessingStrategy): """快递订单策略""" def validate_address(self, address: Address) -> bool: print("Validating express address...") return bool(address) def calculate_shipping_cost(self, order: Order) -> float: weight = order.calculate_total_weight() return weight * 3.0 + 5.0 # 基础费+加急费 def process_payment(self, order: Order) -> str: print("Processing express payment with priority...") return f"Express payment processed: {order.payment.amount} {order.payment.currency}" def ship_order(self, order: Order) -> str: return f"Express shipment to {order.address.city} - PRIORITY"

步骤3：创建策略工厂

# 步骤3：创建策略工厂 class OrderProcessingStrategyFactory: """订单处理策略工厂""" _strategies = { "domestic": DomesticOrderStrategy, "international": InternationalOrderStrategy, "express": ExpressOrderStrategy } @classmethod def get_strategy(cls, order_type: str) -> OrderProcessingStrategy: strategy_class = cls._strategies.get(order_type) if not strategy_class: raise ValueError(f"Unknown order type: {order_type}") return strategy_class()

步骤4：使用模板方法模式创建处理器

# 步骤4：使用模板方法模式创建处理器 class OrderProcessor: """订单处理器 - 使用模板方法和策略模式""" def __init__(self, order_type: str): self.strategy = OrderProcessingStrategyFactory.get_strategy(order_type) def process_order(self, order: Order) -> dict: """ 模板方法：定义订单处理的固定流程 """ # 1. 验证地址 if not self.strategy.validate_address(order.address): raise ValueError("Address validation failed") # 2. 计算运费 shipping_cost = self.strategy.calculate_shipping_cost(order) # 3. 处理支付 payment_result = self.strategy.process_payment(order) # 4. 海关处理（如果需要） customs_result = None if self.strategy.needs_customs_processing(): customs_result = self.strategy.process_customs(order) # 5. 发货 shipping_result = self.strategy.ship_order(order) # 6. 返回结果 result = { "shipping_cost": shipping_cost, "payment": payment_result, "shipping": shipping_result } if customs_result: result["customs"] = customs_result return result

7.5 重构后的代码优势

  1. 消除重复代码：每个策略类只实现自己的逻辑
  2. 符合开闭原则：添加新订单类型只需新增策略类
  3. 职责清晰：每个类都有单一职责
  4. 易于测试：每个策略可以独立测试
  5. 灵活扩展：通过钩子方法支持可选步骤
  6. 类型安全：使用数据类明确数据结构

7.6 使用示例

# 使用示例 if __name__ == "__main__": # 创建国内订单 domestic_order = Order( order_id="D001", order_type="domestic", address=Address("123 Main St", "New York", "USA", "10001"), items=[OrderItem("Laptop", 1, 2.5), OrderItem("Mouse", 1, 0.2)], payment=PaymentInfo("credit_card", 1200.00) ) domestic_processor = OrderProcessor("domestic") result = domestic_processor.process_order(domestic_order) print("Domestic Order Result:", result) print() # 创建国际订单 international_order = Order( order_id="I001", order_type="international", address=Address("456 Oak Ave", "Toronto", "Canada", "M5V 2T6"), items=[OrderItem("Tablet", 2, 1.0)], payment=PaymentInfo("wire_transfer", 800.00) ) international_processor = OrderProcessor("international") result = international_processor.process_order(international_order) print("International Order Result:", result) print() # 创建快递订单 express_order = Order( order_id="E001", order_type="express", address=Address("789 Pine Rd", "Los Angeles", "USA", "90210"), items=[OrderItem("Phone", 1, 0.5)], payment=PaymentInfo("credit_card", 600.00) ) express_processor = OrderProcessor("express") result = express_processor.process_order(express_order) print("Express Order Result:", result)

第八部分：重构引入设计模式的最佳实践

8.1 重构前的准备工作

  1. 确保测试覆盖

    • 在重构前编写足够的单元测试
    • 确保测试能够验证重构前后的行为一致性
    • 使用测试驱动开发（TDD）方法

  2. 识别坏味道

    • 使用静态代码分析工具
    • 进行代码审查
    • 关注常见的坏味道模式

  3. 选择合适的设计模式

    • 根据问题的本质选择模式
    • 避免过度设计
    • 考虑团队熟悉度和项目需求

8.2 重构过程中的注意事项

  1. 小步前进

    • 每次只做一个小的修改
    • 每步重构后运行测试
    • 保持代码可运行状态

  2. 保持行为不变

    • 重构只改变内部结构
    • 外部接口保持不变
    • 使用测试验证行为

  3. 及时提交

    • 每个重构步骤完成后提交版本控制
    • 写清晰的提交信息
    • 便于回滚

  4. 文档化

    • 记录重构的理由和过程
    • 更新设计文档
    • 注释复杂的模式实现

8.3 常见重构到模式的路径

坏味道可能的设计模式重构步骤
switch/if-else分支策略模式、状态模式1. 提取接口 2. 创建具体策略 3. 替换条件为多态
重复代码模板方法模式1. 提取公共基类 2. 移动公共代码 3. 定义抽象方法
过长参数列表参数对象模式1. 创建参数类 2. 替换参数 3. 简化方法签名
过大的类组合模式、职责链模式1. 提取类 2. 重新分配职责 3. 使用组合
对象创建复杂工厂模式、建造者模式1. 提取创建逻辑 2. 创建工厂类 3. 简化构造函数
需要通知机制观察者模式1. 定义观察者接口 2. 实现通知机制 3. 注册观察者

8.4 避免的陷阱

  1. 过度设计

    • 不要为不存在的需求设计
    • 简单问题不需要复杂模式
    • YAGNI原则（You Aren’t Gonna Need It）

  2. 模式误用

    • 理解模式的适用场景
    • 不要强行套用模式
    • 考虑替代方案

  3. 重构不彻底

    • 不要半途而废
    • 确保完全解决问题
    • 清理所有相关代码

  4. 忽略测试

    • 没有测试的重构是危险的
    • 重构前先写测试
    • 重构后验证测试通过

第九部分：工具和资源

9.1 重构工具

  1. IDE内置工具

    • IntelliJ IDEA: Extract Method, Inline, Move等
    • Visual Studio: 重构菜单
    • PyCharm: Python重构支持

  2. 静态分析工具

    • SonarQube: 检测代码坏味道
    • Pylint: Python代码质量检查
    • ESLint: JavaScript代码检查

  3. 测试框架

    • JUnit, pytest, Jest等
    • 确保重构安全

9.2 学习资源

  1. 经典书籍

    • 《重构：改善既有代码的设计》 - Martin Fowler
    • 《设计模式：可复用面向对象软件的基础》 - GoF
    • 《代码整洁之道》 - Robert C. Martin

  2. 在线资源

    • Refactoring Guru: https://refactoring.guru/
    • Martin Fowler’s Bliki: https://martinfowler.com/
    • SourceMaking: https://sourcemaking.com/

  3. 实践建议

    • 在个人项目中练习
    • 参与开源项目
    • 代码审查中应用

第十部分：总结

设计模式与重构是相辅相成的两个重要概念。通过本文的详细分析和实战案例，我们可以得出以下结论：

  1. 设计模式提供目标，重构提供路径：设计模式告诉我们什么是好的设计，而重构帮助我们安全地达到那个目标。

  2. 识别坏味道是第一步：只有准确识别代码中的问题，才能选择合适的设计模式和重构策略。

  3. 小步重构是关键：通过一系列小的、安全的重构步骤，可以逐步引入设计模式，降低风险。

  4. 测试是安全重构的保障：没有可靠的测试，重构就像走钢丝一样危险。

  5. 实践出真知：只有通过不断的实践，才能熟练掌握重构和设计模式的技巧。

  6. 避免过度设计：简单问题简单解决，不要为了使用模式而使用模式。

通过掌握设计模式与重构的关联，开发者能够：

  • 更快地识别和解决代码质量问题
  • 创建更灵活、更易维护的系统
  • 提高代码的可读性和可测试性
  • 降低技术债务
  • 提升团队开发效率

记住，重构和设计模式不是一次性任务，而是持续改进的过程。将它们融入日常开发习惯中，才能真正发挥其价值。