当前位置：首页 > 技术 > 正文内容

责任链模式的多种实现方式

访客技术 2026年5月25日 3

责任链模式是一种行为设计模式，允许将请求沿着一系列处理者传递，直到某个处理者能够处理该请求为止。

1. 链式基础实现

// 请求类
class Request {
    private String type;
    private String content;

    public Request(String type, String content) {
        this.type = type;
        this.content = content;
    }

    public String getType() { return type; }
    public String getContent() { return content; }
}

// 处理者接口
interface Handler {
    void setNext(Handler handler);
    void process(Request request);
}

// 抽象处理器
abstract class AbstractProcessor implements Handler {
    protected Handler next;

    @Override
    public void setNext(Handler handler) {
        this.next = handler;
    }

    @Override
    public void process(Request request) {
        if (isApplicable(request)) {
            handleRequest(request);
        } else if (next != null) {
            next.process(request);
        } else {
            System.out.println("未找到匹配的处理器：" + request);
        }
    }

    protected abstract boolean isApplicable(Request request);
    protected abstract void handleRequest(Request request);
}

// 具体处理器A
class ProcessorA extends AbstractProcessor {
    @Override
    protected boolean isApplicable(Request request) {
        return "A".equals(request.getType());
    }

    @Override
    protected void handleRequest(Request request) {
        System.out.println("处理器A执行：" + request.getContent());
    }
}

// 具体处理器B
class ProcessorB extends AbstractProcessor {
    @Override
    protected boolean isApplicable(Request request) {
        return "B".equals(request.getType());
    }

    @Override
    protected void handleRequest(Request request) {
        System.out.println("处理器B执行：" + request.getContent());
    }
}

// 示例代码
public class ChainDemo {
    public static void main(String[] args) {
        Handler processorA = new ProcessorA();
        Handler processorB = new ProcessorB();

        processorA.setNext(processorB);

        Request req1 = new Request("A", "请求A");
        Request req2 = new Request("B", "请求B");
        Request req3 = new Request("C", "请求C");

        processorA.process(req1); // 处理器A执行：请求A
        processorA.process(req2); // 处理器B执行：请求B
        processorA.process(req3); // 未找到匹配的处理器：请求C
    }
}

2. 使用集合的实现方式

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

// 处理器接口
interface Processor {
    boolean execute(Request request);
}

// 处理器链
class ProcessorChain {
    private List<Processor> processors = new ArrayList<>();

    public void addProcessor(Processor processor) {
        processors.add(processor);
    }

    public void execute(Request request) {
        for (Processor processor : processors) {
            if (processor.execute(request)) {
                return;
            }
        }
        System.out.println("无处理器匹配：" + request);
    }
}

// 具体处理器A
class ConcreteProcessorA implements Processor {
    @Override
    public boolean execute(Request request) {
        if ("A".equals(request.getType())) {
            System.out.println("处理器A执行：" + request.getContent());
            return true;
        }
        return false;
    }
}

// 具体处理器B
class ConcreteProcessorB implements Processor {
    @Override
    public boolean execute(Request request) {
        if ("B".equals(request.getType())) {
            System.out.println("处理器B执行：" + request.getContent());
            return true;
        }
        return false;
    }
}

// 示例代码
public class CollectionChainDemo {
    public static void main(String[] args) {
        ProcessorChain chain = new ProcessorChain();
        chain.addProcessor(new ConcreteProcessorA());
        chain.addProcessor(new ConcreteProcessorB());

        Request req1 = new Request("A", "请求A");
        Request req2 = new Request("B", "请求B");
        Request req3 = new Request("C", "请求C");

        chain.execute(req1); // 处理器A执行：请求A
        chain.execute(req2); // 处理器B执行：请求B
        chain.execute(req3); // 无处理器匹配：请求C
    }
}

3. 函数式接口实现

import java.util.Arrays;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;

// 请求类
class Request {
    private String type;
    private String content;

    public Request(String type, String content) {
        this.type = type;
        this.content = content;
    }

    public String getType() { return type; }
    public String getContent() { return content; }
}

// 函数式处理器接口
@FunctionalInterface
interface ProcessorFunction extends Function<Request, Boolean> {}

// 函数式处理器链
class FunctionalProcessorChain {
    private List<ProcessorFunction> processors;

    public FunctionalProcessorChain(ProcessorFunction... processors) {
        this.processors = Arrays.asList(processors);
    }

    public void execute(Request request) {
        for (ProcessorFunction processor : processors) {
            if (processor.apply(request)) {
                return;
            }
        }
        System.out.println("无处理器匹配：" + request);
    }
}

// 示例代码
public class FunctionalChainDemo {
    public static void main(String[] args) {
        ProcessorFunction processorA = request -> {
            if ("A".equals(request.getType())) {
                System.out.println("处理器A执行：" + request.getContent());
                return true;
            }
            return false;
        };

        ProcessorFunction processorB = request -> {
            if ("B".equals(request.getType())) {
                System.out.println("处理器B执行：" + request.getContent());
                return true;
            }
            return false;
        };

        FunctionalProcessorChain chain = new FunctionalProcessorChain(processorA, processorB);

        Request req1 = new Request("A", "请求A");
        Request req2 = new Request("B", "请求B");
        Request req3 = new Request("C", "请求C");

        chain.execute(req1); // 处理器A执行：请求A
        chain.execute(req2); // 处理器B执行：请求B
        chain.execute(req3); // 无处理器匹配：请求C
    }
}

4. 带排序的集合实现

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;

// 带优先级的处理器接口
interface OrderedProcessor {
    int getPriority();
    boolean execute(Request request);
}

// 排序处理器链
class OrderedProcessorChain {
    private List<OrderedProcessor> processors = new ArrayList<>();

    public void addProcessor(OrderedProcessor processor) {
        processors.add(processor);
        processors.sort(Comparator.comparingInt(OrderedProcessor::getPriority));
    }

    public void execute(Request request) {
        for (OrderedProcessor processor : processors) {
            if (processor.execute(request)) {
                return;
            }
        }
        System.out.println("无处理器匹配：" + request);
    }
}

// 具体处理器（带优先级）
class PriorityProcessorA implements OrderedProcessor {
    @Override
    public int getPriority() {
        return 1; // 高优先级
    }

    @Override
    public boolean execute(Request request) {
        if ("A".equals(request.getType())) {
            System.out.println("高优先级处理器A执行：" + request.getContent());
            return true;
        }
        return false;
    }
}

class PriorityProcessorB implements OrderedProcessor {
    @Override
    public int getPriority() {
        return 2; // 低优先级
    }

    @Override
    public boolean execute(Request request) {
        if ("B".equals(request.getType())) {
            System.out.println("低优先级处理器B执行：" + request.getContent());
            return true;
        }
        return false;
    }
}

// 示例代码
public class OrderedChainDemo {
    public static void main(String[] args) {
        OrderedProcessorChain chain = new OrderedProcessorChain();
        chain.addProcessor(new PriorityProcessorB()); // 添加低优先级
        chain.addProcessor(new PriorityProcessorA()); // 添加高优先级

        Request request = new Request("A", "请求A");
        chain.execute(request); // 高优先级处理器A执行：请求A
    }
}

纯责任链与非纯责任链的区别

纯责任链模式

每个处理器要么处理请求，要么将请求传递给下一个处理器。上述示例均属于纯责任链模式。

非纯责任链模式

每个处理器都可以尝试处理请求，并且无论是否成功，都会将请求传递给下一个处理器。例如，过滤器链属于非纯责任链模式。

import java.util.Arrays;
import java.util.List;

// 数据清理请求
class DataCleaningRequest {
    private String data;
    private List<String> steps = Arrays.asList("原始数据");

    public DataCleaningRequest(String data) {
        this.data = data;
    }

    public String getData() { return data; }
    public void setData(String data) { this.data = data; }
    public List<String> getSteps() { return steps; }
    public void addStep(String step) { steps.add(step); }
}

// 数据清洗器接口
interface DataCleaner {
    void setNext(DataCleaner cleaner);
    void clean(DataCleaningRequest request);
}

// 抽象数据清洗器
abstract class AbstractDataCleaner implements DataCleaner {
    protected DataCleaner next;

    @Override
    public void setNext(DataCleaner cleaner) {
        this.next = cleaner;
    }

    @Override
    public void clean(DataCleaningRequest request) {
        performCleaning(request);

        if (next != null) {
            next.clean(request);
        }
    }

    protected abstract void performCleaning(DataCleaningRequest request);
}

// 具体清洗器 - 去除空格
class WhitespaceRemover extends AbstractDataCleaner {
    @Override
    protected void performCleaning(DataCleaningRequest request) {
        String cleaned = request.getData().replaceAll("\\s+", " ").trim();
        request.setData(cleaned);
        request.addStep("去除空格");
        System.out.println("空格已清理：" + cleaned);
    }
}

// 具体清洗器 - 转换为小写
class LowercaseConverter extends AbstractDataCleaner {
    @Override
    protected void performCleaning(DataCleaningRequest request) {
        String cleaned = request.getData().toLowerCase();
        request.setData(cleaned);
        request.addStep("转换为小写");
        System.out.println("已转换为小写：" + cleaned);
    }
}

// 示例代码
public class NonPureChainDemo {
    public static void main(String[] args) {
        DataCleaner whitespaceRemover = new WhitespaceRemover();
        DataCleaner lowercaseConverter = new LowercaseConverter();

        whitespaceRemover.setNext(lowercaseConverter);

        String raw = "  MIXED CASE DATA   ";
        DataCleaningRequest request = new DataCleaningRequest(raw);

        System.out.println("原始数据：" + raw);
        whitespaceRemover.clean(request);

        System.out.println("\n最终结果：" + request.getData());
        System.out.println("执行步骤：" + request.getSteps());
    }
}

标签: Java DesignPatterns ResponsibilityChain

返回列表

上一篇：Linux 设备树详解：从基础到实践

下一篇：高效C++编程指南：lambda捕获机制与内存安全实践

Linux crontab 详解

1) crontab 是什么cron 是 Linux 的定时任务守护进程；crontab 是用来编辑/查看“按时间周期执行命令”的表（cron table）。常见两类：用户 crontab：每个用户一份（crontab -e 编辑）系统级 crontab / cron.d：可指定执行用户（/etc/crontab、/etc/cron.d/*）2) crontab 时间...

富文本里可以允许的 HTML 属性

一、所有标签默认允许的安全属性（极少）class （可选）id （通常建议禁用）title️ 注意：id 容易被滥用做锚点注入，很多系统直接禁用class 允许的话最好只允许固定前缀（如 editor-*）二、a 标签允许属性<a href="" t...

方法一：通过官网安装包（最简单，适合初学者）如果你只是想快速安装并开始使用，这是最直接的方法。访问 Node.js 官网。页面会显示两个版本：LTS (Recommended For Most Users)：长期支持版，最稳定。建议选这个。Current：最新特性版，包含最新功能但可能不够稳定。下载 .pkg 安装包并运行。按照安装向导点击“下一步”即可完成。方法二：使用 Homebrew 安装（...

Dom\HTML_NO_DEFAULT_NS 的副作用：自动加闭合标签

在使用Dom\HTMLDocument时，Dom\HTML_NO_DEFAULT_NS 将禁止在解析过程中设置元素的命名空间, 此设置是为了与DOMDocument向后兼容而存在的。当使用它时，已知的一个副作用就是：自动加闭合标签例如 </img> 为什么会这样？当你使用：Dom\HTML_NO_DEFAULT_NS文档会变成无命名空间模式，此时内部更接近 XML...

Laravel 事件和监听器创建

在 Laravel 中，使用 Artisan 命令创建 Events（事件）和 Listeners（监听器）是非常高效的。你可以通过以下几种方式来实现：1. 手动创建单个 Event如果你只想创建一个事件类，可以使用 make:event 命令：Bashphp artisan make:event UserRegistered执行后，文件将生成在 app/Even...

自定义域名解析神器 dnsmasq

什么是 dnsmasq？dnsmasq 是一个轻量级、功能强大的网络服务工具，专为小型和中等规模网络设计。它是一个综合的网络基础设施解决方案[1]。dnsmasq 能做什么？功能说明应用场景DNS 转发与缓存将 DNS 查询转发到上游服务器（ISP、Google DNS 等），并在本地缓存结果加快 DNS 查询速度，减少外部 DNS 流量本地 DNS解析本地网络设备的主机名，无需编辑&n...

老程序员博客

责任链模式的多种实现方式

1. 链式基础实现

2. 使用集合的实现方式

3. 函数式接口实现

4. 带排序的集合实现

纯责任链与非纯责任链的区别

纯责任链模式

非纯责任链模式

相关文章

Linux crontab 详解

富文本里可以允许的 HTML 属性

Mac 安装 Node.js 指南

Dom\HTML_NO_DEFAULT_NS 的副作用：自动加闭合标签

Laravel 事件和监听器创建

自定义域名解析神器 dnsmasq

发表评论

Copyright © agingcoder.cn

Powered By Z-BlogPHP. Theme by TOYEAN.

老程序员博客

责任链模式的多种实现方式

1. 链式基础实现

2. 使用集合的实现方式

3. 函数式接口实现

4. 带排序的集合实现

纯责任链与非纯责任链的区别

纯责任链模式

非纯责任链模式

相关文章

Linux crontab 详解

富文本里可以允许的 HTML 属性

Mac 安装 Node.js 指南

Dom\HTML_NO_DEFAULT_NS 的副作用：自动加闭合标签

Laravel 事件和监听器创建

自定义域名解析神器 dnsmasq

发表评论取消回复

Copyright © agingcoder.cn

Powered By Z-BlogPHP. Theme by TOYEAN.

发表评论