第3章：识别代码中的设计问题与重构策略

第三章：识别代码中的设计问题与重构策略

在软件开发的长期演进过程中，代码库会逐渐积累各种设计问题，这些问题通常被称为"代码坏味道"。识别这些坏味道是重构的第一步，也是保持代码健康的关键。本章将详细分析22种常见的代码坏味道，为每种坏味道提供具体的商业项目实例，并展示如何在C++、C#和Java三种语言中识别和解决这些问题。

3.1 重复代码的识别与消除

重复代码是软件开发中最常见的问题之一。当相同的代码结构出现在多个地方时，任何修改都需要在多个位置进行，这不仅增加了工作量，也容易引入不一致性。

商业场景：电子商务系统的折扣计算

假设我们正在开发一个电子商务系统，其中折扣计算逻辑在多个地方重复出现。

C++ 示例：重复的折扣逻辑

#include <iostream>
#include <string>
#include <vector>

class ShoppingCart
{
private:
    std::vector<std::pair<std::string, double>> items;
    
public:
    void addItem(const std::string& productName, double price)
    {
        items.push_back(std::make_pair(productName, price));
    }
    
    // 重复的折扣计算逻辑 - 版本1
    double calculateVIPDiscount()
    {
        double total = 0.0;
        for (const auto& item : items)
        {
            total += item.second;
        }
        
        // VIP折扣逻辑
        double discount = 0.0;
        if (total > 1000.0)
        {
            discount = total * 0.2; // 20%折扣
        }
        else if (total > 500.0)
        {
            discount = total * 0.1; // 10%折扣
        }
        else
        {
            discount = total * 0.05; // 5%折扣
        }
        
        return total - discount;
    }
    
    // 重复的折扣计算逻辑 - 版本2
    double calculateSeasonalDiscount(const std::string& season)
    {
        double total = 0.0;
        for (const auto& item : items)
        {
            total += item.second;
        }
        
        // 季节性折扣逻辑（与VIP折扣逻辑相似）
        double discount = 0.0;
        if (total > 1000.0)
        {
            if (season == "Christmas")
            {
                discount = total * 0.25; // 25%折扣
            }
            else
            {
                discount = total * 0.2; // 20%折扣
            }
        }
        else if (total > 500.0)
        {
            discount = total * 0.1; // 10%折扣
        }
        else
        {
            discount = total * 0.05; // 5%折扣
        }
        
        return total - discount;
    }
};

// 重构后：提取公共逻辑
class DiscountCalculator
{
public:
    static double calculateBaseDiscount(double totalAmount)
    {
        if (totalAmount > 1000.0)
        {
            return 0.2; // 20%基础折扣率
        }
        else if (totalAmount > 500.0)
        {
            return 0.1; // 10%基础折扣率
        }
        else
        {
            return 0.05; // 5%基础折扣率
        }
    }
    
    static double calculateVIPDiscount(double totalAmount)
    {
        double baseRate = calculateBaseDiscount(totalAmount);
        return totalAmount * baseRate;
    }
    
    static double calculateSeasonalDiscount(double totalAmount, const std::string& season)
    {
        double baseRate = calculateBaseDiscount(totalAmount);
        
        // 季节性调整
        if (season == "Christmas" && totalAmount > 1000.0)
        {
            baseRate += 0.05; // 额外5%折扣
        }
        
        return totalAmount * baseRate;
    }
};

class RefactoredShoppingCart
{
private:
    std::vector<std::pair<std::string, double>> items;
    
    double calculateTotal()
    {
        double total = 0.0;
        for (const auto& item : items)
        {
            total += item.second;
        }
        return total;
    }
    
public:
    void addItem(const std::string& productName, double price)
    {
        items.push_back(std::make_pair(productName, price));
    }
    
    double calculateVIPDiscount()
    {
        double total = calculateTotal();
        double discount = DiscountCalculator::calculateVIPDiscount(total);
        return total - discount;
    }
    
    double calculateSeasonalDiscount(const std::string& season)
    {
        double total = calculateTotal();
        double discount = DiscountCalculator::calculateSeasonalDiscount(total, season);
        return total - discount;
    }
};

int main()
{
    // 使用重构前的代码
    ShoppingCart cart;
    cart.addItem("Laptop", 999.99);
    cart.addItem("Mouse", 49.99);
    
    std::cout << "VIP Discount Price: $" << cart.calculateVIPDiscount() << std::endl;
    std::cout << "Christmas Discount Price: $" << cart.calculateSeasonalDiscount("Christmas") << std::endl;
    
    // 使用重构后的代码
    RefactoredShoppingCart refactoredCart;
    refactoredCart.addItem("Laptop", 999.99);
    refactoredCart.addItem("Mouse", 49.99);
    
    std::cout << "\nRefactored VIP Discount Price: $" << refactoredCart.calculateVIPDiscount() << std::endl;
    std::cout << "Refactored Christmas Discount Price: $" << refactoredCart.calculateSeasonalDiscount("Christmas") << std::endl;
    
    return 0;
}

C# 示例：重复的验证逻辑

using System;
using System.Collections.Generic;

namespace ECommerceSystem
{
    // 重复代码示例：多个地方有相似的验证逻辑
    public class UserRegistrationService
    {
        public bool RegisterUser(string username, string email, string password)
        {
            // 用户名验证逻辑（在多个地方重复）
            if (string.IsNullOrEmpty(username))
            {
                throw new ArgumentException("Username cannot be empty");
            }
            if (username.Length < 3)
            {
                throw new ArgumentException("Username must be at least 3 characters");
            }
            if (username.Length > 50)
            {
                throw new ArgumentException("Username cannot exceed 50 characters");
            }
            
            // 邮箱验证逻辑（在多个地方重复）
            if (string.IsNullOrEmpty(email))
            {
                throw new ArgumentException("Email cannot be empty");
            }
            if (!email.Contains("@"))
            {
                throw new ArgumentException("Email must contain @ symbol");
            }
            if (email.Length > 100)
            {
                throw new ArgumentException("Email cannot exceed 100 characters");
            }
            
            // 密码验证逻辑（在多个地方重复）
            if (string.IsNullOrEmpty(password))
            {
                throw new ArgumentException("Password cannot be empty");
            }
            if (password.Length < 8)
            {
                throw new ArgumentException("Password must be at least 8 characters");
            }
            
            // 注册逻辑...
            return true;
        }
        
        public bool UpdateUserProfile(string userId, string newUsername, string newEmail)
        {
            // 重复的用户名验证逻辑
            if (string.IsNullOrEmpty(newUsername))
            {
                throw new ArgumentException("Username cannot be empty");
            }
            if (newUsername.Length < 3)
            {
                throw new ArgumentException("Username must be at least 3 characters");
            }
            if (newUsername.Length > 50)
            {
                throw new ArgumentException("Username cannot exceed 50 characters");
            }
            
            // 重复的邮箱验证逻辑
            if (string.IsNullOrEmpty(newEmail))
            {
                throw new ArgumentException("Email cannot be empty");
            }
            if (!newEmail.Contains("@"))
            {
                throw new ArgumentException("Email must contain @ symbol");
            }
            if (newEmail.Length > 100)
            {
                throw new ArgumentException("Email cannot exceed 100 characters");
            }
            
            // 更新逻辑...
            return true;
        }
    }
    
    // 重构后：提取验证逻辑到专用类
    public static class ValidationHelper
    {
        public static void ValidateUsername(string username)
        {
            if (string.IsNullOrEmpty(username))
            {
                throw new ArgumentException("Username cannot be empty");
            }
            if (username.Length < 3)
            {
                throw new ArgumentException("Username must be at least 3 characters");
            }
            if (username.Length > 50)
            {
                throw new ArgumentException("Username cannot exceed 50 characters");
            }
        }
        
        public static void ValidateEmail(string email)
        {
            if (string.IsNullOrEmpty(email))
            {
                throw new ArgumentException("Email cannot be empty");
            }
            if (!email.Contains("@"))
            {
                throw new ArgumentException("Email must contain @ symbol");
            }
            if (email.Length > 100)
            {
                throw new ArgumentException("Email cannot exceed 100 characters");
            }
        }
        
        public static void ValidatePassword(string password)
        {
            if (string.IsNullOrEmpty(password))
            {
                throw new ArgumentException("Password cannot be empty");
            }
            if (password.Length < 8)
            {
                throw new ArgumentException("Password must be at least 8 characters");
            }
        }
    }
    
    public class RefactoredUserRegistrationService
    {
        public bool RegisterUser(string username, string email, string password)
        {
            ValidationHelper.ValidateUsername(username);
            ValidationHelper.ValidateEmail(email);
            ValidationHelper.ValidatePassword(password);
            
            // 注册逻辑...
            return true;
        }
        
        public bool UpdateUserProfile(string userId, string newUsername, string newEmail)
        {
            ValidationHelper.ValidateUsername(newUsername);
            ValidationHelper.ValidateEmail(newEmail);
            
            // 更新逻辑...
            return true;
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            try
            {
                UserRegistrationService service = new UserRegistrationService();
                service.RegisterUser("john123", "john@example.com", "password123");
                Console.WriteLine("User registered successfully");
                
                RefactoredUserRegistrationService refactoredService = new RefactoredUserRegistrationService();
                refactoredService.RegisterUser("jane456", "jane@example.com", "password456");
                Console.WriteLine("User registered successfully (refactored)");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
            }
        }
    }
}

3.2 过长函数的识别与重构

过长函数通常包含太多职责，难以理解、测试和维护。一个函数应该只做一件事情，并且做好它。

商业场景：订单处理系统

Java 示例：复杂的订单处理函数

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

// 过长函数示例
class OrderProcessor {
    
    public void processOrder(Order order) {
        // 验证订单
        if (order == null) {
            System.out.println("Order is null");
            return;
        }
        
        if (order.getItems() == null || order.getItems().isEmpty()) {
            System.out.println("Order has no items");
            return;
        }
        
        // 验证库存
        for (OrderItem item : order.getItems()) {
            Product product = item.getProduct();
            if (product.getStockQuantity() < item.getQuantity()) {
                System.out.println("Insufficient stock for product: " + product.getName());
                return;
            }
        }
        
        // 计算价格
        double subtotal = 0;
        for (OrderItem item : order.getItems()) {
            subtotal += item.getProduct().getPrice() * item.getQuantity();
        }
        
        // 计算税金
        double taxRate = 0.08; // 8%税率
        double tax = subtotal * taxRate;
        
        // 计算运费
        double shippingCost = calculateShippingCost(order);
        
        // 应用折扣
        double discount = 0;
        if (order.getCustomer().isPremiumMember()) {
            discount = subtotal * 0.1; // 10%折扣
        }
        
        // 计算总额
        double total = subtotal + tax + shippingCost - discount;
        
        // 更新库存
        for (OrderItem item : order.getItems()) {
            Product product = item.getProduct();
            product.setStockQuantity(product.getStockQuantity() - item.getQuantity());
        }
        
        // 处理支付
        boolean paymentSuccess = processPayment(order.getCustomer(), total);
        if (!paymentSuccess) {
            System.out.println("Payment failed");
            return;
        }
        
        // 生成发票
        generateInvoice(order, subtotal, tax, shippingCost, discount, total);
        
        // 发送确认邮件
        sendConfirmationEmail(order.getCustomer(), order);
        
        // 更新订单状态
        order.setStatus("Completed");
        order.setProcessedDate(new Date());
        
        // 记录订单到数据库
        saveOrderToDatabase(order);
        
        System.out.println("Order processed successfully");
    }
    
    private double calculateShippingCost(Order order) {
        // 简化实现
        return 10.0;
    }
    
    private boolean processPayment(Customer customer, double amount) {
        // 简化实现
        return true;
    }
    
    private void generateInvoice(Order order, double subtotal, double tax, 
                                 double shipping, double discount, double total) {
        System.out.println("Generating invoice for order: " + order.getId());
    }
    
    private void sendConfirmationEmail(Customer customer, Order order) {
        System.out.println("Sending confirmation email to: " + customer.getEmail());
    }
    
    private void saveOrderToDatabase(Order order) {
        System.out.println("Saving order to database: " + order.getId());
    }
}

// 重构后：将长函数分解为多个小函数
class RefactoredOrderProcessor {
    
    private final InventoryManager inventoryManager;
    private final PaymentProcessor paymentProcessor;
    private final NotificationService notificationService;
    private final OrderRepository orderRepository;
    
    public RefactoredOrderProcessor() {
        this.inventoryManager = new InventoryManager();
        this.paymentProcessor = new PaymentProcessor();
        this.notificationService = new NotificationService();
        this.orderRepository = new OrderRepository();
    }
    
    public void processOrder(Order order) {
        if (!validateOrder(order)) {
            return;
        }
        
        if (!inventoryManager.checkStockAvailability(order)) {
            return;
        }
        
        OrderCalculationResult calculation = calculateOrderAmounts(order);
        
        if (!paymentProcessor.processPayment(order.getCustomer(), calculation.getTotal())) {
            return;
        }
        
        inventoryManager.updateStock(order);
        
        generateInvoice(order, calculation);
        
        notificationService.sendOrderConfirmation(order.getCustomer(), order);
        
        completeOrder(order);
        
        orderRepository.save(order);
        
        System.out.println("Order processed successfully");
    }
    
    private boolean validateOrder(Order order) {
        if (order == null) {
            System.out.println("Order is null");
            return false;
        }
        
        if (order.getItems() == null || order.getItems().isEmpty()) {
            System.out.println("Order has no items");
            return false;
        }
        
        return true;
    }
    
    private OrderCalculationResult calculateOrderAmounts(Order order) {
        double subtotal = calculateSubtotal(order);
        double tax = calculateTax(subtotal);
        double shippingCost = calculateShippingCost(order);
        double discount = calculateDiscount(order, subtotal);
        double total = subtotal + tax + shippingCost - discount;
        
        return new OrderCalculationResult(subtotal, tax, shippingCost, discount, total);
    }
    
    private double calculateSubtotal(Order order) {
        double subtotal = 0;
        for (OrderItem item : order.getItems()) {
            subtotal += item.getProduct().getPrice() * item.getQuantity();
        }
        return subtotal;
    }
    
    private double calculateTax(double subtotal) {
        double taxRate = 0.08;
        return subtotal * taxRate;
    }
    
    private double calculateShippingCost(Order order) {
        // 简化实现
        return 10.0;
    }
    
    private double calculateDiscount(Order order, double subtotal) {
        if (order.getCustomer().isPremiumMember()) {
            return subtotal * 0.1;
        }
        return 0;
    }
    
    private void generateInvoice(Order order, OrderCalculationResult calculation) {
        System.out.println("Generating invoice for order: " + order.getId());
        System.out.println("Subtotal: $" + calculation.getSubtotal());
        System.out.println("Tax: $" + calculation.getTax());
        System.out.println("Shipping: $" + calculation.getShippingCost());
        System.out.println("Discount: $" + calculation.getDiscount());
        System.out.println("Total: $" + calculation.getTotal());
    }
    
    private void completeOrder(Order order) {
        order.setStatus("Completed");
        order.setProcessedDate(new Date());
    }
}

// 辅助类
class OrderCalculationResult {
    private double subtotal;
    private double tax;
    private double shippingCost;
    private double discount;
    private double total;
    
    public OrderCalculationResult(double subtotal, double tax, double shippingCost, 
                                  double discount, double total) {
        this.subtotal = subtotal;
        this.tax = tax;
        this.shippingCost = shippingCost;
        this.discount = discount;
        this.total = total;
    }
    
    public double getSubtotal() { return subtotal; }
    public double getTax() { return tax; }
    public double getShippingCost() { return shippingCost; }
    public double getDiscount() { return discount; }
    public double getTotal() { return total; }
}

// 其他服务类（简化）
class InventoryManager {
    public boolean checkStockAvailability(Order order) {
        for (OrderItem item : order.getItems()) {
            Product product = item.getProduct();
            if (product.getStockQuantity() < item.getQuantity()) {
                System.out.println("Insufficient stock for product: " + product.getName());
                return false;
            }
        }
        return true;
    }
    
    public void updateStock(Order order) {
        for (OrderItem item : order.getItems()) {
            Product product = item.getProduct();
            product.setStockQuantity(product.getStockQuantity() - item.getQuantity());
        }
    }
}

class PaymentProcessor {
    public boolean processPayment(Customer customer, double amount) {
        // 简化实现
        return true;
    }
}

class NotificationService {
    public void sendOrderConfirmation(Customer customer, Order order) {
        System.out.println("Sending confirmation email to: " + customer.getEmail());
    }
}

class OrderRepository {
    public void save(Order order) {
        System.out.println("Saving order to database: " + order.getId());
    }
}

// 数据模型类
class Order {
    private String id;
    private Customer customer;
    private List<OrderItem> items;
    private String status;
    private Date processedDate;
    
    public Order(String id, Customer customer) {
        this.id = id;
        this.customer = customer;
        this.items = new ArrayList<>();
    }
    
    public void addItem(Product product, int quantity) {
        items.add(new OrderItem(product, quantity));
    }
    
    // Getter和Setter方法
    public String getId() { return id; }
    public Customer getCustomer() { return customer; }
    public List<OrderItem> getItems() { return items; }
    public String getStatus() { return status; }
    public void setStatus(String status) { this.status = status; }
    public Date getProcessedDate() { return processedDate; }
    public void setProcessedDate(Date processedDate) { this.processedDate = processedDate; }
}

class OrderItem {
    private Product product;
    private int quantity;
    
    public OrderItem(Product product, int quantity) {
        this.product = product;
        this.quantity = quantity;
    }
    
    public Product getProduct() { return product; }
    public int getQuantity() { return quantity; }
}

class Product {
    private String name;
    private double price;
    private int stockQuantity;
    
    public Product(String name, double price, int stockQuantity) {
        this.name = name;
        this.price = price;
        this.stockQuantity = stockQuantity;
    }
    
    public String getName() { return name; }
    public double getPrice() { return price; }
    public int getStockQuantity() { return stockQuantity; }
    public void setStockQuantity(int stockQuantity) { this.stockQuantity = stockQuantity; }
}

class Customer {
    private String email;
    private boolean premiumMember;
    
    public Customer(String email, boolean premiumMember) {
        this.email = email;
        this.premiumMember = premiumMember;
    }
    
    public String getEmail() { return email; }
    public boolean isPremiumMember() { return premiumMember; }
}

public class Main {
    public static void main(String[] args) {
        // 创建测试数据
        Customer customer = new Customer("john@example.com", true);
        Order order = new Order("ORD001", customer);
        
        Product laptop = new Product("Laptop", 999.99, 10);
        Product mouse = new Product("Mouse", 49.99, 50);
        
        order.addItem(laptop, 1);
        order.addItem(mouse, 2);
        
        // 使用重构前的处理器
        OrderProcessor processor = new OrderProcessor();
        System.out.println("Processing order with original processor:");
        processor.processOrder(order);
        
        System.out.println("\n---\n");
        
        // 使用重构后的处理器
        RefactoredOrderProcessor refactoredProcessor = new RefactoredOrderProcessor();
        System.out.println("Processing order with refactored processor:");
        refactoredProcessor.processOrder(order);
    }
}

3.3 过大类的识别与重构

当一个类试图做太多事情时，它会变得难以理解和维护。过大的类通常有太多的字段和方法，违反了单一职责原则。

商业场景：客户关系管理系统

C++ 示例：包含太多职责的Customer类

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <memory>

// 过大的类示例：Customer类承担了太多职责
class Customer
{
private:
    // 个人信息
    std::string id;
    std::string name;
    std::string email;
    std::string phone;
    std::string address;
    std::string city;
    std::string state;
    std::string zipCode;
    std::string country;
    
    // 账户信息
    std::string accountNumber;
    double accountBalance;
    std::string accountType;
    std::string currency;
    
    // 订单历史
    std::vector<std::string> orderIds;
    std::map<std::string, double> orderAmounts;
    
    // 支付信息
    std::vector<std::string> paymentMethods;
    std::map<std::string, std::string> paymentDetails;
    
    // 服务历史
    std::vector<std::string> serviceTickets;
    std::map<std::string, std::string> serviceHistory;
    
    // 偏好设置
    std::map<std::string, std::string> preferences;
    std::vector<std::string> favoriteProducts;
    
public:
    Customer(const std::string& customerId, const std::string& customerName)
        : id(customerId), name(customerName), accountBalance(0.0) {}
    
    // 个人信息相关方法
    void updatePersonalInfo(const std::string& newEmail, const std::string& newPhone,
                           const std::string& newAddress, const std::string& newCity,
                           const std::string& newState, const std::string& newZip,
                           const std::string& newCountry)
    {
        email = newEmail;
        phone = newPhone;
        address = newAddress;
        city = newCity;
        state = newState;
        zipCode = newZip;
        country = newCountry;
    }
    
    std::string getFullAddress() const
    {
        return address + ", " + city + ", " + state + " " + zipCode + ", " + country;
    }
    
    // 账户相关方法
    void createAccount(const std::string& accNumber, const std::string& accType,
                      const std::string& curr)
    {
        accountNumber = accNumber;
        accountType = accType;
        currency = curr;
    }
    
    void deposit(double amount)
    {
        accountBalance += amount;
    }
    
    bool withdraw(double amount)
    {
        if (amount <= accountBalance)
        {
            accountBalance -= amount;
            return true;
        }
        return false;
    }
    
    double getAccountBalance() const
    {
        return accountBalance;
    }
    
    // 订单相关方法
    void addOrder(const std::string& orderId, double amount)
    {
        orderIds.push_back(orderId);
        orderAmounts[orderId] = amount;
    }
    
    double getTotalSpent() const
    {
        double total = 0.0;
        for (const auto& pair : orderAmounts)
        {
            total += pair.second;
        }
        return total;
    }
    
    // 支付相关方法
    void addPaymentMethod(const std::string& method, const std::string& details)
    {
        paymentMethods.push_back(method);
        paymentDetails[method] = details;
    }
    
    // 服务相关方法
    void createServiceTicket(const std::string& ticketId, const std::string& description)
    {
        serviceTickets.push_back(ticketId);
        serviceHistory[ticketId] = description;
    }
    
    // 偏好相关方法
    void setPreference(const std::string& key, const std::string& value)
    {
        preferences[key] = value;
    }
    
    void addFavoriteProduct(const std::string& productId)
    {
        favoriteProducts.push_back(productId);
    }
    
    // 太多其他方法...
    // 这个类已经变得太大，承担了太多职责
};

// 重构后：将大类分解为多个小类
class PersonalInfo
{
private:
    std::string id;
    std::string name;
    std::string email;
    std::string phone;
    std::string address;
    std::string city;
    std::string state;
    std::string zipCode;
    std::string country;
    
public:
    PersonalInfo(const std::string& customerId, const std::string& customerName)
        : id(customerId), name(customerName) {}
    
    void updateInfo(const std::string& newEmail, const std::string& newPhone,
                   const std::string& newAddress, const std::string& newCity,
                   const std::string& newState, const std::string& newZip,
                   const std::string& newCountry)
    {
        email = newEmail;
        phone = newPhone;
        address = newAddress;
        city = newCity;
        state = newState;
        zipCode = newZip;
        country = newCountry;
    }
    
    std::string getFullAddress() const
    {
        return address + ", " + city + ", " + state + " " + zipCode + ", " + country;
    }
    
    std::string getId() const { return id; }
    std::string getName() const { return name; }
    std::string getEmail() const { return email; }
    std::string getPhone() const { return phone; }
};

class CustomerAccount
{
private:
    std::string accountNumber;
    double balance;
    std::string accountType;
    std::string currency;
    
public:
    CustomerAccount(const std::string& accNumber, const std::string& accType,
                   const std::string& curr)
        : accountNumber(accNumber), balance(0.0), accountType(accType), currency(curr) {}
    
    void deposit(double amount)
    {
        balance += amount;
    }
    
    bool withdraw(double amount)
    {
        if (amount <= balance)
        {
            balance -= amount;
            return true;
        }
        return false;
    }
    
    double getBalance() const
    {
        return balance;
    }
    
    std::string getAccountNumber() const { return accountNumber; }
    std::string getAccountType() const { return accountType; }
};

class OrderHistory
{
private:
    std::vector<std::string> orderIds;
    std::map<std::string, double> orderAmounts;
    
public:
    void addOrder(const std::string& orderId, double amount)
    {
        orderIds.push_back(orderId);
        orderAmounts[orderId] = amount;
    }
    
    double getTotalSpent() const
    {
        double total = 0.0;
        for (const auto& pair : orderAmounts)
        {
            total += pair.second;
        }
        return total;
    }
    
    int getOrderCount() const
    {
        return orderIds.size();
    }
    
    const std::vector<std::string>& getOrderIds() const
    {
        return orderIds;
    }
};

class PaymentManager
{
private:
    std::vector<std::string> paymentMethods;
    std::map<std::string, std::string> paymentDetails;
    
public:
    void addPaymentMethod(const std::string& method, const std::string& details)
    {
        paymentMethods.push_back(method);
        paymentDetails[method] = details;
    }
    
    bool hasPaymentMethod(const std::string& method) const
    {
        for (const auto& m : paymentMethods)
        {
            if (m == method)
            {
                return true;
            }
        }
        return false;
    }
    
    std::string getPaymentDetails(const std::string& method) const
    {
        auto it = paymentDetails.find(method);
        if (it != paymentDetails.end())
        {
            return it->second;
        }
        return "";
    }
};

class CustomerPreferences
{
private:
    std::map<std::string, std::string> preferences;
    std::vector<std::string> favoriteProducts;
    
public:
    void setPreference(const std::string& key, const std::string& value)
    {
        preferences[key] = value;
    }
    
    std::string getPreference(const std::string& key) const
    {
        auto it = preferences.find(key);
        if (it != preferences.end())
        {
            return it->second;
        }
        return "";
    }
    
    void addFavoriteProduct(const std::string& productId)
    {
        favoriteProducts.push_back(productId);
    }
    
    const std::vector<std::string>& getFavoriteProducts() const
    {
        return favoriteProducts;
    }
};

// 重构后的Customer类
class RefactoredCustomer
{
private:
    std::shared_ptr<PersonalInfo> personalInfo;
    std::shared_ptr<CustomerAccount> account;
    std::shared_ptr<OrderHistory> orderHistory;
    std::shared_ptr<PaymentManager> paymentManager;
    std::shared_ptr<CustomerPreferences> preferences;
    
public:
    RefactoredCustomer(const std::string& customerId, const std::string& customerName)
    {
        personalInfo = std::make_shared<PersonalInfo>(customerId, customerName);
        orderHistory = std::make_shared<OrderHistory>();
        paymentManager = std::make_shared<PaymentManager>();
        preferences = std::make_shared<CustomerPreferences>();
    }
    
    // 个人信息访问
    std::shared_ptr<PersonalInfo> getPersonalInfo()
    {
        return personalInfo;
    }
    
    // 账户管理
    void createAccount(const std::string& accNumber, const std::string& accType,
                      const std::string& currency)
    {
        account = std::make_shared<CustomerAccount>(accNumber, accType, currency);
    }
    
    std::shared_ptr<CustomerAccount> getAccount()
    {
        return account;
    }
    
    // 订单历史访问
    std::shared_ptr<OrderHistory> getOrderHistory()
    {
        return orderHistory;
    }
    
    // 支付管理访问
    std::shared_ptr<PaymentManager> getPaymentManager()
    {
        return paymentManager;
    }
    
    // 偏好设置访问
    std::shared_ptr<CustomerPreferences> getPreferences()
    {
        return preferences;
    }
    
    // 综合方法
    std::string getCustomerSummary() const
    {
        std::string summary = "Customer: " + personalInfo->getName() + "\n";
        summary += "Email: " + personalInfo->getEmail() + "\n";
        
        if (account)
        {
            summary += "Account Balance: $" + std::to_string(account->getBalance()) + "\n";
        }
        
        summary += "Total Orders: " + std::to_string(orderHistory->getOrderCount()) + "\n";
        summary += "Total Spent: $" + std::to_string(orderHistory->getTotalSpent()) + "\n";
        
        return summary;
    }
};

int main()
{
    // 使用重构前的过大类
    Customer oldCustomer("CUST001", "John Doe");
    oldCustomer.updatePersonalInfo("john@example.com", "123-456-7890", 
                                  "123 Main St", "Anytown", "CA", "12345", "USA");
    oldCustomer.createAccount("ACC001", "Checking", "USD");
    oldCustomer.deposit(1000.0);
    oldCustomer.addOrder("ORD001", 299.99);
    oldCustomer.addOrder("ORD002", 149.99);
    
    std::cout << "Old Customer Total Spent: $" << oldCustomer.getTotalSpent() << std::endl;
    std::cout << "Old Customer Balance: $" << oldCustomer.getAccountBalance() << std::endl;
    
    // 使用重构后的类
    RefactoredCustomer newCustomer("CUST002", "Jane Smith");
    newCustomer.getPersonalInfo()->updateInfo("jane@example.com", "987-654-3210",
                                             "456 Oak St", "Othertown", "NY", "54321", "USA");
    newCustomer.createAccount("ACC002", "Savings", "USD");
    newCustomer.getAccount()->deposit(2000.0);
    newCustomer.getOrderHistory()->addOrder("ORD003", 499.99);
    newCustomer.getOrderHistory()->addOrder("ORD004", 199.99);
    
    std::cout << "\nNew Customer Summary:\n" << newCustomer.getCustomerSummary() << std::endl;
    
    return 0;
}

3.4 过长参数列的识别与重构

当一个函数需要太多参数时，调用它会变得困难，而且难以理解每个参数的作用。过长参数列通常表示这些参数应该被组织成一个对象。

商业场景：用户注册系统

C# 示例：包含太多参数的注册函数

using System;

namespace UserRegistrationSystem
{
    // 过长参数列示例
    public class UserService
    {
        // 这个函数有太多参数，难以理解和使用
        public bool RegisterUser(
            string username,
            string email,
            string password,
            string firstName,
            string lastName,
            DateTime dateOfBirth,
            string phoneNumber,
            string addressLine1,
            string addressLine2,
            string city,
            string state,
            string zipCode,
            string country,
            bool acceptTerms,
            bool subscribeToNewsletter,
            string referralCode,
            string securityQuestion1,
            string securityAnswer1,
            string securityQuestion2,
            string securityAnswer2)
        {
            // 参数验证
            if (string.IsNullOrEmpty(username))
                throw new ArgumentException("Username is required");
            
            if (string.IsNullOrEmpty(email))
                throw new ArgumentException("Email is required");
            
            if (string.IsNullOrEmpty(password))
                throw new ArgumentException("Password is required");
            
            // 更多验证...
            
            // 用户注册逻辑
            Console.WriteLine($"Registering user: {username}");
            Console.WriteLine($"Email: {email}");
            Console.WriteLine($"Address: {addressLine1}, {city}, {state} {zipCode}");
            
            // 保存到数据库等操作...
            
            return true;
        }
        
        // 更新用户信息的函数也有同样的问题
        public bool UpdateUserProfile(
            string userId,
            string newEmail,
            string newPhoneNumber,
            string newAddressLine1,
            string newAddressLine2,
            string newCity,
            string newState,
            string newZipCode,
            string newCountry,
            bool changePassword,
            string newPassword,
            string newSecurityQuestion1,
            string newSecurityAnswer1)
        {
            // 参数验证和更新逻辑...
            return true;
        }
    }
    
    // 重构后：使用参数对象
    public class UserRegistrationData
    {
        public string Username { get; set; }
        public string Email { get; set; }
        public string Password { get; set; }
        
        // 个人信息
        public string FirstName { get; set; }
        public string LastName { get; set; }
        public DateTime DateOfBirth { get; set; }
        public string PhoneNumber { get; set; }
        
        // 地址信息
        public string AddressLine1 { get; set; }
        public string AddressLine2 { get; set; }
        public string City { get; set; }
        public string State { get; set; }
        public string ZipCode { get; set; }
        public string Country { get; set; }
        
        // 偏好设置
        public bool AcceptTerms { get; set; }
        public bool SubscribeToNewsletter { get; set; }
        public string ReferralCode { get; set; }
        
        // 安全信息
        public string SecurityQuestion1 { get; set; }
        public string SecurityAnswer1 { get; set; }
        public string SecurityQuestion2 { get; set; }
        public string SecurityAnswer2 { get; set; }
        
        public UserRegistrationData()
        {
            DateOfBirth = DateTime.MinValue;
        }
        
        public bool Validate()
        {
            if (string.IsNullOrEmpty(Username))
                throw new ArgumentException("Username is required");
            
            if (string.IsNullOrEmpty(Email))
                throw new ArgumentException("Email is required");
            
            if (string.IsNullOrEmpty(Password))
                throw new ArgumentException("Password is required");
            
            if (!AcceptTerms)
                throw new ArgumentException("Terms must be accepted");
            
            return true;
        }
    }
    
    public class UserProfileUpdateData
    {
        public string UserId { get; set; }
        public string NewEmail { get; set; }
        public string NewPhoneNumber { get; set; }
        
        // 地址更新
        public string NewAddressLine1 { get; set; }
        public string NewAddressLine2 { get; set; }
        public string NewCity { get; set; }
        public string NewState { get; set; }
        public string NewZipCode { get; set; }
        public string NewCountry { get; set; }
        
        // 密码更新
        public bool ChangePassword { get; set; }
        public string NewPassword { get; set; }
        
        // 安全信息更新
        public string NewSecurityQuestion1 { get; set; }
        public string NewSecurityAnswer1 { get; set; }
        
        public bool Validate()
        {
            if (string.IsNullOrEmpty(UserId))
                throw new ArgumentException("User ID is required");
            
            return true;
        }
    }
    
    public class RefactoredUserService
    {
        public bool RegisterUser(UserRegistrationData registrationData)
        {
            // 验证数据
            registrationData.Validate();
            
            // 用户注册逻辑
            Console.WriteLine($"Registering user: {registrationData.Username}");
            Console.WriteLine($"Email: {registrationData.Email}");
            Console.WriteLine($"Address: {registrationData.AddressLine1}, {registrationData.City}, " +
                            $"{registrationData.State} {registrationData.ZipCode}");
            
            // 保存到数据库等操作...
            
            return true;
        }
        
        public bool UpdateUserProfile(UserProfileUpdateData updateData)
        {
            // 验证数据
            updateData.Validate();
            
            // 更新逻辑...
            Console.WriteLine($"Updating profile for user: {updateData.UserId}");
            
            return true;
        }
        
        // 便捷方法：创建用户注册数据
        public UserRegistrationData CreateRegistrationData(string username, string email, 
                                                          string password, string firstName, 
                                                          string lastName)
        {
            return new UserRegistrationData
            {
                Username = username,
                Email = email,
                Password = password,
                FirstName = firstName,
                LastName = lastName,
                AcceptTerms = true
            };
        }
    }
    
    // 建造者模式进一步优化
    public class UserRegistrationDataBuilder
    {
        private UserRegistrationData data;
        
        public UserRegistrationDataBuilder(string username, string email, string password)
        {
            data = new UserRegistrationData
            {
                Username = username,
                Email = email,
                Password = password
            };
        }
        
        public UserRegistrationDataBuilder WithPersonalInfo(string firstName, string lastName, 
                                                           DateTime dateOfBirth, string phoneNumber)
        {
            data.FirstName = firstName;
            data.LastName = lastName;
            data.DateOfBirth = dateOfBirth;
            data.PhoneNumber = phoneNumber;
            return this;
        }
        
        public UserRegistrationDataBuilder WithAddress(string addressLine1, string city, 
                                                      string state, string zipCode, string country)
        {
            data.AddressLine1 = addressLine1;
            data.City = city;
            data.State = state;
            data.ZipCode = zipCode;
            data.Country = country;
            return this;
        }
        
        public UserRegistrationDataBuilder WithPreferences(bool acceptTerms, 
                                                          bool subscribeToNewsletter)
        {
            data.AcceptTerms = acceptTerms;
            data.SubscribeToNewsletter = subscribeToNewsletter;
            return this;
        }
        
        public UserRegistrationDataBuilder WithSecurityInfo(string question1, string answer1, 
                                                           string question2, string answer2)
        {
            data.SecurityQuestion1 = question1;
            data.SecurityAnswer1 = answer1;
            data.SecurityQuestion2 = question2;
            data.SecurityAnswer2 = answer2;
            return this;
        }
        
        public UserRegistrationData Build()
        {
            return data;
        }
    }
    
    class Program
    {
        static void Main(string[] args)
        {
            // 使用重构前的服务（参数过多，难以使用）
            UserService oldService = new UserService();
            
            try
            {
                bool result = oldService.RegisterUser(
                    "johndoe",
                    "john@example.com",
                    "password123",
                    "John",
                    "Doe",
                    new DateTime(1990, 1, 1),
                    "123-456-7890",
                    "123 Main St",
                    "",
                    "Anytown",
                    "CA",
                    "12345",
                    "USA",
                    true,
                    true,
                    "REF123",
                    "What is your pet's name?",
                    "Fluffy",
                    "What is your mother's maiden name?",
                    "Smith");
                
                Console.WriteLine($"Registration result: {result}");
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
            }
            
            Console.WriteLine("\n---\n");
            
            // 使用重构后的服务
            RefactoredUserService newService = new RefactoredUserService();
            
            // 方法1：直接创建参数对象
            UserRegistrationData registrationData = new UserRegistrationData
            {
                Username = "janedoe",
                Email = "jane@example.com",
                Password = "password456",
                FirstName = "Jane",
                LastName = "Doe",
                PhoneNumber = "987-654-3210",
                AddressLine1 = "456 Oak St",
                City = "Othertown",
                State = "NY",
                ZipCode = "54321",
                Country = "USA",
                AcceptTerms = true,
                SubscribeToNewsletter = false
            };
            
            bool newResult = newService.RegisterUser(registrationData);
            Console.WriteLine($"Refactored registration result: {newResult}");
            
            Console.WriteLine("\n---\n");
            
            // 方法2：使用建造者模式
            UserRegistrationDataBuilder builder = new UserRegistrationDataBuilder(
                "bobsmith", "bob@example.com", "password789");
            
            UserRegistrationData builtData = builder
                .WithPersonalInfo("Bob", "Smith", new DateTime(1985, 5, 15), "555-123-4567")
                .WithAddress("789 Pine St", "Sometown", "TX", "67890", "USA")
                .WithPreferences(true, true)
                .Build();
            
            newResult = newService.RegisterUser(builtData);
            Console.WriteLine($"Builder pattern registration result: {newResult}");
        }
    }
}

3.5 发散式变化的识别与重构

发散式变化是指一个类因为不同的原因在不同的方向上发生变化。这意味着这个类有多个职责，当某个职责的需求变化时，就需要修改这个类。

商业场景：报告生成系统

Java 示例：承担多种报告职责的Report类

import java.util.Date;
import java.util.List;
import java.util.ArrayList;

// 发散式变化示例：Report类因为多种原因需要修改
class Report {
    private String title;
    private Date generationDate;
    private List<ReportData> data;
    private ReportFormat format;
    private String author;
    
    public Report(String title, List<ReportData> data, ReportFormat format, String author) {
        this.title = title;
        this.generationDate = new Date();
        this.data = data;
        this.format = format;
        this.author = author;
    }
    
    // 问题：这个类因为多个原因需要修改：
    // 1. 当报告内容变化时（如添加新的数据字段）
    // 2. 当报告格式变化时（如支持新的输出格式）
    // 3. 当报告分发方式变化时（如添加新的分发渠道）
    // 4. 当报告安全要求变化时（如添加加密）
    
    // 生成报告内容
    public String generateContent() {
        StringBuilder content = new StringBuilder();
        content.append("Report: ").append(title).append("\n");
        content.append("Generated on: ").append(generationDate).append("\n");
        content.append("Author: ").append(author).append("\n\n");
        
        for (ReportData item : data) {
            content.append(item.getName()).append(": ").append(item.getValue()).append("\n");
        }
        
        return content.toString();
    }
    
    // 格式化报告（HTML格式）
    public String formatAsHtml() {
        String content = generateContent();
        StringBuilder html = new StringBuilder();
        html.append("<html><head><title>").append(title).append("</title></head><body>");
        html.append("<h1>").append(title).append("</h1>");
        html.append("<p>Generated on: ").append(generationDate).append("</p>");
        html.append("<p>Author: ").append(author).append("</p>");
        html.append("<table border='1'>");
        html.append("<tr><th>Name</th><th>Value</th></tr>");
        
        for (ReportData item : data) {
            html.append("<tr>");
            html.append("<td>").append(item.getName()).append("</td>");
            html.append("<td>").append(item.getValue()).append("</td>");
            html.append("</tr>");
        }
        
        html.append("</table></body></html>");
        return html.toString();
    }
    
    // 格式化报告（CSV格式）
    public String formatAsCsv() {
        StringBuilder csv = new StringBuilder();
        csv.append("Report,").append(title).append("\n");
        csv.append("Generated on,").append(generationDate).append("\n");
        csv.append("Author,").append(author).append("\n\n");
        csv.append("Name,Value\n");
        
        for (ReportData item : data) {
            csv.append(item.getName()).append(",").append(item.getValue()).append("\n");
        }
        
        return csv.toString();
    }
    
    // 保存报告到文件
    public void saveToFile(String filename) {
        String content = "";
        if (format == ReportFormat.HTML) {
            content = formatAsHtml();
        } else if (format == ReportFormat.CSV) {
            content = formatAsCsv();
        } else {
            content = generateContent();
        }
        
        // 保存文件逻辑
        System.out.println("Saving report to file: " + filename);
        System.out.println("Content length: " + content.length() + " characters");
    }
    
    // 发送报告邮件
    public void sendByEmail(String recipient) {
        String subject = "Report: " + title;
        String body = generateContent();
        
        // 发送邮件逻辑
        System.out.println("Sending report to: " + recipient);
        System.out.println("Subject: " + subject);
        System.out.println("Body length: " + body.length() + " characters");
    }
    
    // 加密报告
    public String encryptReport() {
        String content = generateContent();
        // 简单的加密逻辑（示例）
        StringBuilder encrypted = new StringBuilder();
        for (char c : content.toCharArray()) {
            encrypted.append((char)(c + 1)); // 简单的字符偏移加密
        }
        return encrypted.toString();
    }
    
    // 解密报告
    public String decryptReport(String encryptedContent) {
        StringBuilder decrypted = new StringBuilder();
        for (char c : encryptedContent.toCharArray()) {
            decrypted.append((char)(c - 1)); // 解密
        }
        return decrypted.toString();
    }
}

enum ReportFormat {
    PLAIN_TEXT,
    HTML,
    CSV
}

class ReportData {
    private String name;
    private String value;
    
    public ReportData(String name, String value) {
        this.name = name;
        this.value = value;
    }
    
    public String getName() { return name; }
    public String getValue() { return value; }
}

// 重构后：将不同的职责分离到不同的类中
// 1. 报告内容生成器
class ReportContentGenerator {
    private String title;
    private Date generationDate;
    private List<ReportData> data;
    private String author;
    
    public ReportContentGenerator(String title, List<ReportData> data, String author) {
        this.title = title;
        this.generationDate = new Date();
        this.data = data;
        this.author = author;
    }
    
    public String generatePlainText() {
        StringBuilder content = new StringBuilder();
        content.append("Report: ").append(title).append("\n");
        content.append("Generated on: ").append(generationDate).append("\n");
        content.append("Author: ").append(author).append("\n\n");
        
        for (ReportData item : data) {
            content.append(item.getName()).append(": ").append(item.getValue()).append("\n");
        }
        
        return content.toString();
    }
    
    // 可以添加更多内容生成方法，但只负责内容生成
    public String generateWithCustomTemplate(String template) {
        // 使用模板生成内容
        return template.replace("{title}", title)
                      .replace("{date}", generationDate.toString())
                      .replace("{author}", author);
    }
}

// 2. 报告格式化器
interface ReportFormatter {
    String format(String content);
}

class HtmlReportFormatter implements ReportFormatter {
    @Override
    public String format(String content) {
        // 简化实现：实际中会将内容转换为HTML
        return "<html><body><pre>" + content + "</pre></body></html>";
    }
}

class CsvReportFormatter implements ReportFormatter {
    @Override
    public String format(String content) {
        // 简化实现：将内容转换为CSV格式
        String[] lines = content.split("\n");
        StringBuilder csv = new StringBuilder();
        for (String line : lines) {
            // 简单的转换逻辑
            csv.append(line.replace(": ", ",")).append("\n");
        }
        return csv.toString();
    }
}

class PdfReportFormatter implements ReportFormatter {
    @Override
    public String format(String content) {
        // 模拟PDF格式（实际会使用PDF库）
        return "PDF Content:\n" + content;
    }
}

// 3. 报告分发器
interface ReportDistributor {
    void distribute(String content, String destination);
}

class EmailReportDistributor implements ReportDistributor {
    @Override
    public void distribute(String content, String destination) {
        System.out.println("Sending report via email to: " + destination);
        System.out.println("Content length: " + content.length() + " characters");
    }
}

class FileReportDistributor implements ReportDistributor {
    @Override
    public void distribute(String content, String destination) {
        System.out.println("Saving report to file: " + destination);
        System.out.println("Content length: " + content.length() + " characters");
    }
}

class CloudStorageReportDistributor implements ReportDistributor {
    @Override
    public void distribute(String content, String destination) {
        System.out.println("Uploading report to cloud storage: " + destination);
        System.out.println("Content length: " + content.length() + " characters");
    }
}

// 4. 报告加密器
interface ReportEncryptor {
    String encrypt(String content);
    String decrypt(String encryptedContent);
}

class SimpleReportEncryptor implements ReportEncryptor {
    @Override
    public String encrypt(String content) {
        StringBuilder encrypted = new StringBuilder();
        for (char c : content.toCharArray()) {
            encrypted.append((char)(c + 1));
        }
        return encrypted.toString();
    }
    
    @Override
    public String decrypt(String encryptedContent) {
        StringBuilder decrypted = new StringBuilder();
        for (char c : encryptedContent.toCharArray()) {
            decrypted.append((char)(c - 1));
        }
        return decrypted.toString();
    }
}

// 5. 重构后的Report类（协调者）
class RefactoredReport {
    private ReportContentGenerator contentGenerator;
    private ReportFormatter formatter;
    private ReportDistributor distributor;
    private ReportEncryptor encryptor;
    
    public RefactoredReport(ReportContentGenerator contentGenerator) {
        this.contentGenerator = contentGenerator;
    }
    
    public void setFormatter(ReportFormatter formatter) {
        this.formatter = formatter;
    }
    
    public void setDistributor(ReportDistributor distributor) {
        this.distributor = distributor;
    }
    
    public void setEncryptor(ReportEncryptor encryptor) {
        this.encryptor = encryptor;
    }
    
    public String generateReport() {
        String content = contentGenerator.generatePlainText();
        
        if (formatter != null) {
            content = formatter.format(content);
        }
        
        if (encryptor != null) {
            content = encryptor.encrypt(content);
        }
        
        return content;
    }
    
    public void distributeReport(String destination) {
        String report = generateReport();
        
        if (distributor != null) {
            distributor.distribute(report, destination);
        } else {
            System.out.println("No distributor set. Report generated but not distributed.");
            System.out.println("Report content (first 100 chars): " + 
                             report.substring(0, Math.min(100, report.length())));
        }
    }
}

public class ReportSystemExample {
    public static void main(String[] args) {
        // 准备测试数据
        List<ReportData> data = new ArrayList<>();
        data.add(new ReportData("Sales Q1", "$100,000"));
        data.add(new ReportData("Sales Q2", "$120,000"));
        data.add(new ReportData("Sales Q3", "$150,000"));
        data.add(new ReportData("Sales Q4", "$180,000"));
        
        System.out.println("=== 使用重构前的Report类 ===");
        Report oldReport = new Report("Annual Sales Report", data, ReportFormat.HTML, "John Doe");
        oldReport.saveToFile("report.html");
        oldReport.sendByEmail("manager@example.com");
        
        System.out.println("\n=== 使用重构后的Report类 ===");
        
        // 创建内容生成器
        ReportContentGenerator contentGenerator = 
            new ReportContentGenerator("Annual Sales Report", data, "Jane Smith");
        
        // 创建报告对象
        RefactoredReport newReport = new RefactoredReport(contentGenerator);
        
        // 配置报告：HTML格式 + 邮件分发
        newReport.setFormatter(new HtmlReportFormatter());
        newReport.setDistributor(new EmailReportDistributor());
        
        // 生成并分发报告
        newReport.distributeReport("ceo@example.com");
        
        System.out.println("\n--- 配置变更：CSV格式 + 文件保存 ---");
        // 改变配置：CSV格式 + 文件保存
        newReport.setFormatter(new CsvReportFormatter());
        newReport.setDistributor(new FileReportDistributor());
        newReport.setEncryptor(new SimpleReportEncryptor());
        
        // 生成并分发报告
        newReport.distributeReport("sales_report.csv");
        
        System.out.println("\n--- 配置变更：PDF格式 + 云存储 ---");
        // 改变配置：PDF格式 + 云存储
        newReport.setFormatter(new PdfReportFormatter());
        newReport.setDistributor(new CloudStorageReportDistributor());
        newReport.setEncryptor(null); // 不加密
        
        // 生成并分发报告
        newReport.distributeReport("cloud://reports/sales.pdf");
    }
}

3.6 霰弹式修改的识别与重构

霰弹式修改是指当需要对系统进行一个修改时，需要在多个类中进行小修改。这与发散式变化相反，发散式变化是一个类因为多个原因需要修改，而霰弹式修改是一个修改需要影响多个类。

商业场景：价格计算系统

C++ 示例：价格计算逻辑分散在多个类中

#include <iostream>
#include <string>
#include <vector>
#include <memory>

// 霰弹式修改示例：价格计算逻辑分散在多个类中
// 当价格计算规则变化时，需要修改多个类

class Product
{
private:
    std::string name;
    double basePrice;
    
public:
    Product(const std::string& productName, double price)
        : name(productName), basePrice(price) {}
    
    // 价格计算方法1：在Product类中
    double calculatePriceWithTax(double taxRate)
    {
        return basePrice * (1 + taxRate);
    }
    
    std::string getName() const { return name; }
    double getBasePrice() const { return basePrice; }
};

class OrderItem
{
private:
    std::shared_ptr<Product> product;
    int quantity;
    
public:
    OrderItem(std::shared_ptr<Product> prod, int qty)
        : product(prod), quantity(qty) {}
    
    // 价格计算方法2：在OrderItem类中
    double calculateItemTotal(double discountRate)
    {
        double price = product->getBasePrice();
        double discountedPrice = price * (1 - discountRate);
        return discountedPrice * quantity;
    }
    
    std::shared_ptr<Product> getProduct() const { return product; }
    int getQuantity() const { return quantity; }
};

class ShoppingCart
{
private:
    std::vector<std::shared_ptr<OrderItem>> items;
    std::string customerType; // "Regular", "VIP", "Wholesale"
    
public:
    ShoppingCart(const std::string& type) : customerType(type) {}
    
    void addItem(std::shared_ptr<OrderItem> item)
    {
        items.push_back(item);
    }
    
    // 价格计算方法3：在ShoppingCart类中
    double calculateCartTotal()
    {
        double total = 0.0;
        
        for (const auto& item : items)
        {
            double discountRate = 0.0;
            
            // 根据客户类型应用折扣
            if (customerType == "VIP")
            {
                discountRate = 0.15; // VIP客户15%折扣
            }
            else if (customerType == "Wholesale")
            {
                discountRate = 0.25; // 批发客户25%折扣
            }
            else
            {
                discountRate = 0.05; // 普通客户5%折扣
            }
            
            total += item->calculateItemTotal(discountRate);
        }
        
        // 购物车总额折扣（满减）
        if (total > 1000.0)
        {
            total -= 50.0; // 满1000减50
        }
        else if (total > 500.0)
        {
            total -= 20.0; // 满500减20
        }
        
        return total;
    }
};

class Invoice
{
private:
    std::shared_ptr<ShoppingCart> cart;
    double taxRate;
    
public:
    Invoice(std::shared_ptr<ShoppingCart> shoppingCart, double rate)
        : cart(shoppingCart), taxRate(rate) {}
    
    // 价格计算方法4：在Invoice类中
    double calculateFinalAmount()
    {
        double subtotal = cart->calculateCartTotal();
        double tax = subtotal * taxRate;
        double shipping = calculateShipping(subtotal);
        
        return subtotal + tax + shipping;
    }
    
private:
    double calculateShipping(double amount)
    {
        if (amount > 500.0)
        {
            return 0.0; // 免运费
        }
        else if (amount > 200.0)
        {
            return 10.0; // 运费10元
        }
        else
        {
            return 20.0; // 运费20元
        }
    }
};

// 问题：价格计算逻辑分散在多个类中
// 当需要修改价格计算规则时（例如调整VIP折扣率），
// 需要在多个类中查找和修改相关代码

// 重构后：将价格计算逻辑集中到专门的类中
class PriceCalculationRule
{
public:
    virtual ~PriceCalculationRule() = default;
    virtual double calculatePrice(double basePrice, int quantity) = 0;
    virtual std::string getRuleName() const = 0;
};

class RegularCustomerPriceRule : public PriceCalculationRule
{
private:
    double discountRate;
    
public:
    RegularCustomerPriceRule(double rate = 0.05) : discountRate(rate) {}
    
    double calculatePrice(double basePrice, int quantity) override
    {
        double price = basePrice * (1 - discountRate);
        return price * quantity;
    }
    
    std::string getRuleName() const override
    {
        return "Regular Customer Price Rule";
    }
};

class VIPCustomerPriceRule : public PriceCalculationRule
{
private:
    double discountRate;
    
public:
    VIPCustomerPriceRule(double rate = 0.15) : discountRate(rate) {}
    
    double calculatePrice(double basePrice, int quantity) override
    {
        double price = basePrice * (1 - discountRate);
        return price * quantity;
    }
    
    std::string getRuleName() const override
    {
        return "VIP Customer Price Rule";
    }
};

class WholesalePriceRule : public PriceCalculationRule
{
private:
    double discountRate;
    int bulkQuantityThreshold;
    
public:
    WholesalePriceRule(double rate = 0.25, int threshold = 10) 
        : discountRate(rate), bulkQuantityThreshold(threshold) {}
    
    double calculatePrice(double basePrice, int quantity) override
    {
        double effectiveDiscount = discountRate;
        
        // 批量购买额外折扣
        if (quantity >= bulkQuantityThreshold)
        {
            effectiveDiscount += 0.05; // 额外5%折扣
        }
        
        double price = basePrice * (1 - effectiveDiscount);
        return price * quantity;
    }
    
    std::string getRuleName() const override
    {
        return "Wholesale Price Rule";
    }
};

class PriceCalculator
{
private:
    std::shared_ptr<PriceCalculationRule> priceRule;
    double taxRate;
    
public:
    PriceCalculator(std::shared_ptr<PriceCalculationRule> rule, double tax = 0.08)
        : priceRule(rule), taxRate(tax) {}
    
    void setPriceRule(std::shared_ptr<PriceCalculationRule> rule)
    {
        priceRule = rule;
    }
    
    double calculateItemPrice(double basePrice, int quantity)
    {
        if (!priceRule)
        {
            return basePrice * quantity;
        }
        return priceRule->calculatePrice(basePrice, quantity);
    }
    
    double calculateTax(double amount)
    {
        return amount * taxRate;
    }
    
    double calculateShipping(double amount)
    {
        if (amount > 500.0)
        {
            return 0.0;
        }
        else if (amount > 200.0)
        {
            return 10.0;
        }
        else
        {
            return 20.0;
        }
    }
    
    double calculateCartDiscount(double totalAmount)
    {
        if (totalAmount > 1000.0)
        {
            return 50.0;
        }
        else if (totalAmount > 500.0)
        {
            return 20.0;
        }
        return 0.0;
    }
};

// 重构后的Product类
class RefactoredProduct
{
private:
    std::string name;
    double basePrice;
    
public:
    RefactoredProduct(const std::string& productName, double price)
        : name(productName), basePrice(price) {}
    
    std::string getName() const { return name; }
    double getBasePrice() const { return basePrice; }
};

// 重构后的OrderItem类
class RefactoredOrderItem
{
private:
    std::shared_ptr<RefactoredProduct> product;
    int quantity;
    
public:
    RefactoredOrderItem(std::shared_ptr<RefactoredProduct> prod, int qty)
        : product(prod), quantity(qty) {}
    
    std::shared_ptr<RefactoredProduct> getProduct() const { return product; }
    int getQuantity() const { return quantity; }
};

// 重构后的ShoppingCart类
class RefactoredShoppingCart
{
private:
    std::vector<std::shared_ptr<RefactoredOrderItem>> items;
    std::shared_ptr<PriceCalculator> priceCalculator;
    
public:
    RefactoredShoppingCart(std::shared_ptr<PriceCalculator> calculator)
        : priceCalculator(calculator) {}
    
    void addItem(std::shared_ptr<RefactoredOrderItem> item)
    {
        items.push_back(item);
    }
    
    double calculateSubtotal()
    {
        double subtotal = 0.0;
        
        for (const auto& item : items)
        {
            double basePrice = item->getProduct()->getBasePrice();
            int quantity = item->getQuantity();
            
            subtotal += priceCalculator->calculateItemPrice(basePrice, quantity);
        }
        
        // 应用购物车折扣
        double discount = priceCalculator->calculateCartDiscount(subtotal);
        return subtotal - discount;
    }
    
    double calculateTotal()
    {
        double subtotal = calculateSubtotal();
        double tax = priceCalculator->calculateTax(subtotal);
        double shipping = priceCalculator->calculateShipping(subtotal);
        
        return subtotal + tax + shipping;
    }
};

int main()
{
    // 使用重构前的代码
    std::shared_ptr<Product> laptop = std::make_shared<Product>("Laptop", 999.99);
    std::shared_ptr<Product> mouse = std::make_shared<Product>("Mouse", 49.99);
    
    std::shared_ptr<OrderItem> item1 = std::make_shared<OrderItem>(laptop, 1);
    std::shared_ptr<OrderItem> item2 = std::make_shared<OrderItem>(mouse, 3);
    
    std::shared_ptr<ShoppingCart> cart = std::make_shared<ShoppingCart>("VIP");
    cart->addItem(item1);
    cart->addItem(item2);
    
    std::shared_ptr<Invoice> invoice = std::make_shared<Invoice>(cart, 0.08);
    
    std::cout << "=== 重构前的价格计算 ===" << std::endl;
    std::cout << "Cart Total: $" << cart->calculateCartTotal() << std::endl;
    std::cout << "Final Amount: $" << invoice->calculateFinalAmount() << std::endl;
    
    // 使用重构后的代码
    std::shared_ptr<RefactoredProduct> refactoredLaptop = 
        std::make_shared<RefactoredProduct>("Laptop", 999.99);
    std::shared_ptr<RefactoredProduct> refactoredMouse = 
        std::make_shared<RefactoredProduct>("Mouse", 49.99);
    
    std::shared_ptr<RefactoredOrderItem> refactoredItem1 = 
        std::make_shared<RefactoredOrderItem>(refactoredLaptop, 1);
    std::shared_ptr<RefactoredOrderItem> refactoredItem2 = 
        std::make_shared<RefactoredOrderItem>(refactoredMouse, 3);
    
    // 创建价格计算规则
    std::shared_ptr<PriceCalculationRule> vipRule = 
        std::make_shared<VIPCustomerPriceRule>(0.15);
    
    std::shared_ptr<PriceCalculator> priceCalculator = 
        std::make_shared<PriceCalculator>(vipRule, 0.08);
    
    std::shared_ptr<RefactoredShoppingCart> refactoredCart = 
        std::make_shared<RefactoredShoppingCart>(priceCalculator);
    
    refactoredCart->addItem(refactoredItem1);
    refactoredCart->addItem(refactoredItem2);
    
    std::cout << "\n=== 重构后的价格计算 ===" << std::endl;
    std::cout << "Using: " << vipRule->getRuleName() << std::endl;
    std::cout << "Cart Total: $" << refactoredCart->calculateTotal() << std::endl;
    
    // 改变价格计算规则
    std::shared_ptr<PriceCalculationRule> wholesaleRule = 
        std::make_shared<WholesalePriceRule>(0.25, 5);
    
    priceCalculator->setPriceRule(wholesaleRule);
    
    std::cout << "\n=== 改变价格计算规则 ===" << std::endl;
    std::cout << "Now using: " << wholesaleRule->getRuleName() << std::endl;
    std::cout << "Cart Total: $" << refactoredCart->calculateTotal() << std::endl;
    
    // 优势：当需要修改价格计算规则时，只需要修改PriceCalculationRule的实现
    // 而不需要在多个类中查找和修改代码
    
    return 0;
}