责任链设计模式（Chain of Responsibility）

发表于 | 更新于: | 分类于 | | 阅读次数:
字数统计: 1.6k | 阅读时长 ≈ 7

定义

为了避免请求发送者和多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链，当有请求发生时，可以沿着这条链传递，直到有对象处理它为止；

责任链设计模式主要包含以下角色：

抽象处理者（Handler）角色：定义一个处理的接口，包含抽象处理方法和后继的连接；

具体处理者（Concrete Handler）角色：实现抽象处理者的处理方法，判断是否处理本次请求，如果可以处理请求则处理，否则将该请求转给它的后继者；

客户类（Client）角色：创建处理链，并向链头的具体处理者对象提交请求，它关心处理细节和请求的过程；

特点

优点

  • 降低了请求发送者和请求处理者之间的耦合度。该模式使得请求发送者无须知道是哪一个对象处理其请求以及链的结构，发送者和接受者也无须拥有对方的明确信息；
  • 增强了系统的可扩展性。可以根据需求随时增加新的请求处理类，满足开闭原则；
  • 增强了给对象指派职责的灵活性。当工作流程发生变化时，可以动态地改变链内的成员或者它们的次序，也可以动态的新增和删除链内的成员；
  • 简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用，不需要保持其他所有处理者的引用，也避免使用众多的if或者if…else语句；
  • 责任分担明确，每个处理者专注于做自己的事情。每个处理者只需要处理自己该处理的工作，不该处理的传递给下一个处理者完成，明确各个类的职责范围，符合类的单一职责原则；

缺点

  • 不能保证每一个请求一定被处理。由于一个请求没有明确的接受者，所以不能保证它一定被处理，该请求可能一直传到链的末端都得不到处理；
  • 对于比较长的责任链，请求的处理可能涉及多个处理对象，系统性能将受到一定的影响；
  • 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能由于职责链的错误设置导致系统出错，如造成循环使用；

实现

基础类

1
2
3
4
5
6
7
8
9
10
11
12
13
@Data
@AllArgsConstructor
public class Request {

    /**
     * 绑定通知渠道（微信、短信）
     */
    private ChannelTypeEnum channel;
    /**
     * 具体消息
     */
    private String message;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@Data
public class Response {

    /**
     * 响应结果
     */
    private boolean success;
    /**
     * 结果编码
     */
    private Integer code;
    /**
     * 提示信息
     */
    private Integer msg;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Getter
@AllArgsConstructor
public enum ChannelTypeEnum {
    /**
     * 渠道类型
     */
    WE_CHAT(1, "微信"),
    SMS(2, "短信"),
    OTHER(3, "第三方平台");

    private Integer id;
    private String desc;

    ChannelTypeEnum(Integer id, String desc) {
        this.id = id;
        this.desc = desc;
    }
}

实现方式一

责任链设计模式v1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public abstract class BaseMessageHandler {
    /**
     * 下一个执行者
     */
    protected BaseMessageHandler nextMessageHandler;
    public BaseMessageHandler(BaseMessageHandler nextMessageHandler) {
        this.nextMessageHandler = nextMessageHandler;
    }
    public void doHandle(Request request, Response response) {
        handle(request, response);
        if (response.isSuccess()) {
            return;
        }
        if (nextMessageHandler != null) {
            nextMessageHandler.doHandle(request, response);
        }
    }
    /**
     * 实际操作
     *
     * @param request  request
     * @param response response
     */
    protected abstract void handle(Request request, Response response);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class WeChatMessageHandler extends BaseMessageHandler {

    public WeChatMessageHandler(BaseMessageHandler nextMessageHandler) {
        super(nextMessageHandler);
    }

    @Override
    protected void handle(Request request, Response response) {
        if (ChannelTypeEnum.WE_CHAT.equals(request.getChannel())) {
            System.out.println(request.getChannel().getDesc() + "：" + request.getMessage());
            response.setSuccess(true);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class SmsMessageHandler extends BaseMessageHandler {

    public SmsMessageHandler(BaseMessageHandler nextMessageHandler) {
        super(nextMessageHandler);
    }

    @Override
    protected void handle(Request request, Response response) {
        if (ChannelTypeEnum.SMS.equals(request.getChannel())) {
            System.out.println(request.getChannel().getDesc() + "：" + request.getMessage());
            response.setSuccess(true);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class OtherMessageHandler extends BaseMessageHandler {

    public OtherMessageHandler(BaseMessageHandler nextMessageHandler) {
        super(nextMessageHandler);
    }

    @Override
    protected void handle(Request request, Response response) {
        if (ChannelTypeEnum.OTHER.equals(request.getChannel())) {
            System.out.println(request.getChannel().getDesc() + "：" + request.getMessage());
            response.setSuccess(true);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Client {

    private BaseMessageHandler buildHandlerChain() {
        OtherMessageHandler otherMessageHandler = new OtherMessageHandler(null);
        SmsMessageHandler smsMessageHandler = new SmsMessageHandler(otherMessageHandler);
        WeChatMessageHandler weChatMessageHandler = new WeChatMessageHandler(smsMessageHandler);
        return weChatMessageHandler;
    }

    public static void main(String[] args) {
        Client client = new Client();
        BaseMessageHandler baseMessageHandler = client.buildHandlerChain();
        Request request = new Request(ChannelTypeEnum.WE_CHAT, "有内鬼，交易取消");
        Response response = new Response();
        baseMessageHandler.doHandle(request, response);
    }
}

实现方式二

责任链设计模式v2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class MessageChain implements IChain<Request, Response> {

    private List<IMessageHandler> messageHandlerList = new ArrayList<>();
    // 这里也可以用index下标实现，保存当前位置，我觉得用iterator实现更优雅
    private Iterator<IMessageHandler> iterator;

    public void addMessageHandler(IMessageHandler messageHandler) {
        messageHandlerList.add(messageHandler);
    }

    @Override
    public void doHandle(Request request, Response response) {
        if (null == iterator) {
            iterator = messageHandlerList.iterator();
        }

        if (iterator.hasNext()) {
            IMessageHandler messageHandler = iterator.next();
            messageHandler.handle(request, response, this);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
public interface IMessageHandler {

    /**
     * 数据实际处理
     *
     * @param request      request
     * @param response     response
     * @param messageChain messageChain
     */
    void handle(Request request, Response response, MessageChain messageChain);
}
1
2
3
4
5
6
7
8
9
10
11
12
public class WeChatMessageHandler implements IMessageHandler {

    @Override
    public void handle(Request request, Response response, MessageChain messageChain) {
        if (ChannelTypeEnum.WE_CHAT.equals(request.getChannel())) {
            System.out.println(request.getChannel().getDesc() + "：" + request.getMessage());
            response.setSuccess(true);
        }

        messageChain.doHandle(request, response);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
public class SmsMessageHandler implements IMessageHandler {

    @Override
    public void handle(Request request, Response response, MessageChain messageChain) {

        if (ChannelTypeEnum.SMS.equals(request.getChannel())) {
            System.out.println(request.getChannel().getDesc() + "：" + request.getMessage());
            response.setSuccess(true);
        }

        messageChain.doHandle(request, response);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
public class OtherMessageHandler implements IMessageHandler {

    @Override
    public void handle(Request request, Response response, MessageChain messageChain) {
        if (ChannelTypeEnum.OTHER.equals(request.getChannel())) {
            System.out.println(request.getChannel().getDesc() + "：" + request.getMessage());
            response.setSuccess(true);
        }

        messageChain.doHandle(request, response);
    }
}

源码分析

责任链设计模式源码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
private static class VirtualFilterChain implements FilterChain {

    private final FilterChain originalChain;

    private final List<? extends Filter> additionalFilters;

    private int currentPosition = 0;

    public VirtualFilterChain(FilterChain chain, List<? extends Filter> additionalFilters) {
        this.originalChain = chain;
        this.additionalFilters = additionalFilters;
    }

    // 使用index下标实现
    @Override
    public void doFilter(final ServletRequest request, final ServletResponse response)
            throws IOException, ServletException {

        if (this.currentPosition == this.additionalFilters.size()) {
            this.originalChain.doFilter(request, response);
        }
        else {
            this.currentPosition++;
            Filter nextFilter = this.additionalFilters.get(this.currentPosition - 1);
            nextFilter.doFilter(request, response, this);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
public class MockFilterChain implements FilterChain {
    @Nullable
    private ServletRequest request;
    @Nullable
    private ServletResponse response;
    private final List<Filter> filters;
    @Nullable
    private Iterator<Filter> iterator;

    public MockFilterChain() {
        this.filters = Collections.emptyList();
    }

    public MockFilterChain(Servlet servlet) {
        this.filters = initFilterList(servlet);
    }

    public MockFilterChain(Servlet servlet, Filter... filters) {
        Assert.notNull(filters, "filters cannot be null");
        Assert.noNullElements(filters, "filters cannot contain null values");
        this.filters = initFilterList(servlet, filters);
    }

    private static List<Filter> initFilterList(Servlet servlet, Filter... filters) {
        Filter[] allFilters = (Filter[]) ObjectUtils.addObjectToArray(filters, new MockFilterChain.ServletFilterProxy(servlet));
        return Arrays.asList(allFilters);
    }

    @Nullable
    public ServletRequest getRequest() {
        return this.request;
    }

    @Nullable
    public ServletResponse getResponse() {
        return this.response;
    }

    // 使用 iterator实现
    public void doFilter(ServletRequest request, ServletResponse response) throws IOException, ServletException {
        Assert.notNull(request, "Request must not be null");
        Assert.notNull(response, "Response must not be null");
        Assert.state(this.request == null, "This FilterChain has already been called!");
        if (this.iterator == null) {
            this.iterator = this.filters.iterator();
        }

        if (this.iterator.hasNext()) {
            Filter nextFilter = (Filter) this.iterator.next();
            nextFilter.doFilter(request, response, this);
        }

        this.request = request;
        this.response = response;
    }
}
<-------------The End------------->
坚持原创分享，您的支持就是我最大的动力！