【Java】【设计模式】抽象责任链模式

创建一个责任链上下文容器，用于存储与责任链相应的子任务

@Component
public class AbstractChainContext<T> implements CommandLineRunner {

    private final Map<String, List<AbstractChainHandler>> abstractChainHandlerContainer = new HashMap<>();

    @Override
    public void run(String... args) throws Exception {
        // 通过 Spring 上下文容器，获取所有Bean
        Map<String, AbstractChainHandler> chainFilterMap = SpringUtil
                .getBeansOfType(AbstractChainHandler.class);
        System.out.println("map = " + chainFilterMap);
        chainFilterMap.forEach((beanName, bean) -> {
            List<AbstractChainHandler> abstractChainHandlers = abstractChainHandlerContainer.get(bean.mark());
            if (CollectionUtils.isEmpty(abstractChainHandlers)) {
                abstractChainHandlers = new ArrayList();
            }
            // 将对应 Bean 放入责任链上下文容器中
            abstractChainHandlers.add(bean);
            // 此处根据 Ordered 实际值进行排序处理
            List<AbstractChainHandler> actualAbstractChainHandlers = abstractChainHandlers.stream()
                    .sorted(Comparator.comparing(Ordered::getOrder))
                    .collect(Collectors.toList());
            abstractChainHandlerContainer.put(bean.mark(), actualAbstractChainHandlers);
        });
        System.out.println("mapList = " + abstractChainHandlerContainer);
    }

    /**
     * 责任链组件执行
     *
     * @param requestParam 请求参数
     */
    public void handler(String mark, T requestParam) {
        List<AbstractChainHandler> abstractChainHandlers = abstractChainHandlerContainer.get(mark);
        if (CollectionUtils.isEmpty(abstractChainHandlers)) {
            throw new RuntimeException(String.format("[%s] Chain of Responsibility ID is undefined.", mark));
        }
        abstractChainHandlers.forEach(each -> each.handler(requestParam));
    }
}

责任链组件标识

public enum ChainEnum {
    ONE,
    TWO,
    THREE
}

实现 AbstractChainHandler接口作为责任链处理器，每个具体的实现类负责执行特定的逻辑。

public interface AbstractChainHandler<T> extends Ordered {
    /**
     * 执行责任链逻辑
     *
     * @param requestParam 责任链执行入参
     */
    void handler(T requestParam);

    /**
     * @return 责任链组件标识
     */
    String mark();
}

实现类1

public interface OneChainFilter<T> extends AbstractChainHandler<T> {
    @Override
    default String mark() {
        return ChainEnum.ONE.name();
    }
}

@Component
public class OneChainHandler1 implements OneChainFilter<String>{
    @Override
    public void handler(String requestParam) {
        System.out.println("--OneChainHandler1:" + requestParam + "，执行顺序order：" + getOrder());
    }

    @Override
    public int getOrder() {
        return 0;
    }
}

@Component
public class OneChainHandler2 implements OneChainFilter<String>{
    @Override
    public void handler(String requestParam) {
        System.out.println("--OneChainHandler2:" + requestParam + "，执行顺序order：" + getOrder());
    }

    @Override
    public int getOrder() {
        return 1;
    }
}

实现类2

public interface TwoChainFilter<T> extends AbstractChainHandler<T> {
    @Override
    default String mark() {
        return ChainEnum.TWO.name();
    }
}

@Component
public class TwoChainHandler1 implements TwoChainFilter<String> {
    @Override
    public void handler(String requestParam) {
        System.out.println("--TwoChainHandler1:" + requestParam + "，执行顺序order：" + getOrder());
    }

    @Override
    public int getOrder() {
        return 10;
    }
}

@Component
public class TwoChainHandler2 implements TwoChainFilter<String> {
    @Override
    public void handler(String requestParam) {
        System.out.println("--TwoChainHandler2:" + requestParam + "，执行顺序order：" + getOrder());
    }

    @Override
    public int getOrder() {
        return 11;
    }
}

实现类3

public interface ThreeChainFilter<T> extends AbstractChainHandler<T> {
    @Override
    default String mark() {
        return ChainEnum.THREE.name();
    }
}

@Component
public class ThreeChainHandler1 implements ThreeChainFilter<String> {
    @Override
    public void handler(String requestParam) {
        System.out.println("--ThreeChainHandler1:" + requestParam + "，执行顺序order：" + getOrder());
    }

    @Override
    public int getOrder() {
        return 20;
    }
}

@Component
public class ThreeChainHandler2 implements ThreeChainFilter<String> {
    @Override
    public void handler(String requestParam) {
        System.out.println("--ThreeChainHandler2:" + requestParam + "，执行顺序order：" + getOrder());
    }

    @Override
    public int getOrder() {
        return 21;
    }
}

测试

    @Autowired
    private AbstractChainContext abstractChainContext;
    
    @RequestMapping(value = "/chain", method = RequestMethod.GET)
    public Result chain() {
        abstractChainContext.handler(ChainEnum.ONE.name(), "test chain one");
        abstractChainContext.handler(ChainEnum.TWO.name(), "test chain two");
        abstractChainContext.handler(ChainEnum.THREE.name(), "test chain three");
        return Result.success("test chain");
    }

GET http://localhost:8080/test/chain
//输出
--OneChainHandler1:test chain one，执行顺序order：0
--OneChainHandler2:test chain one，执行顺序order：1
--TwoChainHandler1:test chain two，执行顺序order：10
--TwoChainHandler2:test chain two，执行顺序order：11
--ThreeChainHandler1:test chain three，执行顺序order：20
--ThreeChainHandler2:test chain three，执行顺序order：21