本文共 5910 字，大约阅读时间需要 19 分钟。

职责链模式是软件设计中一种常用的部件协作模式。它的主要思想是通过将处理单元按链状结构连接起来，使任何一个单元都可以处理请求，从而避免了处理单元之间直接耦合的麻烦。这种模式被广泛应用于面对多样化请求的系统中，能够有效提升系统的灵活性和可扩展性。

职责链模式示例分析

在以下示例中，我们将定义一系列具体的处理器类，分别针对不同的请求范围进行处理。这些处理器类通过链式的方式连接起来，从而形成一个完整的处理链路。

public abstract class Handler {
    protected Handler successor;
    
    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }
    
    public abstract void handleRequest(int request);
}
// 具体处理器类 1：处理 0-10 的请求
class ConcreteHandlerA extends Handler {
    @Override
    public void handleRequest(int request) {
        if (request >= 0 && request <= 10) {
            System.out.println("ConcreteHandlerA 处理了请求: " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}
// 具体处理器类 2：处理 11-20 的请求
class ConcreteHandlerB extends Handler {
    @override
    public void handleRequest(int request) {
        if (request > 10 && request <= 20) {
            System.out.println("ConcreteHandlerB 处理了请求: " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}
// 具体处理器类 3：处理 21-30 的请求
class ConcreteHandlerC extends Handler {
    @override
    public void handleRequest(int request) {
        if (request > 20 && request <= 30) {
            System.out.println("ConcreteHandlerC 处理了请求: " + request);
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}
// 客户端主要逻辑
public class Client {
    public static void main(String[] args) {
        Handler handlerA = new ConcreteHandlerA();
        Handler handlerB = new ConcreteHandlerB();
        Handler handlerC = new ConcreteHandlerC();
        
        handlerA.setSuccessor(handlerB);
        handlerB.setSuccessor(handlerC);
        
        int[] requests = {2, 14, 5, 6, 8, 23, 12, 21};
        
        for (int request : requests) {
            handlerA.handleRequest(request);
        }
    }
}

在这个示例中，我们通过设置处理器之间的链条来将一个请求沿着链路传递，直到有一个处理器能够完全处理它。这种方式不仅提升了系统的灵活性，还避免了处理器之间的紧耦合。

请假请求的权限管理

在实际应用中，职责链模式常常用于权限管理场景。以下是一个化简的请假申请权限管理案例：

// 抽象管理者类
public abstract class Manager {
    protected String name;
    protected Manager superior;
    
    public Manager(String name) {
        this.name = name;
    }
    
    public void setSuperior(Manager superior) {
        this.superior = superior;
    }
    
    public abstract void requestApplications(Request request);
}
// 总监类：审批数量 <= 2 的请假
public class Majordomo extends Manager {
    public Majordomo(String name) {
        super(name);
    }
    
    @override
    public void requestApplications(Request request) {
        if (request.getRequestType() == "请假" && request.getNumber() <= 2) {
            System.out.println(name + ": " + request.getRequestContent() + " 数量" + request.getNumber() + " 被批准");
        } else {
            if (superior != null) {
                superior.requestApplications(request);
            }
        }
    }
}
// 总经理类：审批数量不限的请假
public class GeneralManager extends Manager {
    public GeneralManager(String name) {
        super(name);
    }
    
    @override
    public void requestApplications(Request request) {
        if (request.getRequestType() == "请假") {
            System.out.println(name + ": " + request.getRequestContent() + " 数量" + request.getNumber() + " 被批准");
        }
    }
}
// 经理类：审批数量 <= 5 的请假
public class CommonManager extends Manager {
    public CommonManager(String name) {
        super(name);
    }
    
    @override
    public void requestApplications(Request request) {
        if (request.getRequestType() == "请假" && request.getNumber() <= 2) {
            System.out.println(name + ": " + request.getRequestContent() + " 数量" + request.getNumber() + " 被批准");
        } else {
            if (superior != null) {
                superior.requestApplications(request);
            }
        }
    }
}
// 出具请假请求类
public class Request {
    private String requestType;
    private String requestContent;
    private int number;
    
    public String getRequestType() {
        return requestType;
    }
    public void setRequestType(String requestType) {
        this.requestType = requestType;
    }
    
    public String getRequestContent() {
        return requestContent;
    }
    public void setRequestContent(String requestContent) {
        this.requestContent = requestContent;
    }
    
    public int getNumber() {
        return number;
    }
    public void setNumber(int number) {
        this.number = number;
    }
}
// 客户端
public class Client {
    public static void main(String[] args) {
        CommonManager commonManager = new CommonManager("经理");
        Majordomo majordomo = new Majordomo("总监");
        GeneralManager generalManager = new GeneralManager("总经理");
        commonManager.setSuperior(majordomo);
        majordomo.setSuperior(generalManager);
        
        Request request = new Request();
        request.setRequestType("请假");
        request.setRequestContent("小菜请假");
        request.setNumber(1);
        commonManager.requestApplications(request);
        
        Request request2 = new Request();
        request2.setRequestType("请假");
        request2.setRequestContent("小菜请假");
        request2.setNumber(4);
        commonManager.requestApplications(request2);
        
        Request request3 = new Request();
        request3.setRequestType("加薪");
        request3.setRequestContent("小菜请求加薪");
        request3.setNumber(500);
        commonManager.requestApplications(request3);
        
        Request request4 = new Request();
        request4.setRequestType("加薪");
        request4.setRequestContent("小菜请求加薪");
        request4.setNumber(1000);
        commonManager.requestApplications(request4);
    }
}

在这个案例中，我们通过职责分离的方式构建了一个完整的权限管理链。但是如果单个员工的请假数量超过权限上限，就会自动传递给上级审批。这保证了权限分级管理的灵活性，同时有效防止了权限力度过大。

总结

职责链模式通过在处理器之间建立灵活的依赖关系，使系统能够以降低耦合度的方式响应需求变化。在实际应用中，这种模式通过将任务分配给最佳适配的处理器，显著提升了系统的可维护性和处理能力。