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

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

2022-09-20 144
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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设计模式责任
王老邪
目录
相关文章
进步`于辰
|
2月前
|
设计模式 Java 程序员
[Java]23种设计模式
本文介绍了设计模式的概念及其七大原则，强调了设计模式在提高代码重用性、可读性、可扩展性和可靠性方面的作用。文章还简要概述了23种设计模式，并提供了进一步学习的资源链接。
进步`于辰
48 0
[Java]23种设计模式
大数据文摘
|
26天前
|
设计模式 JavaScript Java
Java设计模式：建造者模式详解
建造者模式是一种创建型设计模式，通过将复杂对象的构建过程与表示分离，使得相同的构建过程可以创建不同的表示。本文详细介绍了建造者模式的原理、背景、应用场景及实际Demo，帮助读者更好地理解和应用这一模式。
大数据文摘
31 0
全干程序员demo
|
2月前
|
设计模式 监控 算法
Java设计模式梳理：行为型模式（策略，观察者等）
本文详细介绍了Java设计模式中的行为型模式，包括策略模式、观察者模式、责任链模式、模板方法模式和状态模式。通过具体示例代码，深入浅出地讲解了每种模式的应用场景与实现方式。例如，策略模式通过定义一系列算法让客户端在运行时选择所需算法；观察者模式则让多个观察者对象同时监听某一个主题对象，实现松耦合的消息传递机制。此外，还探讨了这些模式与实际开发中的联系，帮助读者更好地理解和应用设计模式，提升代码质量。
全干程序员demo
72 0
Java设计模式梳理：行为型模式（策略，观察者等）
艾利克斯冰
|
3月前
|
存储 设计模式 安全
Java设计模式-备忘录模式（23）
Java设计模式-备忘录模式（23）
艾利克斯冰
44 3
艾利克斯冰
|
3月前
|
设计模式 存储 缓存
Java设计模式 - 解释器模式（24）
Java设计模式 - 解释器模式（24）
艾利克斯冰
36 1
木子0204
|
2月前
|
设计模式 Java
Java设计模式
Java设计模式
木子0204
32 0
baker_zhuang
|
2月前
|
设计模式 Java
Java设计模式之外观模式
这篇文章详细解释了Java设计模式之外观模式的原理及其应用场景，并通过具体代码示例展示了如何通过外观模式简化子系统的使用。
baker_zhuang
32 0
baker_zhuang
|
2月前
|
设计模式 Java
Java设计模式之桥接模式
这篇文章介绍了Java设计模式中的桥接模式，包括桥接模式的目的、实现方式，并通过具体代码示例展示了如何分离抽象与实现，使得两者可以独立变化。
baker_zhuang
46 0
baker_zhuang
|
2月前
|
设计模式 Java
Java设计模式之适配器模式
这篇文章详细讲解了Java设计模式中的适配器模式，包括其应用场景、实现方式及代码示例。
baker_zhuang
51 0
艾利克斯冰
|
3月前
|
设计模式 缓存 算法
Java设计模式-访问者模式(22)
Java设计模式-访问者模式(22)
艾利克斯冰
32 0

热门文章

最新文章

  • 1
    3、Python与设计模式--建造者模式
  • 2
    极速理解设计模式系列：4.原型模式(Prototype Pattern)
  • 3
    设计模式[11]-Visitor
  • 4
    深入浅出单实例Singleton设计模式
  • 5
    云计算设计模式（十九）——运行重构模式
  • 6
    学习设计模式之单例模式
  • 7
    设计模式最佳套路4 —— 愉快地使用模板模式
  • 8
    MapReduce设计模式学习
  • 9
    [浪子学编程][MS Enterprise Library]ObjectBuilder之设计模式(一)：策略模式
  • 10
    【设计模式】—— 模板方法Template
  • 1
    面试官：素有Java锁王称号的‘StampedLock’你知道吗？我：这什么鬼？
    99
  • 2
    Java的取余如何编写代码
    75
  • 3
    Java获取字符串最后一位
    574
  • 4
    Java一分钟之-Lambda表达式与函数式接口
    75
  • 5
    Java一分钟之-Java内部类与匿名类
    46
  • 6
    Java一分钟之-Java注解的理解与应用
    49
  • 7
    Java一分钟之-Java反射机制：动态操作类与对象
    79
  • 8
    Java一分钟之线程池：ExecutorService与Future
    146
  • 9
    深入理解Java并发编程：线程安全与性能优化
    47
  • 10
    Java中Lambda表达式的深入理解与应用
    48

    • 相关课程

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

    • 相关电子书

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

    • 相关实验场景

    更多
  • 阿里云平台上进行Java程序的编译与运行
  • 使用Java面向对象编写网络通信程序应用
  • 手动部署Java Web环境（Alibaba Cloud Linux 2）
  • 搭建Java Web开发环境（Anolis OS）
  • RocketMQ中使用Java客户端发送消息和消费的应用
  • 部署基于Dragonwell的Java运行环境
    • 下一篇
    阿里云无影云电脑免费试用，最长可试用3个月