责任链模式与spring容器的搭配应用

news/2024/5/19 12:28:03 标签: 责任链模式, spring, java

背景

有个需求，原先只涉及到一种A情况设备的筛选，每次筛选会经过多个流程，比如先a功能，a功能通过再筛选b功能，然后再筛选c功能，以此类推。现在新增了另外一种B情况的筛选，B情况同样需要A情况的筛选流程，并且需要在A情况的基础上，新增另外的功能筛选，这里假设A需要a、b、c功能的筛选，而B需要a、b、c、d功能的筛选，并且这些功能的筛选的顺序可能发生变动，比如新增了某个筛选，这个筛选涉及到的计算量少那肯定可以把这个置在前面先处理，不满足条件就return，咋一看，这个需求很符合责任链模式的应用场景，下面介绍编码。这里的代码参考了 马丁玩编程 在其12306项目里面的责任链模式，并做出一些相应改动，以适配当前的场景。

代码

责任链模式顶层接口

这里继承了Ordered类，是为了方便后续对处理器进行排序。

public interface AbstractChainHandler<REQUEST> extends Ordered {

    default boolean handler(REQUEST requestParam){

        return true;
    };
    
}

A情况的接口和B情况的接口。

public interface DeviceTypeAChainFilter extends AbstractChainHandler<DeviceFilterBO> {

}

public interface DeviceTypeBChainFilter extends AbstractChainHandler<DeviceFilterBO> {

}

定义成接口，后续往里面添加处理器的时候，方便查看当前A规则和B规则都有哪些处理器：

image-20240206171639069

具体的处理器

处理器1：

@Component
public class DeviceFunctionChainHandler implements DeviceTypeAChainFilter, DeviceTypeBChainFilter {

    @Override
    public boolean handler(DeviceFilterBO deviceFilterBO) {
        if (deviceFilterBO.getDeviceBO().getCondition() % 2 == 0) {
            System.out.println("处理器A：筛选功能不通过");
            return false;
        }
        // 筛选功能
        System.out.println("处理器A：筛选功能通过");
        return true;
    }

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

处理器2：

@Component
public class DeviceResolutionChainHandler implements DeviceTypeAChainFilter, DeviceTypeBChainFilter {

    @Override
    public boolean handler(DeviceFilterBO deviceFilterBO) {
        // 分辨率支持
        System.out.println("处理器B：分辨率支持");
        return true;
    }

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

}

处理器3：

@Component
public class DeviceCaculateOutputChainHandler implements DeviceTypeBChainFilter {

    @Override
    public boolean handler(DeviceFilterBO deviceFilterBO) {
        // 接口支持
        System.out.println("处理器C：输出接口支持");
        // 计算设备数量满足要求
        System.out.println("处理器C：根据输出接口计算的设备数量满足要求");
        return true;
    }

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

处理器4：

@Component
public class DeviceCaculateInputChainHandler implements DeviceTypeAChainFilter, DeviceTypeBChainFilter {

    @Override
    public boolean handler(DeviceFilterBO deviceFilterBO) {
        if (deviceFilterBO.getDeviceBO().getCondition() % deviceFilterBO.getCondition() == 0) {
            System.out.println("处理器D：输入接口不支持");
            return false;
        }
        ArrayList<DeviceBO> deviceRes = (ArrayList<DeviceBO>) AbstractChainContext.threadLocal.get();
        deviceRes.add(deviceFilterBO.getDeviceBO());
        // 接口支持
        System.out.println("处理器D：输入接口支持");
        // 计算设备数量满足要求
        System.out.println("处理器D：根据输入接口计算的设备数量满足要求");
        return true;
    }

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

可以看到，处理器都用@Component进行标识，后续通过ioc容器获取这些处理器进行分类和执行。并且，可以看到A..filter接口有三个实现者，这说明A有三种处理器，同理B有四种处理器，并且由于顶层接口继承了Order类，所有具体的处理器都会标识当前的order，如上面的10，20，30...这里把Order的数字间隔放大一些，比如10，20，30，如果以后要往这些间隔插入新的处理逻辑也方便。

获取具体处理器和执行hanlder的上下文类

先将不同的处理规则的接口都放在某个特定包下

image-20240206172405349

先去扫描这个包下的所有接口，然后再去Spring Ioc容器里面拿出这些接口的实现类，把不同的接口实现类按接口名字作为标识，按Order对这些实现类进行排序，然后放到一个List里面，以接口名字作为key，实现类List作为value，后续调用链式调用的时候，传入具体的接口名字（处理规则名字），实现链式顺序调用，具体实现如下

AbstractChainContext上下文类：

public final class AbstractChainContext<REQUEST, RESPONSE> implements CommandLineRunner {

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

    public final static ThreadLocal threadLocal = new ThreadLocal<>();

    public void handler(String mark, REQUEST requestParam) {
        List<AbstractChainHandler> abstractChainHandlers = abstractChainHandlerContainer.get(mark);
        if (CollectionUtils.isEmpty(abstractChainHandlers)) {
            throw new RuntimeException(String.format("[%s] Chain of Responsibility ID is undefined.", mark));
        }
        for (AbstractChainHandler abstractChainHandler : abstractChainHandlers) {
            if(!abstractChainHandler.handler(requestParam)){
                break;
            }
        }
    }


    @Override
    public void run(String... args) {
        List<Class<?>> interfaces = getInterfacesInPackage("com.zh.demo.designpattern.chain.type");
        for (Class<?> interfaceType : interfaces) {
            Map<String, AbstractChainHandler> beansOfType = (Map<String, AbstractChainHandler>) ApplicationContextHolder.getBeansOfType(interfaceType);
            // 转成list
            List<AbstractChainHandler> sortedList = beansOfType.values().stream()
                    .sorted(Comparator.comparing(Ordered::getOrder))
                    .collect(Collectors.toList());
            int index = interfaceType.getName().lastIndexOf(".") + 1;
            abstractChainHandlerContainer.put(interfaceType.getName().substring(index), sortedList);
        }
    }

    public static List<Class<?>> getInterfacesInPackage(String packageName) {
        List<Class<?>> result = new ArrayList<>();
        try {
            ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
            String path = packageName.replace('.', '/');
            Enumeration<URL> resources = classLoader.getResources(path);

            while (resources.hasMoreElements()) {
                URL resource = resources.nextElement();
                File directory = new File(resource.getFile());
                File[] files = directory.listFiles();

                if (files != null) {
                    for (File file : files) {
                        if (file.getName().endsWith(".class")) {
                            String className = packageName + '.' + file.getName().replace(".class", "");
                            Class<?> clazz = Class.forName(className);

                            if (clazz.isInterface()) {
                                result.add(clazz);
                            }
                        }
                    }
                }
            }
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }

        return result;
    }
}

在上面变量中，用了个 public final static ThreadLocal threadLocal = new ThreadLocal<>(); 这个是用来保存设备的筛选列表。

定义好不同筛选规则的枚举类：

public enum DeviceChainMarkEnum {

    /**
     * A设备过滤器
     */
    DEVICE_TYPEA_FILTER("DeviceTypeAChainFilter"),

    /**
     * B设备过滤器
     */
    DEVICE_TYPEB_FILTER("DeviceTypeBChainFilter");

    String name;

    public String getName() {
        return name;
    }

    DeviceChainMarkEnum(String name) {
        this.name = name;
    }

}

Service的编写

@Service
@RequiredArgsConstructor
@Slf4j
public class DemoServiceImpl implements DemoService {

    private final AbstractChainContext<DeviceFilterBO, Object> devcieTypeChainContext;

    @Override
    public List<DeviceBO> filterDeviceTypeA(ParmDTO parmDTO) {
        ArrayList<DeviceBO> deviceList = new ArrayList<>();
        // 简化条件
        parmDTO.setCondition(2);
        // 实际情况应该是从数据库读取设备的信息
        for (int i = 0; i < 5; i++) {
            DeviceBO deviceDTO = DeviceBO.builder().condition(new Random().nextInt(100)).build();
            deviceList.add(deviceDTO);
        }
        ArrayList<DeviceBO> deviceRes = new ArrayList<>();
       // 把需要的结果放到threadLocal中,在具体的处理器中对结果List进行处理
        AbstractChainContext.threadLocal.set(deviceRes);
        // 筛选多个设备 对符合的设备加入到deviceRes
        for (DeviceBO deviceBo : deviceList) {
            DeviceFilterBO deviceFilterBO = DeviceFilterBO.builder().condition(parmDTO.getCondition()).deviceBO(deviceBo).build();
            // 以A规则进行处理
            devcieTypeChainContext.handler(DeviceChainMarkEnum.DEVICE_TYPEA_FILTER.getName(), deviceFilterBO);
        }
        AbstractChainContext.threadLocal.remove();
        System.out.println("筛选结果数量：" + deviceRes.size());
        return deviceRes;
    }

    @Override
    public List<DeviceBO> filterDeviceTypeB(ParmDTO parmDTO) {
        ArrayList<DeviceBO> deviceList = new ArrayList<>();
        // 简化条件
        parmDTO.setCondition(2);
        // 实际情况应该是从数据库读取设备的信息
        for (int i = 0; i < 5; i++) {
            DeviceBO deviceDTO = DeviceBO.builder().condition(new Random().nextInt(100)).build();
            deviceList.add(deviceDTO);
        }
        ArrayList<DeviceBO> deviceRes = new ArrayList<>();
        // 把需要的结果放到threadLocal中,在具体的处理器中对结果List进行处理
        AbstractChainContext.threadLocal.set(deviceRes);
        // 筛选多个设备 对符合的设备加入到deviceRes
        for (DeviceBO deviceBo : deviceList) {
            DeviceFilterBO deviceFilterBO = DeviceFilterBO.builder().condition(parmDTO.getCondition()).deviceBO(deviceBo).build();
            // 以B规则进行处理
            devcieTypeChainContext.handler(DeviceChainMarkEnum.DEVICE_TYPEB_FILTER.getName(), deviceFilterBO);
        }
        AbstractChainContext.threadLocal.remove();
        System.out.println("筛选结果数量：" + deviceRes.size());
        return deviceRes;
    }

}

这里假设有五种设备，每个设备通过DeviceBO里面的condition设置条件，演示一遍筛选过程

DeviceBO类：

@Builder
@Data
public class DeviceBO {

    private int condition;

}

演示筛选规则A，一共五个设备数据，只有一个筛选通过了，这里涉及到A,B,D三种处理器

image-20240222103239661

演示筛选规则B，一共五个设备数据，2个筛选通过了，这里涉及到A,B,C,D三种处理器

image-20240222103338406

文章转载自：John-zh

原文链接：https://www.cnblogs.com/Johnyzh/p/18026938

体验地址：引迈 - JNPF快速开发平台_低代码开发平台_零代码开发平台_流程设计器_表单引擎_工作流引擎_软件架构


http://www.niftyadmin.cn/n/5389306.html

相关文章

数据结构之平衡二叉搜索树

数据结构之平衡二叉搜索树

什么是平衡二叉树 AVL是一种自平衡二叉搜索树&#xff08;self-balancing binary search tree&#xff09;的数据结构&#xff0c;它的名称来源于其发明者G.M. Adelson-Velsky和E.M. Landis。AVL树通过在每次插入或删除节点时进行旋转操作&#xff0c;来确保树的高度始终保持在…
阅读更多...
C#中用ffmpeg截取视频使用要点

C#中用ffmpeg截取视频使用要点

一、代码 string inputFile "E:\\Test\\1\\5.mp4"; string outputFile "E:\\Test\\1\\10.mp4"; int startTime 5; // 开始时间&#xff08;秒&#xff09; int endtime 10; // 结束时间&#xff08;秒&#xff09;Process p new Process(); p.StartI…
阅读更多...
对Redis锁延期的一些讨论与思考

对Redis锁延期的一些讨论与思考

上一篇文章提到使用针对不同的业务场景如何合理使用Redis分布式锁&#xff0c;并引入了一个新的问题 若定义锁的过期时间是10s&#xff0c;此时A线程获取了锁然后执行业务代码&#xff0c;但是业务代码消耗时间花费了15s。这就会导致A线程还没有执行完业务代码&#xff0c;A线程…
阅读更多...
【kubernetes】二进制部署k8s集群之，多master节点负载均衡以及高可用（下）

【kubernetes】二进制部署k8s集群之，多master节点负载均衡以及高可用（下）

↑↑↑↑接上一篇继续部署↑↑↑↑ 之前已经完成了单master节点的部署&#xff0c;现在需要完成多master节点以及实现k8s集群的高可用 一、完成master02节点的初始化操作 二、在master01节点基础上&#xff0c;完成master02节点部署 步骤一&#xff1a;准备好master节点所需…
阅读更多...
SpringCloud(16)之SpringCloud OpenFeign和Ribbon

SpringCloud(16)之SpringCloud OpenFeign和Ribbon

一、Spring Cloud OpenFeign介绍 Feign [feɪn] 译文 伪装。Feign是一个轻量级的Http封装工具对象,大大简化了Http请求,它的使用方法 是定义一个接口&#xff0c;然后在上面添加注解。不需要拼接URL、参数等操作。项目主页&#xff1a;GitHub - OpenFeign/feign: Feign makes w…
阅读更多...
JavaScript 设计模式之策略模式

JavaScript 设计模式之策略模式

策略模式 结构上看&#xff0c;它与状态模式很像&#xff0c;也是在内部封装一个对象&#xff0c;然后通过返回的接口对象实现对内部对象的调用&#xff0c;不同点是&#xff0c;策略模式不需要管理状态、状态间没有依赖关系、策略之间可以相互替换、在策略对象内部保存的是相…
阅读更多...
ROS1 下载与运行Github上的ROS demo

ROS1 下载与运行Github上的ROS demo

目录 1 创建工作空间2 下载Github包到本地方法1：git方法2：下载3 编译准备3.1 安装依赖3.2 编译4 配置环境方法1：工作空间的.bash文件方法2：系统.bashrc文件5 运行ROS程序5.1 打开roscore终端5.2 执行程序1 创建工作空间 选择项目存放路径，创建工作空间，存放GitHub下
阅读更多...
使用Docker中部署GitLab 避坑指南

使用Docker中部署GitLab 避坑指南

在容器化的世界中&#xff0c;Docker已经成为了我们部署和管理应用程序的首选工具。然而&#xff0c;在使用Docker部署GitLab时&#xff0c;我们可能会遇到一些问题&#xff0c;本文将为你提供一份详细的避坑指南。网上的教程有的都没说清楚&#xff0c;或者干脆是错的。摸索了…
阅读更多...
最新文章

Copyright @ 2022~2023