设计模式 - 责任链模式

最新推荐文章于 2025-12-11 22:46:37 发布

原创最新推荐文章于 2025-12-11 22:46:37 发布 · 169 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #设计模式

设计模式专栏收录该内容

14 篇文章

订阅专栏

一、基本介绍

概念：使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关

系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止
模式类型：结构型
设计原则：开闭原则

二、实现

需求：

父系社会，女人逛街在不同阶段需向不同的男人申请

1、一般实现

Ⅰ、代码

// 女人接口
public interface IWomen {
    // 获取个人情况
    int getType();
    // 获取需要请求的事情，逛街、约会？
    String getRequest();
}
// 具体女人实现
public class Women implements IWomen {

    /**
     * 通过一个int类型的参数来描述妇女的个人状况
     * 1--未出嫁
     * 2--出嫁
     * 3--夫死
     */
    private int type;

    private String request;

    public Women(int type,String request) {
        this.type = type;
        this.request = request;
    }

    @Override
    public int getType() {
        return this.type;
    }

    @Override
    public String getRequest() {
        return this.request;
    }
}

// 处理者接口
public interface IHandler {

    // 一个女性（女儿、妻子或者母亲）要求逛街，你要处理这个请求
    void handlerMessage(IWomen iWomen);
}

// 未出嫁时父亲处理
public class Father implements IHandler {

    @Override
    public void handlerMessage(IWomen iWomen) {
        System.out.println("女儿的请示" + iWomen.getRequest());
        System.out.println("父亲答应");
    }
}

// 出嫁后丈夫处理
public class Husband implements IHandler {

    @Override
    public void handlerMessage(IWomen iWomen) {
        System.out.println("妻子的请示" + iWomen.getRequest());
        System.out.println("丈夫答应");
    }
}

// 丈夫死后儿子处理
public class Son implements IHandler {

    @Override
    public void handlerMessage(IWomen iWomen) {
        System.out.println("母亲的请示" + iWomen.getRequest());
        System.out.println("儿子答应");
    }
}

// 具体处理场景
public class Client {
    public static void main(String[] args) {
        Random random = new Random();
        List<IWomen> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            list.add(new Women(random.nextInt(4), "我要出去逛街"));
        }
        IHandler father = new Father();
        IHandler husband = new Husband();
        IHandler son = new Son();
        for (IWomen iWomen : list) {
            if (iWomen.getType() == 1) {
                father.handlerMessage(iWomen);
            } else if (iWomen.getType() == 2) {
                husband.handlerMessage(iWomen);
            } else if (iWomen.getType() == 3) {
                son.handlerMessage(iWomen);
            } else {

            }
        }
    }
}

Ⅱ、优点

Ⅲ、缺点

职责界定不清晰：原本应该是父亲这个类做的事情抛给了Client类中进行组装进行处理
代码臃肿：随着能处理该类型的请示人员越多，if…else的判断就越多
耦合过重：要根据Women的type来决定使用IHandler的那个实现类来处理请求，IHandler类的实现扩展就需要更改Client，不符合开闭原则

2、模式

Women类及接口不变

Ⅰ、代码

抽象处理者

public abstract class AbsHandler {
    // 声明所有处理者的处理级别
    protected static final int FATHER_LEVEL_REQUEST = 1;
    protected static final int HUSBAND_level_REQUEST = 2;
    protected static final int SON_LEVEL_REQUEST = 3;
    
    private int level;
    private AbsHandler nextHandler;

    // 具体实现强制初始化级别
    public AbsHandler(int level) {
        this.level = level;
    }

    // 设置下一个处理链
    public void setNextHandler(AbsHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    // 具体处理者的具体处理逻辑
    protected abstract void response(IWomen iWomen);

    // 处理链从头到尾遍历，该自己处理则需要处理，处理不了就传递给下一个处理者
    public final void handlerMessage(IWomen iWomen) {
        if (iWomen.getType() == this.level) {
            this.response(iWomen);
        } else {
            if (this.nextHandler != null) {
                this.nextHandler.handlerMessage(iWomen);
            } else {
                System.out.println("没有可处理的链了");
            }
        }
    }
}

具体处理者

// 具体处理者1
public class Father extends AbsHandler {

    public Father() {
        super(AbsHandler.FATHER_LEVEL_REQUEST);
    }

    @Override
    protected void response(IWomen iWomen) {
        System.out.println("--------女儿向父亲请示-------");
        System.out.println(iWomen.getRequest());
        System.out.println("父亲的答复是:同意\n");
    }
}
// 具体处理者2
public class Husband extends AbsHandler {

    public Husband() {
        super(AbsHandler.HUSBAND_level_REQUEST);
    }

    @Override
    protected void response(IWomen iWomen) {
        System.out.println("--------妻子向丈夫请示-------");
        System.out.println(iWomen.getRequest());
        System.out.println("丈夫的答复是：同意\n");
    }
}

// 具体处理者3
public class Son extends AbsHandler {

    public Son() {
        super(AbsHandler.SON_LEVEL_REQUEST);
    }

    @Override
    protected void response(IWomen iWomen) {
        System.out.println("--------母亲向儿子请示-------");
        System.out.println(iWomen.getRequest());
        System.out.println("儿子的答复是：同意\n");
    }
}

场景类

public class Client {
    public static void main(String[] args) {
        Random random = new Random();
        List<IWomen> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            list.add(new Women(random.nextInt(4), "我要出去逛街"));
        }
        
        // 也可以将所有的处理者及编排顺序再次进行封装，只返回第一个处理者
        AbsHandler father = new Father();
        AbsHandler husband = new Husband();
        AbsHandler son = new Son();

        father.setNextHandler(husband);
        husband.setNextHandler(son);
        for (IWomen iWomen : list) {
            father.handlerMessage(iWomen);
        }
    }
}