大话设计模式读书笔记——职责链模式

头盔程序员

已于 2023-06-15 11:15:54 修改

阅读量89

点赞数

分类专栏：大话设计模式读书笔记文章标签：设计模式 java 前端

于 2023-06-15 11:13:08 首次发布

本文链接：https://blog.csdn.net/lizeheng/article/details/131220857

版权

大话设计模式读书笔记专栏收录该内容

23 篇文章 4 订阅

订阅专栏

1.需求

假如你想申请加工资，需要向上级部门申请。如你先向经理申请，经理没权利，然后向总监上报，总监也没权
限，最后向总经理上报。将这段场景用代码实现

2.代码版本1.0

2.1 申请类

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

2.2 管理者类

public class Manager {
    protected  String name;
    public Manager(String name){
        this.name = name;
    }

    public void getResult(String managerLevel,Request request){
        if (managerLevel=="经理"){
            if (request.getRequestType()=="请假"&&request.getNumber()<=2){
                System.out.println(this.name+":"+request.getRequestContent()+" 数量："+request.getNumber()+"天，被批准");
            }else{
                System.out.println(this.name+":"+request.getRequestContent()+" 数量："+request.getNumber()+"天，我无权处理");
            }
        }else if(managerLevel=="总监"){
            if (request.getRequestType()=="请假"&&request.getNumber()<=5){
                System.out.println(this.name+":"+request.getRequestContent()+" 数量："+request.getNumber()+"天，被批准");
            }else{
                System.out.println(this.name+":"+request.getRequestContent()+" 数量："+request.getNumber()+"天，我无权处理");
            }
        }else if(managerLevel=="总经理"){
            if (request.getRequestType()=="请假"){
                System.out.println(this.name+":"+request.getRequestContent()+" 数量："+request.getNumber()+"天，被批准");
            }else if(request.getRequestType()=="加薪"&&request.getNumber()<=5000){
                System.out.println(this.name+":"+request.getRequestContent()+" 数量："+request.getNumber()+"元，被批准");
            }else if(request.getRequestType()=="加薪"&&request.getNumber()>5000){
                System.out.println(this.name+":"+request.getRequestContent()+" 数量："+request.getNumber()+"元，再说吧");
            }
        }
    }
}

2.3 客户端代码

     Manager manager = new Manager("经理");
     Manager director = new Manager("总监");
     Manager generalManager = new Manager("总经理");

     Request request = new Request();
     request.setRequestType("加薪");
     request.setRequestContent("小菜请求加薪");
     request.setNumber(10000);

     manager.getResult("经理",request);
     director.getResult("总监",request);
     generalManager.getResult("总经理",request);

     Request request2 = new Request();
     request2.setRequestType("请假");
     request2.setRequestContent("小菜请假");
     request2.setNumber(3);

     manager.getResult("经理",request2);
     director.getResult("总监",request2);
     generalManager.getResult("总经理",request2);

2.4结果

经理:小菜请求加薪 数量：10000天，我无权处理
总监:小菜请求加薪 数量：10000天，我无权处理
总经理:小菜请求加薪 数量：10000元，再说吧
经理:小菜请假 数量：3天，我无权处理
总监:小菜请假 数量：3天，被批准
总经理:小菜请假 数量：3天，被批准

2.5 弊端

管理者类中太多判断分支
管理者类承担了太多的责任，违背了单一职责原则；增加新的管理类别，需要修
改这个类，违背了开放-封闭原则

3.职责链模式

3.1概念

职责链模式（Chain of Responsibility）：使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

3.2UML类图

在这里插入图片描述

3.3案例代码

3.3.1 Handler类

Handler类，定义一个处理请示的接口。

public abstract class Handler {
    protected Handler successor;

    //设置继任者
    public void setSuccessor(Handler successor){
        this.successor = successor;
    }

    public abstract void handleRequest(int request);
}

3.3.2 ConcreteHandler类

ConcreteHandler类，具体处理者类，处理它所负责的请求，可访问它的后继者，如果可处理该请求，就处理之，否则就将该请求转发给它的后继者。

public class ConcreteHandler1 extends Handler{
    @Override
    public void handleRequest(int request) {
        if (request>=0 && request<10){
            System.out.println(this.getClass().getSimpleName()+"处理请求"+request);
        }else if (successor!=null){
            successor.handleRequest(request);
        }
    }
}

public class ConcreteHandler2 extends Handler{
    @Override
    public void handleRequest(int request) {
        if (request>=10 && request<20){
            System.out.println(this.getClass().getSimpleName()+"处理请求"+request);
        }else if (successor!=null){
            successor.handleRequest(request);
        }
    }
}

public class ConcreteHandler3 extends Handler{
    @Override
    public void handleRequest(int request) {
        if (request>=20 && request<30){
            System.out.println(this.getClass().getSimpleName()+"处理请求"+request);
        }else if (successor!=null){
            successor.handleRequest(request);
        }
    }
}

3.3.3 客户端代码

     Handler h1 = new ConcreteHandler1();
     Handler h2 = new ConcreteHandler2();
     Handler h3 = new ConcreteHandler3();
     //设置继任者
     h1.setSuccessor(h2);
     h2.setSuccessor(h3);

     int[] requests = {2,5,14,22,18,3,27,20};
     for (int request : requests) {
         h1.handleRequest(request);
     }

3.4职责链模式好处

当客户提交一个请求时，请求是沿链传递直至有一个ConcreteHandler对象负责处理它，这就使得接收者和发送者都没有对方的明确信息，且链中的对象自己也并不知道链的结构。结果是职责链可简化对象的相互连接，它们仅需保持一个指向其后继者的引用，而不需保持它所有的候选接受者的引用。
随时地增加或修改处理一个请求的结构。增强了给对象指派职责的灵活性。

注意：，一个请求极有可能到了链的末端都得不到处理，或者因为没有正确配置而得不到处理。

4.代码版本2.0（职责链模式实现）

4.1UML类图

在这里插入图片描述

4.2 管理者抽象类和管理者子类

public abstract class Manager {
    protected String name;
    public Manager(String name){
        this.name = name;
    }

    //设置管理上级
    protected Manager superior;
    public void setSuperior(Manager superior){
        this.superior = superior;
    }

    //请求申请
    public abstract void requestApplications(Request request);
}

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(this.name+":"+request.getRequestContent()+" 数量："+request.getNumber()+"天，被批准");
        }else{
            if (this.superior!=null){
                this.superior.requestApplications(request);
            }
        }
    }
}

public class Director extends Manager{
    public Director(String name) {
        super(name);
    }

    @Override
    public void requestApplications(Request request) {
        if (request.getRequestType()=="请假"&& request.getNumber()<=5){
            System.out.println(this.name+":"+request.getRequestContent()+" 数量："+request.getNumber()+"天，被批准");
        }else{
            if (this.superior!=null){
                this.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(this.name+":"+request.getRequestContent()+" 数量："+request.getNumber()+"天，被批准");
        }else if(request.getRequestType()=="加薪"&&request.getNumber()<=5000){
            System.out.println(this.name+":"+request.getRequestContent()+" 数量："+request.getNumber()+"元，被批准");
        }else if(request.getRequestType()=="加薪"&&request.getNumber()>5000){
            System.out.println(this.name+":"+request.getRequestContent()+" 数量："+request.getNumber()+"元，再说吧");
        }
    }
}

4.3 客户端代码

        CommonManager manager = new CommonManager("经理");
        Director director = new Director("总监");
        GeneralManager generalManager = new GeneralManager("总经理");
        manager.setSuperior(director);
        director.setSuperior(generalManager);

        Request request1 = new Request();
        request1.setRequestType("请假");
        request1.setRequestContent("小菜请假");
        request1.setNumber(1);
        manager.requestApplications(request1);

        Request request2 = new Request();
        request2.setRequestType("请假");
        request2.setRequestContent("小菜请假");
        request2.setNumber(1);
        manager.requestApplications(request2);

        Request request3 = new Request();
        request3.setRequestType("加薪");
        request3.setRequestContent("小菜请求加薪");
        request3.setNumber(5000);
        manager.requestApplications(request3);

        Request request4 = new Request();
        request4.setRequestType("加薪");
        request4.setRequestContent("小菜请求加薪");
        request4.setNumber(10000);
        manager.requestApplications(request4);

4.4 结果

经理:小菜请假 数量：1天，被批准
经理:小菜请假 数量：1天，被批准
总经理:小菜请求加薪 数量：5000元，被批准
总经理:小菜请求加薪 数量：10000元，再说吧

头盔程序员

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
大话设计模式读书笔记——职责链模式

假如你想申请加工资，需要向上级部门申请。如你先向经理申请，经理没权利，然后向总监上报，总监也没权。注意：，一个请求极有可能到了链的末端都得不到处理，或者因为没有正确配置而得不到处理。将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。ConcreteHandler类，具体处理者类，处理它所负责的请求，，如果可处理该请求，就处理之，否则就将该请求转发给它的后继者。限，最后向总经理上报。将这段场景用代码实现。Handler类，定义一个处理请示的接口。
复制链接

扫一扫