面向对象编程实战技巧与设计模式解析

1. 面向对象编程进阶指南

记得第一次接触面向对象编程时，我被那些"类"、"对象"、"继承"这些概念绕得头晕。直到真正在项目中应用后，才发现面向对象思想就像搭积木一样自然。今天我们就来聊聊面向对象编程中那些教科书上不会告诉你的实战技巧。

面向对象编程(OOP)是现代软件开发的核心范式，无论是Python、Java还是C++，掌握其精髓都能让你的代码更优雅、更易维护。我们将从实际项目经验出发，深入探讨封装、继承、多态三大特性的高级应用，以及设计模式中的面向对象思想。

2. 封装的艺术与实战技巧

2.1 访问控制的边界把控

封装不只是简单的private/public修饰符使用。在实际项目中，我总结出几个关键原则：

1. 最小权限原则：只暴露必要的方法和属性
2. 防御性编程：对输入参数进行严格校验
3. 不变性设计：尽可能使用final/readonly属性

python复制class BankAccount:
    def __init__(self, initial_balance):
        self._balance = initial_balance  # 保护属性
        
    @property
    def balance(self):
        return self._balance
        
    def deposit(self, amount):
        if amount <= 0:
            raise ValueError("存款金额必须大于0")
        self._balance += amount

提示：Python中没有真正的private，使用单下划线约定表示保护属性，双下划线实现名称改写(name mangling)

2.2 属性管理的进阶技巧

现代编程语言提供了多种属性管理机制：

1. Python的@property装饰器
2. Java的Bean规范
3. C#的自动属性

实际项目中，我推荐使用属性访问器而非直接暴露字段，这为后续业务逻辑变更提供了灵活性。

3. 继承体系的深度设计

3.1 继承与组合的选择困境

很多开发者滥用继承，导致类层次结构臃肿。我的经验法则是：

• 优先使用组合而非继承
• 只有明确的"is-a"关系才考虑继承
• 保持继承层次不超过3层

java复制// 不好的继承设计
class Rectangle {
    double width;
    double height;
}

class Square extends Rectangle {
    // 违反里氏替换原则
}

// 更好的设计
interface Shape {
    double area();
}

class Rectangle implements Shape {
    // 实现细节
}

class Square implements Shape {
    // 实现细节
}

3.2 抽象类与接口的实战应用

抽象类适合：

• 有部分共同实现
• 需要定义模板方法
• 子类间有紧密关系

接口适合：

• 定义行为契约
• 多重继承场景
• 松耦合设计

在最近的一个电商项目中，我们使用接口定义支付策略：

python复制from abc import ABC, abstractmethod

class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount):
        pass

class CreditCardPayment(PaymentStrategy):
    def pay(self, amount):
        print(f"信用卡支付{amount}元")

class AlipayPayment(PaymentStrategy):
    def pay(self, amount):
        print(f"支付宝支付{amount}元")

4. 多态的高级应用场景

4.1 运行时多态与静态多态

多态不仅限于方法重写。在实际项目中，我常用以下模式：

1. 策略模式：运行时切换算法
2. 工厂模式：动态创建对象
3. 访问者模式：处理复杂对象结构

一个典型的策略模式应用：

java复制interface SortingStrategy {
    void sort(int[] data);
}

class QuickSort implements SortingStrategy {
    public void sort(int[] data) {
        // 快速排序实现
    }
}

class Context {
    private SortingStrategy strategy;
    
    public Context(SortingStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void executeSort(int[] data) {
        strategy.sort(data);
    }
}

4.2 鸭子类型的灵活运用

Python等动态语言支持鸭子类型(duck typing)，这为多态提供了更灵活的实现方式：

python复制class Duck:
    def quack(self):
        print("Quack!")

class Person:
    def quack(self):
        print("I'm quacking like a duck!")

def make_it_quack(duck_like):
    duck_like.quack()
    
make_it_quack(Duck())  # 输出: Quack!
make_it_quack(Person())  # 输出: I'm quacking like a duck!

5. 设计模式中的面向对象思想

5.1 创建型模式实战

单例模式的线程安全实现：

java复制public class Singleton {
    private static volatile Singleton instance;
    
    private Singleton() {}
    
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

注意：双重检查锁定模式在Java中需要volatile关键字保证可见性

5.2 结构型模式解析

适配器模式在实际项目中的典型应用：

python复制class OldSystem:
    def specific_request(self):
        return "老系统接口数据"

class Target:
    def request(self):
        pass

class Adapter(Target):
    def __init__(self, old_system):
        self.old_system = old_system
        
    def request(self):
        return f"适配后的数据: {self.old_system.specific_request()}"

5.3 行为型模式应用

观察者模式在事件驱动系统中的实现：

python复制class Subject:
    def __init__(self):
        self._observers = []
        
    def attach(self, observer):
        self._observers.append(observer)
        
    def notify(self):
        for observer in self._observers:
            observer.update(self)

class ConcreteObserver:
    def update(self, subject):
        print("收到状态变更通知")

subject = Subject()
observer = ConcreteObserver()
subject.attach(observer)
subject.notify()

6. 面向对象设计原则深度解读

6.1 SOLID原则实战

1. 单一职责原则(SRP)：

   • 每个类只负责一件事
   • 避免"上帝类"出现

2. 开闭原则(OCP)：

   • 对扩展开放
   • 对修改关闭

3. 里氏替换原则(LSP)：

   • 子类必须能够替换父类
   • 避免破坏继承契约

4. 接口隔离原则(ISP)：

   • 客户端不应依赖不需要的接口
   • 拆分臃肿接口

5. 依赖倒置原则(DIP)：

   • 依赖抽象而非具体实现
   • 高层模块不依赖低层模块

6.2 迪米特法则应用

迪米特法则(最少知识原则)建议：

• 只与直接朋友通信
• 减少类之间的耦合

违反迪米特法则的典型例子：

java复制// 不好的设计
class Customer {
    private Wallet wallet;
    
    public float getPayment(Order order) {
        return wallet.getMoney(order.getTotal());
    }
}

// 更好的设计
class Customer {
    private Wallet wallet;
    
    public void pay(Order order) {
        wallet.deduct(order.getTotal());
    }
}

7. 面向对象设计常见误区

7.1 过度设计陷阱

在项目初期，我经常犯的错误包括：

1. 过早抽象
2. 过度使用设计模式
3. 创建不必要的接口

经验法则：当需求变更三次以上才考虑抽象

7.2 贫血模型问题

贫血模型是指只有数据没有行为的类，这实际上是面向过程编程。解决方案：

1. 将业务逻辑移入领域对象
2. 使用领域驱动设计(DDD)

贫血模型示例：

java复制// 贫血模型
class Order {
    private List<Item> items;
    private double total;
    
    // 只有getter/setter
}

class OrderService {
    public void calculateTotal(Order order) {
        // 业务逻辑在服务类中
    }
}

7.3 继承滥用问题

错误使用继承会导致：

1. 脆弱的基类问题
2. 菱形继承问题
3. 过度耦合

解决方案：

1. 优先使用组合
2. 使用接口定义行为
3. 考虑委托模式

8. 现代面向对象编程实践

8.1 函数式编程与OOP结合

现代语言如Python、Java 8+、C#都支持函数式特性：

python复制from typing import Callable

class OrderProcessor:
    def __init__(self, validation_strategy: Callable[[Order], bool]):
        self.validation_strategy = validation_strategy
        
    def process(self, order: Order):
        if self.validation_strategy(order):
            # 处理订单
            pass

8.2 响应式编程中的OOP

RxJava、Project Reactor等框架中的面向对象设计：

java复制public class OrderService {
    private final OrderRepository repository;
    
    public OrderService(OrderRepository repository) {
        this.repository = repository;
    }
    
    public Flux<Order> getRecentOrders() {
        return repository.findAll()
               .filter(order -> order.getDate().isAfter(LocalDate.now().minusDays(7)))
               .map(this::enrichOrder);
    }
}

8.3 领域驱动设计(DDD)实践

DDD核心概念：

1. 实体(Entity)
2. 值对象(Value Object)
3. 聚合根(Aggregate Root)
4. 仓储(Repository)
5. 领域服务(Domain Service)

示例代码结构：

code复制src/
  domain/
    model/
      order.py       # 聚合根
      line_item.py   # 值对象
    services/
      ordering.py    # 领域服务
  infrastructure/
    repositories/
      order_repo.py  # 仓储实现

9. 性能优化与面向对象设计

9.1 对象创建开销管理

1. 对象池模式
2. 享元模式
3. 延迟初始化

享元模式示例：

java复制class TreeType {
    private String name;
    private Color color;
    
    public TreeType(String name, Color color) {
        this.name = name;
        this.color = color;
    }
    
    public void draw(Point position) {
        // 绘制逻辑
    }
}

class TreeFactory {
    private static Map<String, TreeType> treeTypes = new HashMap<>();
    
    public static TreeType getTreeType(String name, Color color) {
        String key = name + color.toString();
        if (!treeTypes.containsKey(key)) {
            treeTypes.put(key, new TreeType(name, color));
        }
        return treeTypes.get(key);
    }
}

9.2 内存布局优化

在C++等语言中，对象内存布局影响性能：

1. 成员变量排列顺序
2. 虚函数表开销
3. 缓存友好设计

优化示例：

cpp复制// 不好的内存布局
class BadLayout {
    int a;
    double b;  // 可能导致内存对齐填充
    int c;
};

// 更好的布局
class GoodLayout {
    double b;
    int a;
    int c;  // 两个int可以打包在一起
};

10. 测试驱动开发(TDD)与OOP

10.1 可测试性设计

面向对象设计应考虑：

1. 依赖注入
2. 接口隔离
3. 单一职责

可测试的类设计示例：

python复制class OrderProcessor:
    def __init__(self, payment_gateway, inventory_service):
        self.payment_gateway = payment_gateway
        self.inventory_service = inventory_service
        
    def process(self, order):
        # 使用注入的依赖
        self.payment_gateway.charge(order.total)
        self.inventory_service.update(order.items)

10.2 模拟与存根技术

使用unittest.mock进行测试：

python复制from unittest.mock import Mock

def test_order_processing():
    mock_gateway = Mock()
    mock_inventory = Mock()
    
    processor = OrderProcessor(mock_gateway, mock_inventory)
    test_order = Order(...)
    
    processor.process(test_order)
    
    mock_gateway.charge.assert_called_once_with(test_order.total)
    mock_inventory.update.assert_called_once_with(test_order.items)

11. 重构技巧与模式应用

11.1 坏味道识别与重构

常见代码坏味道：

1. 过长的函数
2. 过大的类
3. 重复代码
4. 过长参数列表

重构方法：

1. 提取方法
2. 提取类
3. 引入参数对象
4. 用策略模式替换条件语句

11.2 设计模式驱动的重构

用工厂方法重构条件创建逻辑：

java复制// 重构前
class ProductCreator {
    public Product createProduct(String type) {
        if (type.equals("A")) {
            return new ProductA();
        } else if (type.equals("B")) {
            return new ProductB();
        }
        throw new IllegalArgumentException("未知产品类型");
    }
}

// 重构后
interface ProductFactory {
    Product createProduct();
}

class ProductACreator implements ProductFactory {
    public Product createProduct() {
        return new ProductA();
    }
}

class ProductBCreator implements ProductFactory {
    public Product createProduct() {
        return new ProductB();
    }
}

12. 跨语言面向对象特性比较

12.1 主流语言OOP支持对比

12.2 原型继承与类继承

JavaScript使用原型继承：

javascript复制// 原型继承
function Animal(name) {
    this.name = name;
}

Animal.prototype.speak = function() {
    console.log(this.name + ' makes a noise.');
};

function Dog(name) {
    Animal.call(this, name);
}

Dog.prototype = Object.create(Animal.prototype);
Dog.prototype.constructor = Dog;

Dog.prototype.speak = function() {
    console.log(this.name + ' barks.');
};

ES6引入类语法糖：

javascript复制class Animal {
    constructor(name) {
        this.name = name;
    }
    
    speak() {
        console.log(`${this.name} makes a noise.`);
    }
}

class Dog extends Animal {
    speak() {
        console.log(`${this.name} barks.`);
    }
}

13. 面向对象设计实战案例

13.1 电商系统设计

核心领域模型：

1. 订单聚合根
2. 商品实体
3. 库存值对象
4. 支付策略模式

类图片段：

code复制+----------------+       +----------------+       +----------------+
|    Order       |<>---->|  OrderLineItem |       |    Payment     |
+----------------+       +----------------+       +----------------+
| -orderId       |       | -productId     |       | +process()     |
| -orderDate     |       | -quantity      |       +----------------+
| -status        |       | -unitPrice     |               ^
| +addItem()     |       +----------------+               |
| +calculateTotal()|                                     |
+----------------+                           +-----------+-----------+
                                             |                       |
                                     +----------------+     +----------------+
                                     | CreditCardPay  |     |   AlipayPay    |
                                     +----------------+     +----------------+
                                     | +process()     |     | +process()     |
                                     +----------------+     +----------------+

13.2 游戏开发中的OOP

游戏实体组件模式：

python复制class Entity:
    def __init__(self):
        self.components = {}
        
    def add_component(self, component):
        self.components[type(component)] = component
        
    def get_component(self, component_type):
        return self.components.get(component_type)

class PhysicsComponent:
    def update(self, entity):
        # 物理模拟逻辑
        pass

class RenderComponent:
    def draw(self, entity):
        # 渲染逻辑
        pass

# 使用示例
player = Entity()
player.add_component(PhysicsComponent())
player.add_component(RenderComponent())

14. 面向对象设计工具与技巧

14.1 UML建模实战

常用UML图：

1. 类图：展示静态结构
2. 时序图：展示对象交互
3. 状态图：展示状态转换
4. 活动图：展示工作流程

类图绘制要点：

• 类名、属性、方法
• 可见性符号(+public, -private, #protected)
• 关系类型(继承、关联、聚合、组合)

14.2 设计模式识别工具

常用工具：

1. IntelliJ IDEA的代码检查
2. SonarQube静态分析
3. 设计模式识别插件

识别模式的特征：

1. 工厂方法：创建对象的方法
2. 观察者：主题-监听者结构
3. 装饰器：包装对象并保持接口

15. 面向对象设计的未来趋势

15.1 微服务架构中的OOP

微服务设计原则：

1. 单一职责
2. 领域驱动
3. 独立部署

服务设计示例：

java复制// 订单服务
@RestController
class OrderController {
    private final OrderService orderService;
    
    @PostMapping("/orders")
    public ResponseEntity<Order> createOrder(@RequestBody OrderRequest request) {
        Order order = orderService.createOrder(request);
        return ResponseEntity.ok(order);
    }
}

// 支付服务
@RestController
class PaymentController {
    @PostMapping("/payments")
    public ResponseEntity<PaymentResult> processPayment(@RequestBody PaymentRequest request) {
        // 支付处理逻辑
    }
}

15.2 云原生与OOP

云原生应用设计考虑：

1. 无状态服务
2. 弹性设计
3. 分布式事务

使用Spring Cloud的示例：

java复制@Service
@RequiredArgsConstructor
class OrderService {
    private final InventoryClient inventoryClient;
    private final PaymentClient paymentClient;
    
    @Transactional
    public Order placeOrder(OrderRequest request) {
        inventoryClient.reserve(request.items());
        paymentClient.charge(request.payment());
        return saveOrder(request);
    }
}

16. 常见问题与解决方案

16.1 对象关系映射(ORM)陷阱

常见问题：

1. 懒加载异常
2. N+1查询问题
3. 级联操作风险

解决方案：

1. 使用DTO模式
2. 合理配置抓取策略
3. 避免双向关联

16.2 并发编程挑战

面向对象并发问题：

1. 竞态条件
2. 死锁
3. 可见性问题

线程安全设计技巧：

1. 不可变对象
2. 线程局部存储
3. 并发集合使用

java复制// 线程安全的单例
class Singleton {
    private Singleton() {}
    
    private static class Holder {
        static final Singleton INSTANCE = new Singleton();
    }
    
    public static Singleton getInstance() {
        return Holder.INSTANCE;
    }
}

17. 性能调优实战技巧

17.1 对象池优化

数据库连接池配置示例：

java复制// HikariCP配置
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/mydb");
config.setUsername("user");
config.setPassword("password");
config.setMaximumPoolSize(10);
config.setMinimumIdle(5);

HikariDataSource dataSource = new HikariDataSource(config);

17.2 内存泄漏排查

常见泄漏场景：

1. 静态集合持有对象
2. 未关闭的资源
3. 监听器未注销

排查工具：

1. Java的VisualVM
2. Eclipse MAT
3. YourKit

18. 设计模式反模式

18.1 模式滥用案例

1. 为单例而单例
2. 过度使用工厂
3. 不必要的适配器

重构建议：

1. 先写简单代码
2. 需求变更时再重构
3. 保持YAGNI原则(You Aren't Gonna Need It)

18.2 过度工程化问题

症状：

1. 过多抽象层
2. 过早优化
3. 不必要的灵活性

解决方案：

1. 渐进式设计
2. 简单设计原则
3. 持续重构

19. 领域特定语言(DSL)设计

19.1 流畅接口模式

构建查询DSL示例：

java复制public class QueryBuilder {
    private String select;
    private String from;
    private String where;
    
    public QueryBuilder select(String columns) {
        this.select = columns;
        return this;
    }
    
    public QueryBuilder from(String table) {
        this.from = table;
        return this;
    }
    
    public String build() {
        return String.format("SELECT %s FROM %s WHERE %s", select, from, where);
    }
}

// 使用示例
String query = new QueryBuilder()
    .select("id, name")
    .from("users")
    .build();

19.2 内部DSL设计

使用Python实现配置DSL：

python复制class ConfigBuilder:
    def __init__(self):
        self._config = {}
        
    def database(self, name):
        self._config['database'] = name
        return self
        
    def port(self, number):
        self._config['port'] = number
        return self
        
    def build(self):
        return self._config

# 使用示例
config = (ConfigBuilder()
         .database("mydb")
         .port(5432)
         .build())

20. 架构设计与OOP原则

20.1 分层架构实践

典型三层架构：

1. 表现层(UI)
2. 业务逻辑层(Service)
3. 数据访问层(DAO)

包结构示例：

code复制com.example.app
├── web        # 表现层
├── service    # 业务层
├── domain     # 领域模型
└── repository # 数据层

20.2 六边形架构应用

端口与适配器模式：

code复制         +---------------+
         |   Core Domain |
         +-------^-------+
                 |
         +-------v-------+
         |   Ports       |
         +-------^-------+
                 |
    +------------+------------+
    | Adapters                |
    | +--------+  +--------+ |
    | | REST   |  | DB     | |
    | +--------+  +--------+ |
    +------------------------+

实现示例：

java复制// 核心领域
interface OrderRepository {  // 端口
    Order save(Order order);
}

// 适配器实现
class JpaOrderRepository implements OrderRepository {
    private final EntityManager em;
    
    public Order save(Order order) {
        em.persist(order);
        return order;
    }
}

21. 代码质量与可维护性

21.1 度量指标解读

重要代码质量指标：

1. 圈复杂度
2. 继承深度
3. 类耦合度
4. 方法长度

优化目标：

1. 圈复杂度 < 10
2. 继承层次 < 3
3. 方法行数 < 20

21.2 重构实战演练

长方法重构示例：

java复制// 重构前
public void processOrder(Order order) {
    // 验证逻辑...20行
    // 计算逻辑...15行
    // 库存检查...10行
    // 支付处理...25行
    // 日志记录...5行
}

// 重构后
public void processOrder(Order order) {
    validateOrder(order);
    calculateTotals(order);
    checkInventory(order);
    processPayment(order);
    logOrder(order);
}

22. 设计模式组合应用

22.1 复合模式案例

MVC架构中的模式组合：

1. 观察者模式(模型通知视图)
2. 策略模式(控制器行为)
3. 组合模式(视图层次)

实现示例：

python复制class Model:
    def __init__(self):
        self._observers = []
        self._data = None
        
    def add_observer(self, observer):
        self._observers.append(observer)
        
    def set_data(self, data):
        self._data = data
        for observer in self._observers:
            observer.update(self._data)

class View:
    def update(self, data):
        print(f"View received new data: {data}")

class Controller:
    def __init__(self, model):
        self.model = model
        
    def handle_input(self, data):
        # 可以替换不同的处理策略
        self.model.set_data(data.upper())

22.2 模式协同工作

仓库模式与工作单元模式组合：

csharp复制public interface IUnitOfWork : IDisposable {
    IRepository<Customer> Customers { get; }
    IRepository<Order> Orders { get; }
    int Complete();
}

public class EntityFrameworkUnitOfWork : IUnitOfWork {
    private readonly DbContext _context;
    
    public EntityFrameworkUnitOfWork(DbContext context) {
        _context = context;
        Customers = new Repository<Customer>(context);
        Orders = new Repository<Order>(context);
    }
    
    public IRepository<Customer> Customers { get; }
    public IRepository<Order> Orders { get; }
    
    public int Complete() {
        return _context.SaveChanges();
    }
}

23. 现代语言特性与OOP

23.1 记录类型(Record)应用

Java 14+的Record类：

java复制public record Point(int x, int y) {
    // 自动生成equals, hashCode, toString
    // 不可变对象
}

// 使用示例
Point p = new Point(10, 20);
System.out.println(p.x());  // 获取x值

23.2 模式匹配增强

C#的模式匹配：

csharp复制public double CalculateArea(object shape) {
    return shape switch {
        Circle c => Math.PI * c.Radius * c.Radius,
        Rectangle r => r.Width * r.Height,
        _ => throw new ArgumentException("未知形状")
    };
}

24. 分布式系统中的OOP

24.1 远程对象设计

Java RMI示例：

java复制public interface Calculator extends Remote {
    int add(int a, int b) throws RemoteException;
}

public class CalculatorImpl extends UnicastRemoteObject implements Calculator {
    public CalculatorImpl() throws RemoteException {}
    
    public int add(int a, int b) {
        return a + b;
    }
}

// 服务端
Calculator stub = new CalculatorImpl();
Naming.rebind("//localhost/Calculator", stub);

// 客户端
Calculator calc = (Calculator)Naming.lookup("//localhost/Calculator");
int result = calc.add(5, 3);

24.2 微服务通信设计

RESTful资源设计：

java复制@RestController
@RequestMapping("/api/products")
public class ProductController {
    private final ProductService service;
    
    @GetMapping("/{id}")
    public Product getProduct(@PathVariable Long id) {
        return service.findById(id);
    }
    
    @PostMapping
    public Product createProduct(@RequestBody Product product) {
        return service.save(product);
    }
}

25. 函数式OOP混合编程

25.1 Java流式API设计

结合OOP与函数式：

java复制public class OrderProcessor {
    public List<Order> filterAndProcess(List<Order> orders) {
        return orders.stream()
            .filter(this::isValidOrder)
            .map(this::enrichOrder)
            .sorted(comparing(Order::getDate))
            .collect(toList());
    }
    
    private boolean isValidOrder(Order order) {
        // 验证逻辑
    }
    
    private Order enrichOrder(Order order) {
        // 丰富订单信息
    }
}

25.2 Python的混合范式

使用dataclass和函数式特性：

python复制from dataclasses import dataclass
from typing import List
from functools import reduce

@dataclass
class Product:
    id: int
    name: str
    price: float

class ShoppingCart:
    def __init__(self):
        self.items: List[Product] = []
        
    def add_item(self, product: Product):
        self.items.append(product)
        
    def total_price(self) -> float:
        return reduce(lambda acc, p: acc + p.price, self.items, 0.0)

26. 并发设计模式

26.1 不变性模式

不可变对象示例：

java复制public final class ImmutablePoint {
    private final int x;
    private final int y;
    
    public ImmutablePoint(int x, int y) {
        this.x = x;
        this.y = y;
    }
    
    public int getX() { return x; }
    public int getY() { return y; }
    
    public ImmutablePoint move(int dx, int dy) {
        return new ImmutablePoint(x + dx, y + dy);
    }
}

26.2 线程局部存储

ThreadLocal使用示例：

java复制public class UserContext {
    private static final ThreadLocal<User> currentUser = new ThreadLocal<>();
    
    public static void setCurrentUser(User user) {
        currentUser.set(user);
    }
    
    public static User getCurrentUser() {
        return currentUser.get();
    }
    
    public static void clear() {
        currentUser.remove();
    }
}

27. 缓存策略与OOP

27.1 缓存代理模式

为服务添加缓存：

python复制from functools import lru_cache

class DataService:
    def get_data(self, key):
        # 数据库查询
        pass

class CachedDataService:
    def __init__(self, service: DataService):
        self.service = service
        
    @lru_cache(maxsize=100)
    def get_data(self, key):
        return self.service.get_data(key)

27.2 缓存失效策略

基于事件的缓存失效：

java复制public class ProductCache {
    private final Cache<Long, Product> cache = Caffeine.newBuilder()
        .maximumSize(1000)
        .build();
        
    public void onProductUpdated(ProductUpdatedEvent event) {
        cache.invalidate(event.getProductId());
    }
    
    public Product getProduct(Long id) {
        return cache.get(id, this::loadFromDatabase);
    }
}

28. 安全设计与OOP

28.1 防御性编程技巧

输入验证示例：

java复制public class Account {
    private final String accountNumber;
    
    public Account(String accountNumber) {
        this.accountNumber = validateAccountNumber(accountNumber);
    }
    
    private static String validateAccountNumber(String number) {
        if (number == null || !number.matches("\\d{10}")) {
            throw new IllegalArgumentException("无效账号");
        }
        return number;
    }
}

28.2 权限控制模式

基于角色的访问控制：

python复制class User:
    def __init__(self, username, roles):
        self.username = username
        self.roles = set(roles)
        
    def has_role(self, role):
        return role in self.roles

class Document:
    def __init__(self, content, required_role="reader"):
        self.content = content
        self.required_role = required_role
        
    def access(self, user):
        if user.has_role(self.required_role):
            return self.content
        raise PermissionError("无权访问")

29. 测试策略与OOP

29.1 单元测试设计

测试金字塔实践：

1. 大量单元测试(快速)
2. 适量集成测试
3. 少量UI测试

测试类结构：

java复制class OrderServiceTest {
    private OrderService service;
    private PaymentGateway mockGateway;
    
    @BeforeEach
    void setUp() {
        mockGateway = mock(PaymentGateway.class);
        service = new OrderService(mockGateway);
    }
    
    @Test
    void shouldProcessValidOrder() {
        Order order = new Order(/* 测试数据 */);
        when(mockGateway.charge(any())).thenReturn(true);
        
        Order result = service.process(order);
        
        assertNotNull(result);
        verify(mockGateway).charge(order.getTotal());
    }
}

29.2 集成测试技巧

Spring Boot测试示例：

java复制@SpringBootTest
@AutoConfigureMockMvc
class ProductControllerIT {
    @Autowired
    private MockMvc mockMvc;
    
    @Test
    void shouldReturnProduct() throws Exception {
        mockMvc.perform(get("/api/products/1"))
               .andExpect(status().isOk())
               .andExpect(jsonPath("$.name").value("Test Product"));
    }
}

30. 持续演进与重构

30.1 识别重构时机

重构信号：

1. 添加新功能困难
2. 修复bug引入新问题
3. 代码难以理解
4. 重复代码出现

技术债务评估：

1. 代码异味数量
2. 测试覆盖率
3. 循环复杂度

30.2 安全重构策略

安全重构步骤：

1. 完善测试覆盖
2. 小步修改
3. 频繁验证
4. 版本控制

重构技术：

1. 重命名
2. 提取方法
3. 移动方法
4. 替换算法

31. 设计模式扩展应用

31.1 状态模式进阶

有限状态机实现：

python复制class State(ABC):
    @abstractmethod
    def handle(self, context):
        pass

class ConcreteStateA(State):
    def handle(self, context):
        print("处理状态A的行为")
        context.state = ConcreteStateB()

class Context:
    def __init__(self):
        self.state = ConcreteStateA()
        
    def request(self):
        self.state.handle(self)

# 使用示例
context = Context()
context.request()  # 输出: 处理状态A的行为
context.request()  # 切换到状态B

31.2 访问者模式变体

类型安全的访问者：

java复制interface Visitor<T> {
    T visit(ConcreteElementA element);
    T visit(ConcreteElementB element);
}

interface Element {
    <T> T accept(Visitor<T> visitor);
}

class ConcreteElementA implements Element {
    public <T> T accept(Visitor<T> visitor) {
        return visitor.visit(this);
    }
}

32. 架构模式与OOP

32.1 CQRS模式实现

命令查询职责分离：

csharp复制// 命令端
public class CreateProductCommandHandler {
    private readonly IRepository<Product> _repository;
    
    public void Handle(CreateProductCommand command) {
        var product = new Product(command.Name, command.Price);
        _repository.Add(product);
    }
}

// 查询端
public class ProductQueryService {
    private readonly IQueryable<Product> _products;
    
    public ProductDto GetProduct(int id) {
        return _products.Where(p => p.Id == id)
                       .Select(p => new ProductDto(p))
                       .FirstOrDefault();
    }
}

32.2 事件溯源模式

事件存储实现：

java复制public class EventStore {
    private final List<Event> events = new ArrayList<>();
    
    public void append(Event event) {
        events.add(event);
    }