行为型模式 - 标签 - 咔咔不太卡的博客

命令模式 (Command Pattern)

咔咔 — Sun, 12 Apr 2026 17:00:00 +0800

概述

命令模式是一种行为型设计模式，它将请求封装成对象，从而使你可以用不同的请求、队列或日志来参数化其他对象。命令模式也支持可撤销的操作。

适用场景

需要参数化对象
支持撤销/重做功能
实现操作队列或日志
支持事务

基础实现

        
        
        
    
// 命令接口
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();
    }
}

// 使用
RemoteControl remote = new RemoteControl();
Light light = new Light();

remote.setCommand(new LightOnCommand(light));
remote.pressButton();  // 开灯
remote.pressUndo();    // 撤销（关灯）

框架中的应用

Runnable / Callable

        
// Java 的 Runnable 就是命令模式
ExecutorService executor = Executors.newFixedThreadPool(4);

Runnable command = () -> {
    System.out.println("执行任务");
};

executor.submit(command);

Spring Event

        
        
        
    
@Component
public class OrderMessageListener {
    @JmsListener(destination = "order.queue")
    public void onMessage(OrderMessage message) {
        processOrder(message);
    }
}

优缺点

优点	缺点
解耦调用者和接收者	类数量增加
支持撤销/重做	系统复杂度提高
支持队列和日志

总结

命令模式是解耦请求发送者和接收者的有效方式。在需要支持撤销、队列、日志等功能的场景下非常适用。Spring 的 @Async、消息监听等机制都使用了命令模式的思想。

责任链模式 (Chain of Responsibility Pattern)

咔咔 — Sun, 12 Apr 2026 16:30:00 +0800

概述

责任链模式是一种行为型设计模式，它允许你将请求沿着处理链传递。每个处理者都可以决定处理请求或将其传递给链上的下一个处理者。

适用场景

多个对象可以处理同一请求
需要动态指定处理顺序
不希望显式指定处理者

基础实现

        
        
        
    
// 处理者接口
public abstract class Handler {
    protected Handler nextHandler;
    
    public void setNext(Handler handler) {
        this.nextHandler = handler;
    }
    
    public final void handle(Request request) {
        if (canHandle(request)) {
            process(request);
        } else if (nextHandler != null) {
            nextHandler.handle(request);
        } else {
            System.out.println("无法处理请求");
        }
    }
    
    protected abstract boolean canHandle(Request request);
    protected abstract void process(Request request);
}

// 具体处理者：经理
public class Manager extends Handler {
    @Override
    protected boolean canHandle(Request request) {
        return request.getAmount() <= 1000;
    }
    
    @Override
    protected void process(Request request) {
        System.out.println("经理审批了 " + request.getAmount() + " 元的申请");
    }
}

// 具体处理者：总监
public class Director extends Handler {
    @Override
    protected boolean canHandle(Request request) {
        return request.getAmount() <= 5000;
    }
    
    @Override
    protected void process(Request request) {
        System.out.println("总监审批了 " + request.getAmount() + " 元的申请");
    }
}

// 使用
Handler manager = new Manager();
Handler director = new Director();
manager.setNext(director);

manager.handle(new Request("报销", 500));   // 经理处理
manager.handle(new Request("报销", 3000));  // 总监处理

Spring 过滤器链

        
        
        
    
// Spring Security 的过滤器链是责任链的典型应用
@Component
public class AuthFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain filterChain) {
        if (isAuthenticated(request)) {
            filterChain.doFilter(request, response); // 继续下一个过滤器
        } else {
            response.setStatus(401);
        }
    }
}

优缺点

优点	缺点
解耦发送者和接收者	请求可能未被处理
动态组合处理者	性能可能受影响
符合开闭原则	调试困难

总结

责任链模式在 Web 开发中非常常见，Servlet Filter、Spring Interceptor 都使用了这种模式。设计时要注意避免过长的链条影响性能。

模板方法模式 (Template Method Pattern)

咔咔 — Sun, 12 Apr 2026 16:00:00 +0800

概述

模板方法模式是一种行为型设计模式，它在超类中定义一个算法的框架，允许子类在不修改结构的情况下重写算法的特定步骤。

适用场景

多个类有相同的算法结构
需要控制子类扩展
代码复用，避免重复

基础实现

        
        
        
    
// 抽象类：定义模板
public abstract class DataImporter {
    
    // 模板方法（final 防止重写）
    public final void importData(String filePath) {
        validateFile(filePath);
        List<Data> dataList = parseFile(filePath);
        validateData(dataList);
        saveData(dataList);
        if (shouldNotify()) {
            sendNotification(dataList.size());
        }
    }
    
    private void validateFile(String filePath) {
        System.out.println("验证文件: " + filePath);
    }
    
    // 抽象方法：子类必须实现
    protected abstract List<Data> parseFile(String filePath);
    protected abstract void saveData(List<Data> dataList);
    
    // 钩子方法：子类可选择重写
    protected boolean shouldNotify() {
        return true;
    }
}

// 具体实现：CSV 导入
public class CsvImporter extends DataImporter {
    @Override
    protected List<Data> parseFile(String filePath) {
        System.out.println("解析 CSV 文件");
        return Arrays.asList(new Data("1"), new Data("2"));
    }
    
    @Override
    protected void saveData(List<Data> dataList) {
        System.out.println("保存 CSV 数据到数据库");
    }
}

// 具体实现：Excel 导入
public class ExcelImporter extends DataImporter {
    @Override
    protected List<Data> parseFile(String filePath) {
        System.out.println("解析 Excel 文件");
        return Arrays.asList(new Data("A"), new Data("B"));
    }
    
    @Override
    protected void saveData(List<Data> dataList) {
        System.out.println("保存 Excel 数据到数据库");
    }
    
    @Override
    protected boolean shouldNotify() {
        return false; // Excel 导入不发送通知
    }
}

// 使用
DataImporter csvImporter = new CsvImporter();
csvImporter.importData("data.csv");

框架中的应用

Spring JdbcTemplate

        
        
        
    
// JdbcTemplate 使用模板方法模式
public <T> T query(String sql, ResultSetExtractor<T> rse) {
    Connection con = DataSourceUtils.getConnection(getDataSource());
    try {
        Statement stmt = con.createStatement();
        try {
            ResultSet rs = stmt.executeQuery(sql);
            try {
                return rse.extractData(rs); // 回调实现
            } finally {
                rs.close();
            }
        } finally {
            stmt.close();
        }
    } finally {
        DataSourceUtils.releaseConnection(con, getDataSource());
    }
}

HttpServlet

        
        
        
    
// Servlet 的生命周期使用模板方法
public abstract class HttpServlet extends GenericServlet {
    protected void service(HttpServletRequest req, HttpServletResponse resp) {
        String method = req.getMethod();
        if ("GET".equals(method)) {
            doGet(req, resp);  // 子类实现
        } else if ("POST".equals(method)) {
            doPost(req, resp); // 子类实现
        }
    }
}

优缺点

优点	缺点
代码复用	类数量增加
控制算法结构	可能限制灵活性
符合开闭原则	复杂继承层次

总结

模板方法模式是框架设计的常用模式。Spring 中的 JdbcTemplate、TransactionTemplate 都使用了这种模式。在现代 Java 中，也可以考虑使用回调接口（如 Lambda）来实现更灵活的设计。

观察者模式 (Observer Pattern)

咔咔 — Sun, 12 Apr 2026 15:30:00 +0800

概述

观察者模式是一种行为型设计模式，它定义了对象之间的一对多依赖关系。当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知并自动更新。

模式结构

适用场景

事件处理系统
发布-订阅模型
数据变更通知
消息队列

基础实现

手动实现

        
        
        
    
// 观察者接口
public interface Observer {
    void update(String event, Object data);
}

// 被观察者接口
public interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers(String event, Object data);
}

// 具体被观察者
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 event, Object data) {
        for (Observer observer : observers) {
            observer.update(event, data);
        }
    }
    
    // 业务方法
    public void publishNews(String news) {
        System.out.println("发布新闻: " + news);
        notifyObservers("NEWS_PUBLISHED", news);
    }
}

// 具体观察者：邮件通知
public class EmailSubscriber implements Observer {
    private String email;
    
    public EmailSubscriber(String email) {
        this.email = email;
    }
    
    @Override
    public void update(String event, Object data) {
        if ("NEWS_PUBLISHED".equals(event)) {
            System.out.println("发送邮件到 " + email + ": 新新闻 " + data);
        }
    }
}

// 具体观察者：短信通知
public class SmsSubscriber implements Observer {
    private String phone;
    
    public SmsSubscriber(String phone) {
        this.phone = phone;
    }
    
    @Override
    public void update(String event, Object data) {
        if ("NEWS_PUBLISHED".equals(event)) {
            System.out.println("发送短信到 " + phone + ": 新新闻");
        }
    }
}

// 使用
NewsPublisher publisher = new NewsPublisher();
publisher.attach(new EmailSubscriber("user@example.com"));
publisher.attach(new SmsSubscriber("13800138000"));

publisher.publishNews("Java 21 发布了！");

Java 内置实现

        
        
        
    
import java.util.Observable;
import java.util.Observer;

// 被观察者（Java 9 后已废弃，建议使用 Flow API）
public class WeatherData extends Observable {
    private float temperature;
    
    public void setTemperature(float temperature) {
        this.temperature = temperature;
        setChanged();  // 标记状态已改变
        notifyObservers(temperature);  // 通知观察者
    }
}

// 观察者
public class WeatherDisplay implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("温度更新: " + arg);
    }
}

// 使用
WeatherData weatherData = new WeatherData();
weatherData.addObserver(new WeatherDisplay());
weatherData.setTemperature(25.5f);

Spring Event

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

// 发布事件
@Service
public class OrderService {
    @Autowired
    private ApplicationEventPublisher eventPublisher;
    
    public void createOrder(Order order) {
        orderRepository.save(order);
        eventPublisher.publishEvent(new OrderCreatedEvent(this, order));
    }
}

// 监听事件：发送邮件
@Component
public class OrderEmailListener {
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        Order order = event.getOrder();
        System.out.println("发送订单确认邮件: " + order.getId());
    }
}

// 监听事件：更新库存
@Component
public class OrderInventoryListener {
    @EventListener
    public void handleOrderCreated(OrderCreatedEvent event) {
        Order order = event.getOrder();
        System.out.println("扣减库存: " + order.getProductId());
    }
}

优缺点

优点	缺点
松耦合	通知顺序不确定
支持广播通信	可能循环依赖
易于扩展	内存泄漏风险

总结

观察者模式是实现事件驱动架构的基础。Spring Event 提供了企业级的实现，支持同步/异步、事务等多种特性。

策略模式 (Strategy Pattern)

咔咔 — Sun, 12 Apr 2026 15:00:00 +0800

概述

策略模式是一种行为型设计模式，它定义了一系列算法，并将每个算法封装起来，使它们可以互相替换。策略模式让算法的变化独立于使用算法的客户。

适用场景

多种方式完成相同任务
需要动态切换算法
避免多重条件判断

基础实现

        
        
        
    
// 策略接口
public interface PaymentStrategy {
    void pay(BigDecimal amount);
    String getName();
}

// 具体策略：支付宝
public class AlipayStrategy implements PaymentStrategy {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("支付宝支付: ¥" + amount);
    }
    
    @Override
    public String getName() {
        return "支付宝";
    }
}

// 具体策略：微信支付
public class WechatPayStrategy implements PaymentStrategy {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("微信支付: ¥" + amount);
    }
    
    @Override
    public String getName() {
        return "微信支付";
    }
}

// 具体策略：银行卡
public class CardPayStrategy implements PaymentStrategy {
    @Override
    public void pay(BigDecimal amount) {
        System.out.println("银行卡支付: ¥" + amount);
    }
    
    @Override
    public String getName() {
        return "银行卡";
    }
}

// 上下文
public class PaymentContext {
    private PaymentStrategy strategy;
    
    public void setStrategy(PaymentStrategy strategy) {
        this.strategy = strategy;
    }
    
    public void executePayment(BigDecimal amount) {
        strategy.pay(amount);
    }
}

// 使用
PaymentContext context = new PaymentContext();

// 选择支付宝
context.setStrategy(new AlipayStrategy());
context.executePayment(new BigDecimal("100"));

// 切换到微信支付
context.setStrategy(new WechatPayStrategy());
context.executePayment(new BigDecimal("200"));

Spring 集成

        
        
        
    
// 策略接口
public interface DiscountStrategy {
    BigDecimal calculateDiscount(BigDecimal originalPrice);
    String getType();
}

// 具体策略
@Component
public class NormalDiscountStrategy implements DiscountStrategy {
    @Override
    public BigDecimal calculateDiscount(BigDecimal price) {
        return price; // 无折扣
    }
    
    @Override
    public String getType() {
        return "NORMAL";
    }
}

@Component
public class VipDiscountStrategy implements DiscountStrategy {
    @Override
    public BigDecimal calculateDiscount(BigDecimal price) {
        return price.multiply(new BigDecimal("0.8")); // VIP 8折
    }
    
    @Override
    public String getType() {
        return "VIP";
    }
}

@Component
public class SuperVipDiscountStrategy implements DiscountStrategy {
    @Override
    public BigDecimal calculateDiscount(BigDecimal price) {
        return price.multiply(new BigDecimal("0.5")); // 超级VIP 5折
    }
    
    @Override
    public String getType() {
        return "SUPER_VIP";
    }
}

// 策略工厂
@Component
public class DiscountStrategyFactory {
    private final Map<String, DiscountStrategy> strategies = new HashMap<>();
    
    public DiscountStrategyFactory(List<DiscountStrategy> strategyList) {
        for (DiscountStrategy strategy : strategyList) {
            strategies.put(strategy.getType(), strategy);
        }
    }
    
    public DiscountStrategy getStrategy(String type) {
        DiscountStrategy strategy = strategies.get(type);
        if (strategy == null) {
            throw new IllegalArgumentException("未知的折扣类型: " + type);
        }
        return strategy;
    }
}

// 使用
@Service
public class OrderService {
    @Autowired
    private DiscountStrategyFactory strategyFactory;
    
    public BigDecimal calculatePrice(String userType, BigDecimal originalPrice) {
        DiscountStrategy strategy = strategyFactory.getStrategy(userType);
        return strategy.calculateDiscount(originalPrice);
    }
}

框架中的应用

Java Comparator

        
// Comparator 是策略接口
List<String> names = Arrays.asList("Tom", "JERRY", "alice");

// 策略1：自然排序
names.sort(Comparator.naturalOrder());

// 策略2：忽略大小写
names.sort(String.CASE_INSENSITIVE_ORDER);

// 策略3：按长度排序
names.sort(Comparator.comparingInt(String::length));

// 策略4：自定义排序
names.sort((a, b) -> a.length() - b.length());

Spring Validation

        
        
        
    
// Spring 的 Validator 是策略模式
public interface Validator {
    boolean supports(Class clazz);
    void validate(Object target, Errors errors);
}

// 不同的验证器实现不同的验证策略
@Component
public class UserValidator implements Validator {
    @Override
    public boolean supports(Class clazz) {
        return User.class.equals(clazz);
    }
    
    @Override
    public void validate(Object target, Errors errors) {
        // 验证逻辑
    }
}

ThreadPoolExecutor 拒绝策略

        
        
        
    
// 拒绝策略枚举
new ThreadPoolExecutor(
    5, 10, 60L, TimeUnit.SECONDS,
    new LinkedBlockingQueue<>(100),
    // 选择拒绝策略
    new ThreadPoolExecutor.CallerRunsPolicy()  // 调用者执行
    // new ThreadPoolExecutor.AbortPolicy()    // 抛出异常
    // new ThreadPoolExecutor.DiscardPolicy()  // 静默丢弃
    // new ThreadPoolExecutor.DiscardOldestPolicy() // 丢弃最老任务
);

实际应用：排序策略

        
        
        
    
// 排序策略接口
public interface SortStrategy {
    <T extends Comparable<T>> void sort(List<T> list);
    String getName();
}

// 快速排序
@Component
public class QuickSortStrategy implements SortStrategy {
    @Override
    public <T extends Comparable<T>> void sort(List<T> list) {
        quickSort(list, 0, list.size() - 1);
    }
    
    private <T extends Comparable<T>> void quickSort(List<T> list, int low, int high) {
        if (low < high) {
            int pi = partition(list, low, high);
            quickSort(list, low, pi - 1);
            quickSort(list, pi + 1, high);
        }
    }
    
    private <T extends Comparable<T>> int partition(List<T> list, int low, int high) {
        T pivot = list.get(high);
        int i = low - 1;
        for (int j = low; j < high; j++) {
            if (list.get(j).compareTo(pivot) <= 0) {
                i++;
                Collections.swap(list, i, j);
            }
        }
        Collections.swap(list, i + 1, high);
        return i + 1;
    }
    
    @Override
    public String getName() {
        return "QUICK_SORT";
    }
}

// 归并排序
@Component
public class MergeSortStrategy implements SortStrategy {
    @Override
    public <T extends Comparable<T>> void sort(List<T> list) {
        if (list.size() > 1) {
            mergeSort(list, 0, list.size() - 1);
        }
    }
    
    // 实现归并排序...
    
    @Override
    public String getName() {
        return "MERGE_SORT";
    }
}

// 排序服务
@Service
public class SortService {
    @Autowired
    private Map<String, SortStrategy> strategies;
    
    public <T extends Comparable<T>> List<T> sort(List<T> list, String algorithm) {
        SortStrategy strategy = strategies.get(algorithm);
        if (strategy == null) {
            throw new IllegalArgumentException("未知的排序算法");
        }
        
        List<T> copy = new ArrayList<>(list);
        strategy.sort(copy);
        return copy;
    }
}

与状态模式对比

策略模式	状态模式
客户端选择算法	状态自动转换
算法平等独立	状态有先后顺序
替换整个算法	根据条件改变行为

优缺点

优点	缺点
消除条件判断	类数量增加
易于扩展	客户端需了解策略
复用性好

总结

策略模式是消除 if-else/switch 的有效手段。在 Spring 中结合依赖注入可以实现优雅的策略管理。注意策略数量过多时考虑使用工厂模式管理。