行为型设计模式解析：策略、观察者与责任链实践

王端端

1. 行为型模式概述

在软件开发中，我们经常会遇到对象间复杂的交互和职责分配问题。行为型模式就是为解决这类问题而生的设计模式，它主要关注对象之间的通信机制和职责划分。与创建型模式关注对象创建、结构型模式关注对象组合不同，行为型模式更注重对象间的协作方式。

行为型模式的核心价值在于：它提供了一套经过验证的解决方案，能够优雅地处理对象间的交互逻辑，使系统更灵活、更易于维护。在实际项目中，合理运用行为型模式可以显著降低模块间的耦合度，提高代码的可复用性和可扩展性。

2. 策略模式详解

2.1 策略模式定义与结构

策略模式（Strategy Pattern）定义了一系列算法，并将每个算法封装起来，使它们可以相互替换。策略模式让算法的变化独立于使用算法的客户。

策略模式包含三个核心角色：

Context（环境类）：持有一个策略类的引用，最终给客户端调用
Strategy（抽象策略）：定义所有支持的算法的公共接口
ConcreteStrategy（具体策略）：实现了抽象策略定义的接口，提供具体的算法实现

java复制// 抽象策略接口
public interface PaymentStrategy {
    void pay(int amount);
}

// 具体策略类
public class CreditCardPayment implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("使用信用卡支付：" + amount + "元");
    }
}

public class AlipayPayment implements PaymentStrategy {
    @Override
    public void pay(int amount) {
        System.out.println("使用支付宝支付：" + amount + "元");
    }
}

// 环境类
public class PaymentContext {
    private PaymentStrategy strategy;
    
    public PaymentContext(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void executePayment(int amount) {
        strategy.pay(amount);
    }
}

2.2 策略模式应用场景

策略模式特别适用于以下场景：

一个系统需要动态地在几种算法中选择一种
有多个条件语句的相同行为，可以考虑使用策略模式
不希望客户端知道复杂的、与算法相关的数据结构

实际开发中的典型应用：

支付方式选择（信用卡、支付宝、微信等）
排序算法选择（快速排序、归并排序等）
数据压缩算法选择（ZIP、RAR等）
表单验证策略（前端验证、后端验证等）

2.3 策略模式优缺点分析

优点：

算法可以自由切换：策略模式提供了管理相关算法族的办法
避免使用多重条件判断：将算法封装在独立的Strategy类中，消除了条件语句
扩展性良好：增加新策略只需实现策略接口即可，符合开闭原则

缺点：

客户端必须知道所有的策略类，并自行决定使用哪一个策略类
策略类数量会增多，增加了系统的复杂性
策略模式会产生很多策略类，可以通过享元模式来减少对象的数量

提示：当策略算法很复杂时，可以考虑使用策略模式配合模板方法模式，将算法的可变部分分离出来。

3. 观察者模式深入解析

3.1 观察者模式原理

观察者模式（Observer Pattern）定义了对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

观察者模式包含以下角色：

Subject（目标）：被观察的对象，它维护一组观察者，提供注册和删除观察者的接口
Observer（观察者）：为那些在目标发生改变时需获得通知的对象定义一个更新接口
ConcreteSubject（具体目标）：存储对观察者对象来说有意义的状态，状态改变时向观察者发出通知
ConcreteObserver（具体观察者）：维护一个指向具体目标的引用，存储与目标状态一致的状态，实现Observer的更新接口

java复制// 观察者接口
public interface Observer {
    void update(String message);
}

// 具体观察者
public class User implements Observer {
    private String name;
    
    public User(String name) {
        this.name = name;
    }
    
    @Override
    public void update(String message) {
        System.out.println(name + " 收到消息: " + message);
    }
}

// 目标接口
public interface Subject {
    void registerObserver(Observer o);
    void removeObserver(Observer o);
    void notifyObservers();
}

// 具体目标
public class NewsPublisher implements Subject {
    private List<Observer> observers = new ArrayList<>();
    private String news;
    
    @Override
    public void registerObserver(Observer o) {
        observers.add(o);
    }
    
    @Override
    public void removeObserver(Observer o) {
        observers.remove(o);
    }
    
    @Override
    public void notifyObservers() {
        for (Observer o : observers) {
            o.update(news);
        }
    }
    
    public void setNews(String news) {
        this.news = news;
        notifyObservers();
    }
}

3.2 观察者模式典型应用

观察者模式在实际开发中有广泛应用：

事件处理系统：如GUI中的按钮点击事件、键盘事件等
消息队列：生产者-消费者模型中的消息通知机制
发布-订阅系统：如微博、微信公众号的消息推送
MVC架构：模型(Model)变化时自动更新视图(View)
股票行情系统：股票价格变动时通知所有关注该股票的客户端

3.3 观察者模式实现变体

在实际开发中，观察者模式有多种实现方式：

推模型 vs 拉模型：
- 推模型：Subject将变更信息以参数形式传递给Observer
- 拉模型：Subject将自己传递给Observer，Observer自行获取所需数据
线程安全问题：
- 在多线程环境下，需要考虑Subject和Observer的线程安全问题
- 可以使用CopyOnWriteArrayList等线程安全集合存储观察者
Java内置支持：
- Java提供了Observable类和Observer接口
- 但Observable是类而非接口，限制了使用灵活性

注意：在实现观察者模式时，要特别注意避免观察者更新过程中又触发通知，导致无限循环的问题。

4. 责任链模式实践指南

4.1 责任链模式基本概念

责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。

责任链模式主要角色：

Handler（抽象处理者）：定义处理请求的接口，通常包含一个指向下一个处理者的引用
ConcreteHandler（具体处理者）：处理它负责的请求，可以访问它的后继者

java复制// 抽象处理者
public abstract class Handler {
    protected Handler successor;
    
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }
    
    public abstract void handleRequest(int request);
}

// 具体处理者
public class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request < 10) {
            System.out.println("HandlerA处理请求：" + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

public class ConcreteHandlerB extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 10 && request < 20) {
            System.out.println("HandlerB处理请求：" + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}