设计模式-责任链模式案例

最新推荐文章于 2023-05-01 09:48:29 发布
最新推荐文章于 2023-05-01 09:48:29 发布
阅读量305 收藏 2
点赞数 1
分类专栏： 设计模式 文章标签： 大数据
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_33816292/article/details/125718102
版权

 一，用作车辆属性检查，车架号检查、车辆id检车、sku检查、场站检查、车辆sku检查

1.入口为定时任务触发，es车辆属性检查

package com.dst.common.job;

import com.dst.common.entitys.es.EsVehicleInfo;
import com.dst.common.util.checkEsData.AttributesCheckHandler;
import com.dst.common.util.checkEsData.CarIdCheckHandler;
import com.dst.common.util.checkEsData.CheckHandler;
import com.dst.common.util.checkEsData.SpuCodeCheckHandler;
import com.dst.common.util.checkEsData.StandardSkuCodeCheckHandler;
import com.dst.common.util.checkEsData.StationIdCheckHandler;
import com.dst.common.util.checkEsData.VinCodeCheckHandler;
import com.dst.modules.business.carinventory.service.IEsQueryService;
import com.dst.modules.business.vehicle.service.OperatingAttrManageService;
import com.dst.modules.business.vehicle.service.OperatingNewCarService;
import com.dst.modules.extend.GoodsAttributeServiceImpl;
import com.dstcar.common.utils.string.StringUtil;
import com.dstcar.entitys.goods.attributegroup.AttributeGroupAttrOut;
import com.dstcar.entitys.operating.newcar.OperatingNewCarBaseDTO;
import com.dstcar.entitys.operating.newcar.OperatingNewCarBaseWithAttrDTO;
import com.dstcar.entitys.operating.newcar.OperatingNewCarViewListQuery;
import com.dstcar.entitys.operating.vehicleattr.attr.VehicleAttrManageDTO;
import com.dstcar.entitys.operating.vehicleattr.attr.VehicleAttrManageQuery;
import com.github.pagehelper.PageInfo;
import com.xxl.job.core.biz.model.ReturnT;
import com.xxl.job.core.handler.IJobHandler;
import com.xxl.job.core.handler.annotation.JobHandler;
import com.xxl.job.core.log.XxlJobLogger;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import static java.util.stream.Collectors.toList;

/**
 * 定时任务检查数据库中的数据和es中的数据不一致
 *
 * @author liu wei ping
 * @version 1.0
 * @date 2022-06-30 11:27:29
 */
@JobHandler("carInfoMatchEsJob")
@Component
@Slf4j
public class CarInfoMatchEsJob extends IJobHandler {

    @Autowired
    private OperatingNewCarService operatingNewCarService;

    @Autowired
    private IEsQueryService esQueryService;

    @Autowired
    private GoodsAttributeServiceImpl goodsAttributeService;
    @Autowired
    private OperatingAttrManageService operatingAttrManageService;


    @Override
    public ReturnT<String> execute(String param) throws Exception {
        try {
            List<AttributeGroupAttrOut> configSkuAttrList = goodsAttributeService.getGroupAttrListByKey();
            List<String> configSkuAttrIdList =
                    configSkuAttrList.stream().map(AttributeGroupAttrOut::getAttrId).collect(toList());

            OperatingNewCarViewListQuery query = new OperatingNewCarViewListQuery();
            query.setPageSize(200);
            query.setPageNum(1);
            // 查在库库存
            query.setStationId(-1);
            PageInfo<OperatingNewCarBaseDTO> basicCarPageInfo =
                    operatingNewCarService.getOperatingNewCarBaseListPage(query);

            Set<String> vinCodes =
                    basicCarPageInfo.getList().stream().map(OperatingNewCarBaseDTO::getVinCode).collect(Collectors.toSet());

            // 只查车与sku定义相关的一些属性
            Map<String, List<VehicleAttrManageDTO>> vinAttrMap = getVinCodeAttrListMap(configSkuAttrIdList, vinCodes);
            List<EsVehicleInfo> esInfos = esQueryService.getEsVehicleInfoByVinCodes(new ArrayList<>(vinCodes), 0, 200);
            List<OperatingNewCarBaseWithAttrDTO> attrDTOList = getOperatingNewCarBaseWithAttrs(basicCarPageInfo,
                    vinAttrMap);

            // 比较结果(以数据库为准) ,比较carId,carNo,standardSkuCode,spuCode,stationId,attributes
            checkInfoWithEs(attrDTOList, esInfos);

            for (int j = 2; j <= basicCarPageInfo.getPages(); j++) {
                query.setPageNum(j);
                basicCarPageInfo = operatingNewCarService.getOperatingNewCarBaseListPage(query);
                vinCodes =
                        basicCarPageInfo.getList().stream().map(OperatingNewCarBaseDTO::getVinCode).collect(Collectors.toSet());
                esInfos = esQueryService.getEsVehicleInfoByVinCodes(new ArrayList<>(vinCodes),0,200);
                vinAttrMap = getVinCodeAttrListMap(configSkuAttrIdList, vinCodes);
                attrDTOList = getOperatingNewCarBaseWithAttrs(basicCarPageInfo, vinAttrMap);
                // 校验数据
                checkInfoWithEs(attrDTOList, esInfos);
                log.info("车辆SKU数据库数据与ES数据校验第 {} 页完成...", j);
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            return ReturnT.SUCCESS;
        } catch (Exception e) {
            XxlJobLogger.log("定时任务检查数据库中的数据和es中的数据不一致报错: " + e.getMessage());
        }
        return ReturnT.FAIL;

    }

    private List<OperatingNewCarBaseWithAttrDTO> getOperatingNewCarBaseWithAttrs(PageInfo<OperatingNewCarBaseDTO> basicCarPageInfo, Map<String, List<VehicleAttrManageDTO>> vinAttrMap) {
        List<OperatingNewCarBaseWithAttrDTO> attrDTOList =
                basicCarPageInfo.getList().stream().map(OperatingNewCarBaseDTO::toChild).collect(toList());
        attrDTOList.forEach(vo -> vo.setAttrs(vinAttrMap.get(vo.getVinCode())));
        return attrDTOList;
    }

    private Map<String, List<VehicleAttrManageDTO>> getVinCodeAttrListMap(List<String> configSkuAttrIdList,
                                                                          Set<String> vinCodes) {
        List<VehicleAttrManageDTO> skuAttrs =
                operatingAttrManageService.find(VehicleAttrManageQuery.builder()
                        .attrIds(configSkuAttrIdList)
                        .vinCodes(new ArrayList<>(vinCodes))
                        .build());
        return skuAttrs.stream().collect(Collectors.groupingBy(VehicleAttrManageDTO::getVinCode));
    }

    private void checkInfoWithEs(List<OperatingNewCarBaseWithAttrDTO> cars, List<EsVehicleInfo> esInfos) {
        if (CollectionUtils.isEmpty(cars)) {
            return;
        }
        CheckHandler.Builder<OperatingNewCarBaseWithAttrDTO> builder = new CheckHandler.Builder<>();
        builder.addHandler(new VinCodeCheckHandler())
                .addHandler(new CarIdCheckHandler())
                .addHandler(new StandardSkuCodeCheckHandler())
                .addHandler(new SpuCodeCheckHandler())
                .addHandler(new StationIdCheckHandler())
                .addHandler(new AttributesCheckHandler());
        StringBuilder stringBuilder;
        for (OperatingNewCarBaseWithAttrDTO baseDTO : cars) {
            stringBuilder = new StringBuilder();
            builder.build().doCheck(baseDTO, esInfos, stringBuilder);
            if(!StringUtil.isEmpty(stringBuilder.toString())){
                stringBuilder.insert(0,"vinCode["+baseDTO.getVinCode()+"]");
                log.error(stringBuilder.toString());
            }
        }
    }
}
package com.dst.common.util.checkEsData;

import com.dst.common.entitys.es.EsVehicleInfo;
import java.util.List;

/**
 * @author liu wei ping
 * @version 1.0
 * @date 2022-06-30 18:10:06
 */
public abstract class CheckHandler<T> {
    protected CheckHandler<T> next;

    private void next(CheckHandler<T> next) {
        this.next = next;
    }

    /**
     * 校验
     *
     * @param baseDTO       实体
     * @param esInfos       es中的数据
     * @param stringBuilder stringBuilder
     */
    public abstract void doCheck(T baseDTO, List<? extends EsVehicleInfo> esInfos,
                                 StringBuilder stringBuilder);

    public static class Builder<T> {
        private CheckHandler<T> head;
        private CheckHandler<T> tail;

        public Builder<T> addHandler(CheckHandler<T> handler) {
            if (this.head == null) {
                this.head = this.tail = handler;
                return this;
            }

            this.tail.next(handler);
            this.tail = handler;
            return this;
        }

        public CheckHandler<T> build() {
            return this.head;
        }
    }

}
package com.dst.common.util.checkEsData;

import com.dst.common.entitys.es.EsVehicleInfo;
import com.dstcar.entitys.operating.newcar.OperatingNewCarBaseWithAttrDTO;
import java.util.List;

import static java.util.stream.Collectors.toList;

/**
 * 车架号校验
 *
 * @author liu wei ping
 * @version 1.0
 * @date 2022-06-30 18:30:45
 */
public class VinCodeCheckHandler extends CheckHandler<OperatingNewCarBaseWithAttrDTO> {

    @Override
    public void doCheck(OperatingNewCarBaseWithAttrDTO baseDTO, List<? extends EsVehicleInfo> esInfos,
                        StringBuilder stringBuilder) {
        List<String> vinCodes = esInfos.stream().map(EsVehicleInfo::getVinCode).collect(toList());
        if (!vinCodes.contains(baseDTO.getVinCode())) {
            // 车架号不存在不往下校验了
            stringBuilder.append("vinCode ").append("does not exit in es");
        }

    }


}

package com.dst.common.util.checkEsData;

import com.dst.common.entitys.es.EsVehicleInfo;
import com.dstcar.entitys.operating.newcar.OperatingNewCarBaseWithAttrDTO;
import java.util.List;
import java.util.Objects;
import java.util.Optional;

/**
 * @author liu wei ping
 * @version 1.0
 * @date 2022-06-30 18:41:49
 */
public class CarIdCheckHandler extends CheckHandler<OperatingNewCarBaseWithAttrDTO> {
    @Override
    public void doCheck(OperatingNewCarBaseWithAttrDTO baseDTO, List<? extends EsVehicleInfo> esInfos,
                        StringBuilder stringBuilder) {
        Optional<? extends EsVehicleInfo> info =
                esInfos.stream().filter(esInfo -> esInfo.getVinCode().equals(baseDTO.getVinCode())).findFirst();
        if (info.isPresent() && !info.get().getCarId().equals(baseDTO.getCarId())) {
            stringBuilder.append("carId is different in es,in fact it is :").append(baseDTO.getCarId()).append("but " +
                    "in es it is :").append(info.get().getCarId());
        }

        if (Objects.nonNull(next)) {
            next.doCheck(baseDTO, esInfos, stringBuilder);
        }

    }
}
package com.dst.common.util.checkEsData;

import com.dst.common.entitys.es.EsVehicleInfo;
import com.dstcar.entitys.operating.newcar.OperatingNewCarBaseWithAttrDTO;
import java.util.List;
import java.util.Objects;
import java.util.Optional;

/**
 * 标准sku编码校验
 *
 * @author liu wei ping
 * @version 1.0
 * @date 2022-07-01 10:26:39
 */
public class StandardSkuCodeCheckHandler extends CheckHandler<OperatingNewCarBaseWithAttrDTO> {
    @Override
    public void doCheck(OperatingNewCarBaseWithAttrDTO baseDTO, List<? extends EsVehicleInfo> esInfos,
                        StringBuilder stringBuilder) {
        Optional<? extends EsVehicleInfo> info =
                esInfos.stream().filter(esInfo -> esInfo.getVinCode().equals(baseDTO.getVinCode())).findFirst();
        if (info.isPresent() && !info.get().getStandardSkuCode().equals(baseDTO.getStandardSkuCode())) {
            stringBuilder.append("standardSkuCode is different in es,in fact it is :").append(baseDTO.getStandardSkuCode()).append(
                    "but " +
                            "in es it is :").append(info.get().getStandardSkuCode());
        }

        if (Objects.nonNull(next)) {
            next.doCheck(baseDTO, esInfos, stringBuilder);
        }

    }
}

package com.dst.common.util.checkEsData;

import com.dst.common.entitys.es.EsVehicleInfo;
import com.dstcar.entitys.operating.newcar.OperatingNewCarBaseWithAttrDTO;
import java.util.List;
import java.util.Objects;
import java.util.Optional;

/**
 * spuCode校验
 *
 * @author liu wei ping
 * @version 1.0
 * @date 2022-07-01 10:28:17
 */
public class SpuCodeCheckHandler extends CheckHandler<OperatingNewCarBaseWithAttrDTO> {
    @Override
    public void doCheck(OperatingNewCarBaseWithAttrDTO baseDTO, List<? extends EsVehicleInfo> esInfos,
                        StringBuilder stringBuilder) {
        Optional<? extends EsVehicleInfo> info =
                esInfos.stream().filter(esInfo -> esInfo.getVinCode().equals(baseDTO.getVinCode())).findFirst();
        if (info.isPresent() && !info.get().getSpuCode().equals(baseDTO.getSpuCode())) {
            stringBuilder.append("spuCode is different in es,in fact it is :").append(baseDTO.getSkuCode()).append(
                    "but " +
                            "in es it is :").append(info.get().getSpuCode());
        }

        if (Objects.nonNull(next)) {
            next.doCheck(baseDTO, esInfos, stringBuilder);
        }
    }
}

package com.dst.common.util.checkEsData;

import com.dst.common.entitys.es.EsVehicleInfo;
import com.dstcar.entitys.operating.newcar.OperatingNewCarBaseWithAttrDTO;
import java.util.List;
import java.util.Objects;
import java.util.Optional;

/**
 * 场站id 校验
 *
 * @author liu wei ping
 * @version 1.0
 * @date 2022-07-01 10:30:22
 */
public class StationIdCheckHandler extends CheckHandler<OperatingNewCarBaseWithAttrDTO> {
    @Override
    public void doCheck(OperatingNewCarBaseWithAttrDTO baseDTO, List<? extends EsVehicleInfo> esInfos,
                        StringBuilder stringBuilder) {
        Optional<? extends EsVehicleInfo> info =
                esInfos.stream().filter(esInfo -> esInfo.getVinCode().equals(baseDTO.getVinCode())).findFirst();
        if (info.isPresent() && !info.get().getStationId().equals(baseDTO.getStationId())) {
            stringBuilder.append("stationId is different in es,in fact it is :").append(baseDTO.getStationId()).append(
                    "but " +
                            "in es it is :").append(info.get().getStationId());
        }

        if (Objects.nonNull(next)) {
            next.doCheck(baseDTO, esInfos, stringBuilder);
        }
    }
}

package com.dst.common.util.checkEsData;

import com.dst.common.entitys.es.EsVehicleInfo;
import com.dstcar.common.utils.string.StringUtil;
import com.dstcar.entitys.operating.newcar.OperatingNewCarBaseWithAttrDTO;
import com.dstcar.entitys.operating.vehicleattr.attr.VehicleAttrManageDTO;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * 属性比较
 *
 * @author liu wei ping
 * @version 1.0
 * @date 2022-07-01 10:32:41
 */
public class AttributesCheckHandler extends CheckHandler<OperatingNewCarBaseWithAttrDTO> {
    @Override
    public void doCheck(OperatingNewCarBaseWithAttrDTO baseDTO, List<? extends EsVehicleInfo> esInfos,
                        StringBuilder stringBuilder) {

        Optional<? extends EsVehicleInfo> info =
                esInfos.stream().filter(esInfo -> esInfo.getVinCode().equals(baseDTO.getVinCode())).findFirst();

        List<VehicleAttrManageDTO> attrs = baseDTO.getAttrs();
        Map<String, VehicleAttrManageDTO> attrMap = attrs.stream()
                .collect(Collectors.toMap(VehicleAttrManageDTO::getAttrId, Function.identity()));

        if (info.isPresent()) {
            // ES 中的属性map 的格式为 attrId:attrValueId/attrValueName(针对手动输入的属性)
            Map<String, Object> infoAttrMap = info.get().getAttributes();
            for (Map.Entry<String, VehicleAttrManageDTO> entry : attrMap.entrySet()) {
                //  分情况, 当attrValueId 不为空则比较attrValueId 否则就比较attrValueName
                if (!StringUtil.isEmpty(entry.getValue()) && !infoAttrMap.get(entry.getKey()).equals(entry.getValue())) {
                    stringBuilder.append("attribute is different in es,attrId is")
                            .append(entry.getKey())
                            .append("  attrName is ")
                            .append(entry.getValue().getAttrName())
                            .append("value in es is")
                            .append(infoAttrMap.get(entry.getKey()))
                            .append("value in db is ")
                            .append(entry.getValue().getAttrValueId());
                }

                if (StringUtil.isEmpty(entry.getValue()) && !infoAttrMap.get(entry.getKey()).equals(entry.getValue())) {
                    stringBuilder.append("attribute is different in es,attrId is")
                            .append(entry.getKey())
                            .append("  attrName is ")
                            .append(entry.getValue().getAttrName())
                            .append("value in es is")
                            .append(infoAttrMap.get(entry.getKey()))
                            .append("value in db is ")
                            .append(entry.getValue().getAttrValueName());
                }

            }

        }
        if (Objects.nonNull(next)) {
            next.doCheck(baseDTO, esInfos, stringBuilder);
        }
    }
}

2.使用责任链模式，加入链表结构，让检查方法顺序检查。

孰能生巧-LWP
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
设计模式之——责任链模式
01-08
责任链模式（行为型）：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。 二...
MrTrying#android-learning-notes#【Android笔记】设计模式（七）- 责任链模式1
07-25
1.简述 2.案例实现 3.Android源码中责任链的实现 4.总结
设计模式之责任链模式案例解析
科技向善
05-06 733
以上来源: 鲁班大叔
责任链模式（以及变种管道模式）的应用案例
热门推荐
张彦峰的博客
04-04 1万+
责任链在实际开发中的应用还是比较多的，特别是在营销订购系统、审核流转换处理、任务流程处理系统等系统中，其实我们在开发中往往主要应用的主要无非是以下三个场景（起码以我的平时开发的角度来看）：一是无需太关心责任链中各处理流的顺序的简单使用；二是需要关注处理顺序，按责任链条延续处理，每个处理节点均可对请求进行节点的处理， 或将其传递给链上的下个处理节点；三是在处理中和纯的责任链模式在链上只会有一个处理器用于处理业务数据存在差异，需要进行管道模式采用多个处理器都会处理业务数据。针对以上场景进行业务举例和代码书写
责任链模式实例
CiZhiYiHeng_的博客
01-26 668
责任链模式设计一个请假条审批模块 分析：假如规定学生请假小于或等于 2 天，班主任可以批准；小于或等于 7 天， 系主任可以批准；小于或等于 10 天，院长可以批准；其他情况不予批准； 这个实例适合使用职责链模式实现。 首先，定义一个领导类（Leader），它是抽象处理者，包含了一个指向下一位领导的指针 next 和一个处理假条的抽象处理方法handleRequest(int LeaveDays)；然后， 定义班主任类（ClassAdviser）、系主任类（DepartmentHead）和院长类（Dea
责任链模式案例
weixin_45982841的博客
03-07 280
文章目录前言一、案例总结 前言 二十三种设计模式之责任链模式。马士兵老师留下的责任链模式仿着Servlet过滤器。编写一个先获取每个过滤器的request等所有的过滤器执行完了request后，从后往前依次返回response中的数据。 一、案例 package com.hh.userservice.design.chainofresponsibility; import java.util.LinkedList; public class ChainOfResponsibility {
责任链模式 实例 java_Java模式开发之责任链模式
weixin_29410963的博客
02-27 134
Java模式开发之责任链模式从击鼓传花谈起击鼓传花是一种热闹而又紧张的饮酒游戏。在酒宴上宾客依次坐定位置，由一人击鼓，击鼓的地方与传花的地方是分开的，以示公正。开始击鼓时，花束就开始依次传递，鼓声一落，如果花束在某人手中，则该人就得饮酒。假比说，贾母、贾赦、贾政、贾宝玉和贾环是五个参加击鼓传花游戏的传花者，他们组成一个环链。击鼓者将花传给贾母，开始传花游戏。花由贾母传给贾赦，由贾赦传给贾政，由贾政...
23种java版设计模式源码案例.zip
最新发布
02-28
责任链模式(chainrespon) 命令模式(commond) 解释器模式(interpreter) 迭代器模式(iterator) 中介者模式(mediator) 备忘录模式(memento) 观察者模式(observer) 状态模式(state) 空对象模式(null object) 策略模式...
几种常见设计模式的案例分析源码
11-19
针对几种常见设计模式的案例分析源码：观察者模式、工厂模式、责任链模式、单例模式、模板方法模式、适配器模式。。。。。。
C#设计模式大全
08-05
五、 责任链模式的实际应用案例 六、 责任链模式的实现 设计模式（18）－Command Pattern 一、 命令（Command）模式 二、 命令模式的结构 三、 命令模式的示意性源代码 四、 玉帝传美猴王上天 五、 命令模式...
java设计模式之：责任链模式（企业级案例）
qq_40053836的博客
03-15 726
java设计模式一共有23种，其中主要分为三大类： 1：创建型模式 工厂方法模式、抽象工厂模式、单例模式、创建者模式、原型模式。 2：结构型模式 适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 3：行为模式 策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模状态模式、访问者模式、中介者模式、解释器模式。 今天我们主要讲解行为模式...
java责任链设计模式例子_责任链设计模式案例详解，看这一篇就够了
weixin_34209060的博客
02-28 263
老哥哔哔哔责任链设计模式在日常工作中很常见，也很重要，很多开源框架都采用了责任链设计模式，比如；servlet中的Filter、Dubbo中的Filter、Mybatis中的Plugin、spring MVC的HandlerExecutionChain等等，都是采用了责任链设计模式。如果这篇文章对你有所帮助，请帮老哥点个【在看】和【赞】，如果能分享给你的朋友，那就更好了，嘿嘿生宝宝引发的程序思考什...
设计模式--应用实例四（责任链模式的应用)
weixin_44200656的博客
11-19 646
1、认识责任链模式的结构。 2、在业务中使用责任链模式，加深对责任链模式概念的理解。 3、关注代码结构是如何来达到单一职责原则、隔离、开闭原则。
设计模式-责任链模式实例
qq25910561的博客
03-21 340
职责链模式（称责任链模式）将请求的处理对象像一条长链一般组合起来，形成一条对象链。请求并不知道具体执行请求的对象是哪一个，这样就实现了请求与处理对象之间的解耦。 生活中这种例子如：在公司中申请一些东西需要走流程 员工提出申请-> 部门经理审批 -> 副总经理审批->总经理审批 ，这个过程每个流程都需要审批，只有审批通过才可以进入下一个流程，代码流程如下： 首先创建一个抽象类： package
责任链模式在开发中的应用案例
dingdeyangvip123的博客
12-02 188
1.业务场景：和外部对接中需要传送订单数据给其他三方系统。由于订单有多种状态每次变更都需要同步，但是对方同一个订单只能创建一次，第二次只能更新。由于我方也不想存那些订单推送给他，所以每次都是先无脑创建订单然后再更新一次。 2代码示例： 调用入口： @Service @Slf4j public class EicOrderStrategyService { @Autowired EicOrderCreateProcessor eicOrderCreateProcesso.
设计模式-责任链设计模式-案例1
weixin_37862824的博客
11-15 216
责任链设计模式 本节要讲的并非传统意义的责任链：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。也就是说：用户发起一个请求，之后请求上链，如果当前处理者可以处理该请求，那么就直接处理；否则当前处理者把请求转发给下一个处理者。 本节要讲的是责任链的一种变形，叫做功能链，这种设计模式特别常用，随处可见，用途十分广泛。这种模式是：一个链上有多个处理逻辑，一个请求到来会被所有逻辑处理，最后返
在设计模式中责任链模式的举例（一）
Climbman的博客
05-01 125
一个在线商店需要对用户的购物车进行处理。每个购物车可以包含多个商品，当用户提交购物车时，需要依次对购物车中的商品进行处理，如验证库存、计算价格等。而处理方式可以有不同的实现，并且需要按照一定的顺序执行。从中可以看到，当购物车提交时，它会依次被不同的处理者进行处理，处理方式不同但处理顺序是固定的，每个处理者只需要处理自己能处理的部分并传递请求给下一个处理者。这就是责任链模式的应用。在设计模式中责任链模式的举例。
超详细的责任链设计模式-包含源码举例说明
lqs_user的博客
06-24 464
责任链设计模式-源码
责任链模式样例（基于SpringBoot）
jike11231的博客
04-14 4035
责任链模式，简而言之，就是将多个操作组装成一条链路进行处理。请求在链路上传递，链路上的每一个节点就是一个处理器，每个处理器都可以对请求进行处理，或者传递给链路上的下一个处理器处理。 一、AbstractCheckHandler抽象类处理器 /** * 抽象类处理器 */ @Component public abstract class AbstractCheckHandler { /** * 当前处理器持有下一个处理器的引用 */ @Getter @Sett
拦截器的设计模式--责任链模式
07-27
责任链模式是一种行为型设计模式，用于将请求的发送者和接收者解耦，并将多个对象组成一个链条，依次处理请求。在拦截器的设计中，责任链模式可以被用于实现请求的拦截和处理。 在责任链模式中，每个处理器对象都...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值