> 三、责任链模式 - Yuyy
Yuyy
Yuyy
三、责任链模式

责任链模式

定义

在职责链模式中,多个处理器依次处理同一个请求。一个请求先经过 A 处理器处理,然后再把请求传递给 B 处理器,B 处理器处理完后再传递给 C 处理器,以此类推,形成一个链条。链条上的每个处理器各自承担各自的处理职责,所以叫作职责链模式。

在 GoF 的定义中,一旦某个处理器能处理这个请求,就不会继续将请求传递给后续的处理器了。当然,在实际的开发中,也存在对这个模式的变体,那就是请求不会中途终止传递,而是会被所有的处理器都处理一遍。

实现方式

链表

http://bed.yuyy.info/AbstractHandler.jpg

AbstractHandler

public abstract class AbstractHandler {

    private AbstractHandler nextHandler;

    public void setNextHandler(AbstractHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    public void handle() {
        boolean handled = doHandle();
        if (!handled && nextHandler != null) {
            nextHandler.handle();
        }
    }

    protected abstract boolean doHandle();
}

HandlerA

public class HandlerA extends AbstractHandler {
    @Override
    protected boolean doHandle() {
        boolean result = false;
        System.out.println("HandlerA");
        return result;
    }
}

HandlerB

public class HandlerB extends AbstractHandler {
    @Override
    protected boolean doHandle() {
        boolean result = false;
        System.out.println("HandlerB");
        return result;
    }
}

HandlerChain

public class HandlerChain {
    private AbstractHandler head;
    private AbstractHandler tail;

    public HandlerChain addHandler(AbstractHandler handler) {
        if (head == null) {
            head = handler;
            tail = handler;
        } else {
            tail.setNextHandler(handler);
            tail = handler;
        }
        return this;
    }

    public void handle() {
        if (head != null) {
            head.handle();
        }
    }
}

Application

public class Application {
    public static void main(String[] args) {
        final HandlerChain chain = new HandlerChain();
        chain.addHandler(new HandlerA())
             .addHandler(new HandlerB())
             .handle();
    }
}

数组

http://bed.yuyy.info/IHandler.jpg

IHandler

public interface IHandler {
    void handle();
}

HandlerA

public class HandlerA implements IHandler {
    @Override
    public void handle() {
        System.out.println("HandlerA");
    }
}

HandlerB

public class HandlerB implements IHandler {
    @Override
    public void handle() {
        System.out.println("HandlerB");
    }
}

HandlerChain

public class HandlerChain {
    private List<IHandler> chain = Lists.newArrayList();

    public HandlerChain addHandler(IHandler handler) {
        chain.add(handler);
        return this;
    }

    public void handle() {
        chain.forEach(IHandler::handle);
    }
}

Application

public class Application {
    public static void main(String[] args) {
        final HandlerChain chain = new HandlerChain();
        chain.addHandler(new HandlerA())
             .addHandler(new HandlerB())
             .handle();
    }
}

优缺点

  • 你可以控制请求处理的顺序。
  • 单一职责原则。 你可对发起操作和执行操作的类进行解耦。
  • 开闭原则。 你可以在不更改现有代码的情况下在程序中新增处理者。

适用场景

当程序需要使用不同方式处理不同种类请求, 而且请求类型和顺序预先未知时, 可以使用责任链模式。

该模式能将多个处理者连接成一条链。 接收到请求后, 它会 “询问” 每个处理者是否能够对其进行处理。 这样所有处理者都有机会来处理请求。

当必须按顺序执行多个处理者时, 可以使用该模式。

无论你以何种顺序将处理者连接成一条链, 所有请求都会严格按照顺序通过链上的处理者。

如果所需处理者及其顺序必须在运行时进行改变, 可以使用责任链模式。

如果在处理者类中有对引用成员变量的设定方法, 你将能动态地插入和移除处理者, 或者改变其顺序。

发表评论

textsms
account_circle
email

Yuyy

三、责任链模式
责任链模式 定义 在职责链模式中,多个处理器依次处理同一个请求。一个请求先经过 A 处理器处理,然后再把请求传递给 B 处理器,B 处理器处理完后再传递给 C 处理器,以此类推,形成一…
扫描二维码继续阅读
2021-08-18
友情链接
标签
归档
近期文章
分类
近期文章