【灵动之链】打造高效处理架构的双轨组合模式实战

一只

发布于 2024-06-13 10:33:04

770

发布于 2024-06-13 10:33:04

文章被收录于专栏：用户10693341的专栏用户10693341的专栏

文章目录

打造高效处理架构的双轨组合模式实战
- 目标概述
- 场景一：注解驱动的Chain
- - 设计说明
- 场景二：工作流调度 - List与Set注入的Chain
- - 设计说明
- 总结

打造高效处理架构的双轨组合模式实战

目标概述

本教程旨在阐述两种不同的组合模式实现方式，重点在于如何构建灵活的处理链，以适应不同场景下的需求，如单据处理与工作流调度。我们将基于提供的设计思路，重新定义类名并实施脱敏处理，以保护具体业务逻辑细节。

场景一：注解驱动的Chain

设计说明

核心接口：SingleDocumentHandler（普通处理器接口）与 SingleDocumentHandlerChain（链式处理器接口）。
注解：自定义注解如@DocumentHandler用于标记处理器类及其处理的类型。
实现方式：利用注解扫描与反射机制自动构建处理器链，通过类名或注解中的键值匹配来决定处理器的执行。

// 自定义注解，用于标记处理器
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface DocumentHandler {
    String key(); // 类型的唯一标识
}

// 普通处理器接口
public interface SingleDocumentHandler {
    void handle(DocumentContext context);
}

// 链式处理器基类，实现了普通处理器接口
public abstract class AbstractDocumentHandlerChain implements SingleDocumentHandler {
    private SingleDocumentHandler next; // 下一个处理器引用

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

    // ...其他辅助方法
}

// 示例处理器实现
@DocumentHandler(key = "ORDER_PROCESS")
public class OrderProcessingHandler extends AbstractDocumentHandlerChain {
    @Override
    public void handle(DocumentContext context) {
        // 处理逻辑
        if (next != null) {
            next.handle(context);
        }
    }
}

场景二：工作流调度 - List与Set注入的Chain

设计说明

核心接口：WorkflowTaskDispatcher（任务分发接口）与 WorkflowTaskResolver（任务解析器接口）。
实现方式：WorkflowDispatcherChain仅实现WorkflowTaskDispatcher，包含一个List<WorkflowTaskResolver>成员，通过构造函数或setter注入解析器集合。解析器直接实现WorkflowTaskResolver，无需实现WorkflowTaskDispatcher。

// 任务分发接口
public interface WorkflowTaskDispatcher {
    void dispatch(TaskContext task);
}

// 任务解析器接口
public interface WorkflowTaskResolver {
    boolean canResolve(TaskContext task);
    void resolve(TaskContext task);
}

// 链式调度器实现
public class WorkflowDispatcherChain implements WorkflowTaskDispatcher {
    private final List<WorkflowTaskResolver> resolvers;

    public WorkflowDispatcherChain(List<WorkflowTaskResolver> resolvers) {
        this.resolvers = resolvers;
    }

    @Override
    public void dispatch(TaskContext task) {
        for (WorkflowTaskResolver resolver : resolvers) {
            if (resolver.canResolve(task)) {
                resolver.resolve(task);
                return;
            }
        }
        // 如果没有找到合适的解析器，则...处理逻辑
    }
}

// 示例解析器
public class ApprovalTaskResolver implements WorkflowTaskResolver {
    @Override
    public boolean canResolve(TaskContext task) {
        // 判断逻辑
        return task.getType().equals("APPROVAL");
    }

    @Override
    public void resolve(TaskContext task) {
        // 解析与处理逻辑
    }
}