AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

浅析Java设计模式【5】——责任链

2022-09-20 141
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Java 设计模式，责任链

1. 目录

20220804223608

2. 背景

近期我有个需求，需要实现类似流程功能。我们开发人员本身条件限制，他使用原始的数据库中间状态来实现，但是代码堆的非常多、上下文逻辑很混乱、BUG 多，没有达到预期设定的要求。

事后，我想了下，如果换做是我，我该怎么做？

分析此类业务的特点，流程，我想到了 责任链 。

3. 概念

责任链模式（Chain of Responsibility）是设计模式的一种，属于 行为型设计模式 。

20220804224244

为请求创建了一个链，请求在链上被处理。通常某个处理器如果不能处理该请求，那么它会把相同的请求传给链上的下一个处理器。

3.1. 使用场景

如果一个请求需要经过多个处理步骤，将多个处理的步骤抽象成一条 执行链 ，那么便可以使用责任链模式。

责任链的使用场景一般有：

  • 向多处理器提交一个请求，最终运行时只会有一个处理器处理请求；
  • 向多处理器提交一个请求，所有处理器都会处理请求。

在现实中，我们很多场景都使用到了责任链模式。

  • RBAC 模型 ：多条件流程判断
  • ERP 系统流程审批：总经理、销售总监、产品部经理、项目组长
  • Java MVC 过滤器的底层实现 Filter

3.2. 优缺点

3.2.1. 优点

  • 降低耦合度。它将请求的发送者和接收者解耦
  • 简化了对象，使得对象不需要知道链的结构
  • 增强给对象指派职责的灵活性，允许动态地新增或者删除责任链
  • 增加新的请求处理类方便

3.2.2. 缺点

  • 不能保证请求一定被接收；
  • 系统性能将受到一定影响，调试时不方便，可能会造成循环调用

4. 模式结构

4.1. 对象定义

4.1.1. Handler抽象处理者

handler 定义处理请求的接口， handler 知道下一个处理者是谁，如果自己无法处理请求，就转给下一个处理者。

4.1.2. ConcreteHandler

具体的处理者是处理请求的具体角色

4.1.3. Client

请求者角色，就是向第一个具体的 handler 发送请求的角色，并连接好责任链。

20220804231106

4.2. 传统样例

4.2.1. 抽象处理


public abstract class AbstractHandler {
    /**
     * 定义下一用当前抽象类来接收
     */
    protected AbstractHandler next;

    public void setNext(AbstractHandler next) {
        this.next = next;
    }

    public abstract int handler();
}

4.2.2. 实际处理


@Slf4j
public class FirstPassHandler extends AbstractHandler{

    static final int FIRST_SCOPE = 70;

    @Override
    public int handler() {
        log.error("第一环节处理");
        int score = first();
        if(score>=FIRST_SCOPE){
            log.error("处理完毕，交由下一环节处理");
            if(this.next != null){
                return this.next.handler();
            }
        }else{
            log.error("处理不了，交由下一环节处理");
        }
        return score;
    }

    private int first(){
        return FIRST_SCOPE;
    }
}


@Slf4j
public class SecondPassHandler extends AbstractHandler{

    static final int SECOND_SCOPE = 80;

    @Override
    public int handler() {
        log.error("第二环节处理");
        int score = second();
        if(score>=SECOND_SCOPE){
            log.error("处理完毕，交由下一环节处理");
            if(this.next != null){
                return this.next.handler();
            }
        }else{
            log.error("处理不了，交由下一环节处理");
        }
        return score;
    }

    private int second(){
        return SECOND_SCOPE;
    }
}

@Slf4j
public class ThirdPassHandler extends AbstractHandler{

    static final int THIRD_SCOPE = 90;

    @Override
    public int handler() {
        log.error("第三环节处理");
        int score = third();
        if(score>=THIRD_SCOPE){
            log.error("处理完毕，交由下一环节处理");
            if(this.next != null){
                return this.next.handler();
            }
        }else{
            log.error("处理不了，交由下一环节处理");
        }
        return score;
    }

    private int third(){
        return THIRD_SCOPE;
    }
}

4.2.3. 客户端


    @DisplayName("责任链模式")
    @Test
    public void testChain() {
        FirstPassHandler firstPassHandler = new FirstPassHandler();
        SecondPassHandler secondPassHandler = new SecondPassHandler();
        ThirdPassHandler thirdPassHandler = new ThirdPassHandler();

        firstPassHandler.setNext(secondPassHandler);
        secondPassHandler.setNext(thirdPassHandler);

        firstPassHandler.handler();
    }

这种方式，有点不好，每次都需要 客户端 自己维护这样的关系，不是非常合理，而且很多时候人家客户端不想知道这个过程。

4.3. 进阶实现

在上述样例中，我们可以将关系维护到配置文件中或者一个枚举中。此处用枚举作为实现方式来演示如何动态的配置请求链并且将每个请求者形成一条调用链。

20220805114312

4.3.1. 定义处理器实体


@Data
@AllArgsConstructor
public class FilterEntity {
    /**
     * handlerId
     */
    private Integer handlerId;

    /**
     * 处理器名称
     */
    private String name;

    /**
     * 处理器 包名 + 类名
     */
    private String conference;

    /**
     * 上一个处理器
     */
    private Integer preHandlerId;

    /**
     * 下一个处理器
     */
    private Integer nextHandlerId;
}

4.3.2. 枚举


public enum FilterEnum {

    FIRST_HANDLER(new FilterEntity(1, "首要处理环节", FirstFilterHandler.class.getName(), null, 2)),
    SECOND_HANDLER(new FilterEntity(2, "二次处理环节", SecondFilterHandler.class.getName(), 1, 3)),
    THIRD_HANDLER(new FilterEntity(3, "三次处理环节", ThirdFilterHandler.class.getName(), 2, null));

    FilterEntity filterEntity;

    public FilterEntity getGameEntity() {
        return filterEntity;
    }

    FilterEnum(FilterEntity filterEntity) {
        this.filterEntity = filterEntity;
    }
}

这里将处理环节利用枚举，将前后依赖顺序进行定义。

4.3.3. 获取处理者


public interface FilterDao {
    /**
     * 根据 handlerId 获取配置项
     * @param handlerId
     * @return
     */
    FilterEntity getGameEntity(Integer handlerId);

    /**
     * 获取第一个处理者
     * @return
     */
    FilterEntity getFirstGameEntity();
}


public class FilterImpl implements FilterDao {

    /**
     * 初始化，将枚举中配置的handler初始化到map中，方便获取
     */
    private static Map<Integer, FilterEntity> gatewayEntityMap = new HashMap<>();

    static {
        FilterEnum[] values = FilterEnum.values();
        for (FilterEnum value : values) {
            FilterEntity gatewayEntity = value.getGameEntity();
            gatewayEntityMap.put(gatewayEntity.getHandlerId(), gatewayEntity);
        }
    }

    @Override
    public FilterEntity getGameEntity(Integer handlerId) {
        return gatewayEntityMap.get(handlerId);
    }

    @Override
    public FilterEntity getFirstGameEntity() {
        for (Map.Entry<Integer, FilterEntity> entry : gatewayEntityMap.entrySet()) {
            FilterEntity value = entry.getValue();
            //  没有上一个handler的就是第一个
            if (value.getPreHandlerId() == null) {
                return value;
            }
        }
        return null;
    }
}

4.3.4. 抽象处理者


public abstract class AbstractFilterHandler {

    /**
     * 定义下一用当前抽象类来接收
     */
    protected AbstractFilterHandler next;

    public void setNext(AbstractFilterHandler next) {
        this.next = next;
    }

    public abstract int handler();
}

4.3.5. 实际处理者


@Slf4j
public class FirstFilterHandler extends AbstractFilterHandler {

    static final int FIRST_SCOPE = 70;

    @Override
    public int handler() {
        log.error("第一环节处理");
        int score = first();
        if(score>=FIRST_SCOPE){
            log.error("处理完毕，交由下一环节处理");
            if(this.next != null){
                return this.next.handler();
            }
        }else{
            log.error("处理不了，交由下一环节处理");
        }
        return score;
    }

    private int first(){
        return FIRST_SCOPE;
    }
}

@Slf4j
public class SecondFilterHandler extends AbstractFilterHandler {

    static final int SECOND_SCOPE = 80;

    @Override
    public int handler() {
        log.error("第二环节处理");
        int score = second();
        if(score>=SECOND_SCOPE){
            log.error("处理完毕，交由下一环节处理");
            if(this.next != null){
                return this.next.handler();
            }
        }else{
            log.error("处理不了，交由下一环节处理");
        }
        return score;
    }

    private int second(){
        return SECOND_SCOPE;
    }
}

@Slf4j
public class ThirdFilterHandler extends AbstractFilterHandler {

    static final int THIRD_SCOPE = 90;

    @Override
    public int handler() {
        log.error("第三环节处理");
        int score = third();
        if(score>=THIRD_SCOPE){
            log.error("处理完毕，交由下一环节处理");
        }else{
            log.error("处理不了，交由下一环节处理");
            if(this.next != null){
                return this.next.handler();
            }
        }
        return score;
    }

    private int third(){
        return THIRD_SCOPE;
    }
}

4.3.6. 抽象工厂


@Slf4j
public class FilterHandlerEnumFactory {

    private static FilterDao filterDao = new FilterImpl();

    /**
     * 提供静态方法，获取第一个handler
     *
     * @return AbstractFilterHandler
     * @author <a href="https://github.com/rothschil">Sam</a>
     * @date 2022/8/4-23:50
     **/
    public static AbstractFilterHandler getFirstHandler() {

        FilterEntity firstGatewayEntity = filterDao.getFirstGameEntity();
        AbstractFilterHandler firstAbstractFilterHandler = newGatewayHandler(firstGatewayEntity);
        if (firstAbstractFilterHandler == null) {
            return null;
        }

        FilterEntity tempFilterEntity = firstGatewayEntity;
        Integer nextHandlerId = null;
        AbstractFilterHandler tempHandler = firstAbstractFilterHandler;
        // 迭代遍历所有handler，以及将它们链接起来
        while ((nextHandlerId = tempFilterEntity.getNextHandlerId()) != null) {
            FilterEntity filterEntity = filterDao.getGameEntity(nextHandlerId);
            AbstractFilterHandler abstractFilterHandler = newGatewayHandler(filterEntity);
            tempHandler.setNext(abstractFilterHandler);
            tempHandler = abstractFilterHandler;
            tempFilterEntity = filterEntity;
            log.warn("Init GatewayHandler", tempFilterEntity.getHandlerId());
        }
        // 返回第一个handler
        return firstAbstractFilterHandler;
    }

    /**
     * 反射实体化具体的处理者
     *
     * @param filterEntity
     * @return AbstractFilterHandler
     */
    private static AbstractFilterHandler newGatewayHandler(FilterEntity filterEntity) {
        try {
            String clazzName = filterEntity.getConference();
            log.error(clazzName);
            Class<?> clazz = Class.forName(clazzName);
            return (AbstractFilterHandler) clazz.newInstance();
        } catch (IllegalAccessException | InstantiationException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}

4.3.7. 客户端


    @DisplayName("责任链模式-工厂")
    @Test
    public void testChainFactory() {
        AbstractFilterHandler handler = FilterHandlerEnumFactory.getFirstHandler();
        handler.handler();
    }

4.3.8. 执行效果

20220805114818

4.3.9. 小结

通过枚举以及抽象工厂，我们将每个处理器连接起来，让客户端只关系自己的诉求部分，具体实现逻辑交由枚举来定义。这样做简化客户端的业务。相对来说比较友好，而且容易拓展。

文章标签：
Java
前端开发
数据库
设计模式
关键词：
Java设计模式
设计模式责任链
Java责任链
设计模式责任
Java设计模式责任
王老邪
目录
相关文章
进步`于辰
|
25天前
|
设计模式 Java 程序员
[Java]23种设计模式
本文介绍了设计模式的概念及其七大原则，强调了设计模式在提高代码重用性、可读性、可扩展性和可靠性方面的作用。文章还简要概述了23种设计模式，并提供了进一步学习的资源链接。
进步`于辰
41 0
[Java]23种设计模式
大数据文摘
|
9天前
|
设计模式 JavaScript Java
Java设计模式：建造者模式详解
建造者模式是一种创建型设计模式，通过将复杂对象的构建过程与表示分离，使得相同的构建过程可以创建不同的表示。本文详细介绍了建造者模式的原理、背景、应用场景及实际Demo，帮助读者更好地理解和应用这一模式。
大数据文摘
23 0
全干程序员demo
|
1月前
|
设计模式 监控 算法
Java设计模式梳理：行为型模式（策略，观察者等）
本文详细介绍了Java设计模式中的行为型模式，包括策略模式、观察者模式、责任链模式、模板方法模式和状态模式。通过具体示例代码，深入浅出地讲解了每种模式的应用场景与实现方式。例如，策略模式通过定义一系列算法让客户端在运行时选择所需算法；观察者模式则让多个观察者对象同时监听某一个主题对象，实现松耦合的消息传递机制。此外，还探讨了这些模式与实际开发中的联系，帮助读者更好地理解和应用设计模式，提升代码质量。
全干程序员demo
65 0
Java设计模式梳理：行为型模式（策略，观察者等）
艾利克斯冰
|
2月前
|
存储 设计模式 安全
Java设计模式-备忘录模式（23）
Java设计模式-备忘录模式（23）
艾利克斯冰
41 3
艾利克斯冰
|
2月前
|
设计模式 存储 缓存
Java设计模式 - 解释器模式（24）
Java设计模式 - 解释器模式（24）
艾利克斯冰
34 1
木子0204
|
1月前
|
设计模式 Java
Java设计模式
Java设计模式
木子0204
28 0
baker_zhuang
|
1月前
|
设计模式 Java
Java设计模式之外观模式
这篇文章详细解释了Java设计模式之外观模式的原理及其应用场景，并通过具体代码示例展示了如何通过外观模式简化子系统的使用。
baker_zhuang
29 0
baker_zhuang
|
1月前
|
设计模式 Java
Java设计模式之桥接模式
这篇文章介绍了Java设计模式中的桥接模式，包括桥接模式的目的、实现方式，并通过具体代码示例展示了如何分离抽象与实现，使得两者可以独立变化。
baker_zhuang
43 0
baker_zhuang
|
1月前
|
设计模式 Java
Java设计模式之适配器模式
这篇文章详细讲解了Java设计模式中的适配器模式，包括其应用场景、实现方式及代码示例。
baker_zhuang
44 0
艾利克斯冰
|
2月前
|
设计模式 缓存 算法
Java设计模式-访问者模式(22)
Java设计模式-访问者模式(22)
艾利克斯冰
27 0

热门文章

最新文章

  • 1
    3、Python与设计模式--建造者模式
  • 2
    设计模式--组合模式
  • 3
    设计模式（九）：Composite组合模式 -- 结构型模式
  • 4
    设计模式之美：Command（命令）
  • 5
    极速理解设计模式系列：4.原型模式(Prototype Pattern)
  • 6
    深入浅出单实例Singleton设计模式
  • 7
    设计模式[11]-Visitor
  • 8
    云计算设计模式（十九）——运行重构模式
  • 9
    [浪子学编程][MS Enterprise Library]ObjectBuilder之设计模式(一)：策略模式
  • 10
    学习设计模式之单例模式
  • 1
    前端和Java验签以太坊钱包签名实现中心化登录
    1021
  • 2
    零基础轻松入门Java数据库连接（JDBC）
    61
  • 3
    04｜零基础玩转面向对象编程：Java OOP
    33
  • 4
    03｜Java基础语法：讲解标识符、关键字、变量、数据类型、运算符、控制语句（条件分支、循环）
    38
  • 5
    探索Java世界的奇妙工具——运算符与表达式运算符
    30
  • 6
    深入浅出Java基础语法：标识符、关键字、变量、数据类型、运算符与控制语句
    31
  • 7
    Java一分钟之-Java IO流：文件读写基础
    115
  • 8
    轻松理解Java中的数据类型和变量
    24
  • 9
    Java一分钟之-Map接口与HashMap详解
    38
  • 10
    01｜Java简介与历史
    36

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    阿里云OSS设置跨域访问