责任链模式 - 技术栈

责任链模式是一种行为设计模式，允许你将请求沿着处理链传递，直到有一个处理者处理它为止。

责任链模式几种常见的实现方式

1. 基础实现方式（链表式）

java 复制代码

@Data
@AllArgsConstructor
@NoArgsConstructor
class Request {
    private String type;
    private String msg;
}

java 复制代码

// 处理者接口
interface Handler {
    // 指向下一个处理器
    void setNext(Handler handler);
    void handle(Request request);
}

// 抽象处理者
abstract class AbstractHandler implements Handler {
    private Handler next;
    
    @Override
    public void setNext(Handler handler) {
        this.next = handler;
    }
    
    @Override
    public void handle(Request request) {
        if (canHandle(request)) {
            process(request);
        } else if (next != null) {
            next.handle(request);
        } else {
            System.out.println("No handler found for request: " + request);
        }
    }
    
    protected abstract boolean canHandle(Request request);
    protected abstract void process(Request request);
}

// 具体处理者A
class ConcreteHandlerA extends AbstractHandler {
    @Override
    protected boolean canHandle(Request request) {
        return request.getType().equals("A");
    }
    
    @Override
    protected void process(Request request) {
        System.out.println("Handler A processing: " + request.getContent());
    }
}

// 具体处理者B
class ConcreteHandlerB extends AbstractHandler {
    @Override
    protected boolean canHandle(Request request) {
        return request.getType().equals("B");
    }
    
    @Override
    protected void process(Request request) {
        System.out.println("Handler B processing: " + request.getContent());
    }
}

// 请求类
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; }
}

// 使用示例
public class ChainOfResponsibilityDemo {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        
        handlerA.setNext(handlerB);
        
        Request request1 = new Request("A", "Request A");
        Request request2 = new Request("B", "Request B");
        Request request3 = new Request("C", "Request C");
        
        handlerA.handle(request1); // Handler A processing: Request A
        handlerA.handle(request2); // Handler B processing: Request B
        handlerA.handle(request3); // No handler found for request: Request C
    }
}

2. 使用集合的实现方式

java 复制代码

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

// 处理者接口
interface Handler {
    boolean handle(Request request);
}

// 处理链
class HandlerChain {
    private List<Handler> handlers = new ArrayList<>();
    
    public void addHandler(Handler handler) {
        handlers.add(handler);
    }
    
    public void handle(Request request) {
        for (Handler handler : handlers) {
            if (handler.handle(request)) {
                return; // 处理成功，终止传递
            }
        }
        System.out.println("No handler found for request: " + request);
    }
}

// 具体处理者A
class ConcreteHandlerA implements Handler {
    @Override
    public boolean handle(Request request) {
        if (request.getType().equals("A")) {
            System.out.println("Handler A processing: " + request.getContent());
            return true;
        }
        return false;
    }
}

// 具体处理者B
class ConcreteHandlerB implements Handler {
    @Override
    public boolean handle(Request request) {
        if (request.getType().equals("B")) {
            System.out.println("Handler B processing: " + request.getContent());
            return true;
        }
        return false;
    }
}

// 使用示例
public class CollectionChainDemo {
    public static void main(String[] args) {
        HandlerChain chain = new HandlerChain();
        chain.addHandler(new ConcreteHandlerA());
        chain.addHandler(new ConcreteHandlerB());
        
        Request request1 = new Request("A", "Request A");
        Request request2 = new Request("B", "Request B");
        Request request3 = new Request("C", "Request C");
        
        chain.handle(request1); // Handler A processing: Request A
        chain.handle(request2); // Handler B processing: Request B
        chain.handle(request3); // No handler found for request: Request C
    }
}

3. 使用函数式接口的实现方式

java 复制代码

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; }
    
    @Override
    public String toString() {
        return "Request{type='" + type + "', content='" + content + "'}";
    }
}

// 处理者函数接口
@FunctionalInterface
interface HandlerFunction extends Function<Request, Boolean> {
    // 可以添加默认方法或其他功能
}

// 函数式处理链
class FunctionalHandlerChain {
    private List<HandlerFunction> handlers;
    
    public FunctionalHandlerChain(HandlerFunction... handlers) {
        this.handlers = Arrays.asList(handlers);
    }
    
    public void handle(Request request) {
        for (HandlerFunction handler : handlers) {
            if (handler.apply(request)) {
                return; // 处理成功，终止传递
            }
        }
        System.out.println("No handler found for request: " + request);
    }
}

// 使用示例
public class FunctionalChainDemo {
    public static void main(String[] args) {
        // 创建处理者函数
        HandlerFunction handlerA = request -> {
            if ("A".equals(request.getType())) {
                System.out.println("Handler A processing: " + request.getContent());
                return true;
            }
            return false;
        };
        
        HandlerFunction handlerB = request -> {
            if ("B".equals(request.getType())) {
                System.out.println("Handler B processing: " + request.getContent());
                return true;
            }
            return false;
        };
        
        // 创建处理链
        FunctionalHandlerChain chain = new FunctionalHandlerChain(handlerA, handlerB);
        
        Request request1 = new Request("A", "Request A");
        Request request2 = new Request("B", "Request B");
        Request request3 = new Request("C", "Request C");
        
        chain.handle(request1); // Handler A processing: Request A
        chain.handle(request2); // Handler B processing: Request B
        chain.handle(request3); // No handler found for request: Request C
    }
}

4. 带排序的集合实现方式

java 复制代码

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

// 带优先级的处理者接口
interface OrderedHandler {
    int getOrder();
    boolean handle(Request request);
}

// 排序处理链
class OrderedHandlerChain {
    private List<OrderedHandler> handlers = new ArrayList<>();
    
    public void addHandler(OrderedHandler handler) {
        handlers.add(handler);
        // 按优先级排序
        handlers.sort(Comparator.comparingInt(OrderedHandler::getOrder));
    }
    
    public void handle(Request request) {
        for (OrderedHandler handler : handlers) {
            if (handler.handle(request)) {
                return; // 处理成功，终止传递
            }
        }
        System.out.println("No handler found for request: " + request);
    }
}

// 具体处理者（带优先级）
class PriorityHandlerA implements OrderedHandler {
    @Override
    public int getOrder() {
        return 1; // 高优先级
    }
    
    @Override
    public boolean handle(Request request) {
        if (request.getType().equals("A")) {
            System.out.println("Priority Handler A processing: " + request.getContent());
            return true;
        }
        return false;
    }
}

class PriorityHandlerB implements OrderedHandler {
    @Override
    public int getOrder() {
        return 2; // 低优先级
    }
    
    @Override
    public boolean handle(Request request) {
        if (request.getType().equals("B")) {
            System.out.println("Priority Handler B processing: " + request.getContent());
            return true;
        }
        return false;
    }
}

// 使用示例
public class OrderedChainDemo {
    public static void main(String[] args) {
        OrderedHandlerChain chain = new OrderedHandlerChain();
        chain.addHandler(new PriorityHandlerB()); // 先添加低优先级
        chain.addHandler(new PriorityHandlerA()); // 后添加高优先级
        
        Request request = new Request("A", "Request A");
        chain.handle(request); // Priority Handler A processing: Request A
    }
}

纯责任链模式与不纯的责任链模式

纯责任链模式：每个处理者要么处理请求，要么把请求传递给下一个处理者。比如我们上面写的四个例子都属于纯责任链模式。

不纯的责任链模式：每个处理者都可以处理请求，然后将请求传递给下一个处理者。比如servlet的过滤器，属于不纯的责任链模式。

本例使用链表式，表示不纯的责任链模式，注意和第一个案例进行对比。

java 复制代码

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

// 数据清洗请求
class DataCleaningRequest {
    private String rawData;
    private List<String> stepsPerformed = Arrays.asList("原始数据");
    
    public DataCleaningRequest(String rawData) {
        this.rawData = rawData;
    }
    
    public String getRawData() { return rawData; }
    public void setRawData(String data) { this.rawData = data; }
    public List<String> getStepsPerformed() { return stepsPerformed; }
    public void addStep(String step) { stepsPerformed.add(step); }
}

// 数据清洗处理器
interface DataCleaner {
    void setNextCleaner(DataCleaner cleaner);
    void cleanData(DataCleaningRequest request);
}

// 抽象数据清洗器
abstract class AbstractDataCleaner implements DataCleaner {
    protected DataCleaner nextCleaner;
    
    @Override
    public void setNextCleaner(DataCleaner cleaner) {
        this.nextCleaner = cleaner;
    }
    
    @Override
    public void cleanData(DataCleaningRequest request) {
        // 每个处理器都执行自己的清洗逻辑
        processData(request);
        
        // 传递给下一个处理器,注意和第一个案例的写法进行比较
        // 第一个案例根据处理结果判断是否需要执行下一个处理器,而本案例只要下一个处理器不为空，则执行下一个处理器
        if (nextCleaner != null) {
            nextCleaner.cleanData(request);
        }
    }
    
    protected abstract void processData(DataCleaningRequest request);
}

// 具体清洗器 - 去除空格
class WhitespaceCleaner extends AbstractDataCleaner {
    @Override
    protected void processData(DataCleaningRequest request) {
        String data = request.getRawData();
        data = data.trim().replaceAll("\\s+", " ");
        request.setRawData(data);
        request.addStep("去除空格");
        System.out.println("空格清理完成: " + data);
    }
}

// 具体清洗器 - 特殊字符处理
class SpecialCharCleaner extends AbstractDataCleaner {
    @Override
    protected void processData(DataCleaningRequest request) {
        String data = request.getRawData();
        data = data.replaceAll("[^a-zA-Z0-9\\s]", "");
        request.setRawData(data);
        request.addStep("去除特殊字符");
        System.out.println("特殊字符清理完成: " + data);
    }
}

// 具体清洗器 - 大小写规范化
class CaseNormalizer extends AbstractDataCleaner {
    @Override
    protected void processData(DataCleaningRequest request) {
        String data = request.getRawData();
        data = data.toLowerCase();
        request.setRawData(data);
        request.addStep("大小写规范化");
        System.out.println("大小写规范化完成: " + data);
    }
}

// 具体清洗器 - 重复词去除
class DuplicateWordCleaner extends AbstractDataCleaner {
    @Override
    protected void processData(DataCleaningRequest request) {
        String data = request.getRawData();
        String[] words = data.split("\\s+");
        StringBuilder result = new StringBuilder();
        String lastWord = "";
        
        for (String word : words) {
            if (!word.equals(lastWord)) {
                result.append(word).append(" ");
                lastWord = word;
            }
        }
        
        request.setRawData(result.toString().trim());
        request.addStep("去除重复词");
        System.out.println("重复词清理完成: " + result.toString().trim());
    }
}

// 使用示例
public class DataCleaningDemo {
    public static void main(String[] args) {
        // 构建清洗链
        DataCleaner whitespaceCleaner = new WhitespaceCleaner();
        DataCleaner specialCharCleaner = new SpecialCharCleaner();
        DataCleaner caseNormalizer = new CaseNormalizer();
        DataCleaner duplicateCleaner = new DuplicateWordCleaner();
        
        whitespaceCleaner.setNextCleaner(specialCharCleaner);
        specialCharCleaner.setNextCleaner(caseNormalizer);
        caseNormalizer.setNextCleaner(duplicateCleaner);
        
        // 测试数据清洗
        String rawData = "  Hello   WORLD!!  Hello  TEST  123  ";
        DataCleaningRequest request = new DataCleaningRequest(rawData);
        
        System.out.println("原始数据: '" + rawData + "'");
        System.out.println("开始数据清洗...");
        
        whitespaceCleaner.cleanData(request);
        
        System.out.println("\n最终结果: '" + request.getRawData() + "'");
        System.out.println("执行步骤: " + request.getStepsPerformed());
    }
}