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

王老邪

已于 2022-09-20 10:33:40 修改

阅读量1.5k

点赞数 2

分类专栏：设计工具文章标签： java 设计模式开发语言

于 2022-08-05 11:52:00 首次发布

本文链接：https://blog.csdn.net/rothchil/article/details/126174982

版权

设计工具专栏收录该内容

14 篇文章 0 订阅

订阅专栏

20220804223608

1. 背景

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

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

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

2. 概念

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

20220804224244

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

2.1. 使用场景

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

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

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

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

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

2.2. 优缺点

2.2.1. 优点

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

2.2.2. 缺点

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

3. 模式结构

3.1. 对象定义

3.1.1. Handler抽象处理者

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

3.1.2. ConcreteHandler

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

3.1.3. Client

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

20220804231106

3.2. 传统样例

3.2.1. 抽象处理


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

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

    public abstract int handler();
}

3.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;
    }
}

3.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();
    }

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

3.3. 进阶实现

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

20220805114312

3.3.1. 定义处理器实体


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

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

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

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

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

3.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;
    }
}

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

3.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;
    }
}

3.3.4. 抽象处理者


public abstract class AbstractFilterHandler {

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

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

    public abstract int handler();
}

3.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;
    }
}

3.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;
    }
}

3.3.7. 客户端


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