行为型模式

行为型模式关注对象之间的通信和职责分配。

策略模式

定义一系列算法，将每个算法封装起来，使它们可以互换。

// 策略接口
public interface PayStrategy {
    void pay(double amount);
}

// 具体策略
public class AliPayStrategy implements PayStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("支付宝支付: " + amount);
    }
}

public class WeChatPayStrategy implements PayStrategy {
    @Override
    public void pay(double amount) {
        System.out.println("微信支付: " + amount);
    }
}

// 上下文
public class PayContext {
    private PayStrategy strategy;
    
    public void setStrategy(PayStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void pay(double amount) {
        strategy.pay(amount);
    }
}

// 使用
PayContext context = new PayContext();
context.setStrategy(new AliPayStrategy());
context.pay(100);

context.setStrategy(new WeChatPayStrategy());
context.pay(200);

策略模式 + 工厂

public class PayStrategyFactory {
    private static Map<String, PayStrategy> strategies = new HashMap<>();
    
    static {
        strategies.put("alipay", new AliPayStrategy());
        strategies.put("wechat", new WeChatPayStrategy());
    }
    
    public static PayStrategy getStrategy(String type) {
        return strategies.get(type);
    }
}

// 使用
PayStrategy strategy = PayStrategyFactory.getStrategy("alipay");
strategy.pay(100);

观察者模式

定义对象间的一对多依赖关系，当一个对象状态改变时，所有依赖者都会收到通知。

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

// 主题接口
public interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers(String message);
}

// 具体主题
public class NewsPublisher implements Subject {
    private List<Observer> observers = new ArrayList<>();
    
    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }
    
    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }
    
    @Override
    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
    
    public void publishNews(String news) {
        System.out.println("发布新闻: " + news);
        notifyObservers(news);
    }
}

// 具体观察者
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);
    }
}

// 使用
NewsPublisher publisher = new NewsPublisher();
publisher.attach(new User("张三"));
publisher.attach(new User("李四"));
publisher.publishNews("重大新闻！");

Spring 事件机制

// 定义事件
public class OrderEvent extends ApplicationEvent {
    private Order order;
    
    public OrderEvent(Object source, Order order) {
        super(source);
        this.order = order;
    }
}

// 发布事件
@Service
public class OrderService {
    @Autowired
    private ApplicationEventPublisher publisher;
    
    public void createOrder(Order order) {
        // 创建订单
        publisher.publishEvent(new OrderEvent(this, order));
    }
}

// 监听事件
@Component
public class OrderListener {
    @EventListener
    public void handleOrderEvent(OrderEvent event) {
        System.out.println("处理订单事件: " + event.getOrder());
    }
}

模板方法模式

定义算法的骨架，将某些步骤延迟到子类实现。

// 抽象类
public abstract class AbstractTemplate {
    
    // 模板方法
    public final void execute() {
        step1();
        step2();
        if (hook()) {
            step3();
        }
        step4();
    }
    
    // 具体方法
    private void step1() {
        System.out.println("步骤1：通用实现");
    }
    
    // 抽象方法
    protected abstract void step2();
    
    // 钩子方法
    protected boolean hook() {
        return true;
    }
    
    protected abstract void step3();
    
    private void step4() {
        System.out.println("步骤4：通用实现");
    }
}

// 具体实现
public class ConcreteTemplate extends AbstractTemplate {
    @Override
    protected void step2() {
        System.out.println("步骤2：具体实现A");
    }
    
    @Override
    protected void step3() {
        System.out.println("步骤3：具体实现A");
    }
}

实际应用

// Spring JdbcTemplate
jdbcTemplate.query(sql, (rs, rowNum) -> {
    User user = new User();
    user.setId(rs.getLong("id"));
    user.setName(rs.getString("name"));
    return user;
});

责任链模式

将请求沿着处理者链传递，直到有处理者处理它。

// 处理者接口
public abstract class Handler {
    protected Handler next;
    
    public void setNext(Handler next) {
        this.next = next;
    }
    
    public abstract void handle(Request request);
}

// 具体处理者
public class AuthHandler extends Handler {
    @Override
    public void handle(Request request) {
        if (request.isAuthenticated()) {
            System.out.println("认证通过");
            if (next != null) {
                next.handle(request);
            }
        } else {
            System.out.println("认证失败");
        }
    }
}

public class PermissionHandler extends Handler {
    @Override
    public void handle(Request request) {
        if (request.hasPermission()) {
            System.out.println("权限检查通过");
            if (next != null) {
                next.handle(request);
            }
        } else {
            System.out.println("权限不足");
        }
    }
}

public class BusinessHandler extends Handler {
    @Override
    public void handle(Request request) {
        System.out.println("处理业务逻辑");
    }
}

// 使用
Handler auth = new AuthHandler();
Handler permission = new PermissionHandler();
Handler business = new BusinessHandler();

auth.setNext(permission);
permission.setNext(business);

auth.handle(request);

实际应用

// Servlet Filter 链
// Spring Interceptor 链
// Netty ChannelPipeline

状态模式

允许对象在内部状态改变时改变它的行为。

// 状态接口
public interface State {
    void handle(Context context);
}

// 具体状态
public class StartState implements State {
    @Override
    public void handle(Context context) {
        System.out.println("开始状态");
        context.setState(new RunningState());
    }
}

public class RunningState implements State {
    @Override
    public void handle(Context context) {
        System.out.println("运行状态");
        context.setState(new StopState());
    }
}

public class StopState implements State {
    @Override
    public void handle(Context context) {
        System.out.println("停止状态");
    }
}

// 上下文
public class Context {
    private State state;
    
    public Context() {
        this.state = new StartState();
    }
    
    public void setState(State state) {
        this.state = state;
    }
    
    public void request() {
        state.handle(this);
    }
}

// 使用
Context context = new Context();
context.request();  // 开始状态
context.request();  // 运行状态
context.request();  // 停止状态

命令模式

将请求封装成对象，使你可以用不同的请求对客户进行参数化。

// 命令接口
public interface Command {
    void execute();
    void undo();
}

// 接收者
public class Light {
    public void on() { System.out.println("灯打开"); }
    public void off() { System.out.println("灯关闭"); }
}

// 具体命令
public class LightOnCommand implements Command {
    private Light light;
    
    public LightOnCommand(Light light) {
        this.light = light;
    }
    
    @Override
    public void execute() {
        light.on();
    }
    
    @Override
    public void undo() {
        light.off();
    }
}

// 调用者
public class RemoteControl {
    private Command command;
    
    public void setCommand(Command command) {
        this.command = command;
    }
    
    public void pressButton() {
        command.execute();
    }
    
    public void pressUndo() {
        command.undo();
    }
}

// 使用
Light light = new Light();
Command lightOn = new LightOnCommand(light);
RemoteControl remote = new RemoteControl();
remote.setCommand(lightOn);
remote.pressButton();  // 灯打开
remote.pressUndo();    // 灯关闭

迭代器模式

提供一种方法顺序访问聚合对象中的各个元素。

// Java 内置迭代器
List<String> list = Arrays.asList("A", "B", "C");
Iterator<String> iterator = list.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

// 增强 for 循环（语法糖）
for (String item : list) {
    System.out.println(item);
}