用责任链模式改造 if else

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量482 收藏 7
点赞数 20
分类专栏： 个人工作 文章标签： 责任链模式 java 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DS_Watson/article/details/142656714
版权

我的上一篇文章，因为if else 多了，捣鼓很久，今天用责任链模式改造一下。

代码写着写着，if else if 逻辑忘记了，哎。。。-CSDN博客
责任链模式（Chain of Responsibility Pattern）
1. 什么是责任链模式？
责任链模式是一种行为设计模式，它允许请求沿着处理者链传递，直到其中一个处理者处理它。每个处理者都可以决定是否处理请求或者将其传递给链中的下一个处理者。
2. 责任链模式的优点
降低耦合度：请求发送者不需要知道请求的最终处理者是谁，只需要知道请求会被某个处理者处理。
灵活配置处理链：可以根据需要动态地增加或删除处理者，而不影响其他处理者。
增强系统扩展性：新的处理者可以很容易地添加到链中，从而扩展系统的功能。
3. 责任链模式的应用场景
权限控制：多个权限检查器组成一个链，逐级检查用户的权限。
日志处理：多个日志处理器组成一个链，逐级处理日志消息。
支付处理：多种支付方式组成一个链，逐级处理支付请求。
4. 责任链模式的实现
现在如下代码改成 责任链模式

        //代理价>销售价
        if (agentPrice.compareTo(goodsPrice) > 0) {
            isNeedLock=true;
            reason="代理价>销售价";
            reasonType="1";
            log.info("agentPrice.compareTo(goodsPrice) > 0 ");
        }else if (agentPrice.compareTo(BigDecimal.ZERO) > 0) {
            //（销售价-代理价）/代理价<5%
            double num = (goodsPrice.subtract(agentPrice)).divide(agentPrice,6, RoundingMode.HALF_UP)
                    .multiply(new BigDecimal(100)).doubleValue();
            if (num < 5) {
                isNeedLock=true;
                reason="（销售价-代理价）/代理价<5%";
                reasonType="2";
                log.info("agentPrice.compareTo(BigDecimal.ZERO) > 0");
            }
 
        }else if (supplyPrice.compareTo(agentPrice) > 0) {
            isNeedLock = true;
            reason = "供货价大于代理价";
            reasonType = "5";
            log.info(" supplyPrice.compareTo(agentPrice) > 0 ");
        }

首先分析需要代码，这里的每一个 if else 都有机会执行，一个执行了，其他的 if else 就不会执行了。

入参需要三个价格，那么可以将这个价格放到一个类里面, 这里执行结果有四种，那么可以创建一个枚举类存放，可以在初始化入参的时候设置为默认枚举。

入参请求和结果类 PriceCheckRequest 

/**
 * @author hds
 */
@Data
public class PriceCheckRequest {
    private BigDecimal goodsPrice;
    private BigDecimal agentPrice;
    private BigDecimal supplyPrice;
    private PriceCheckEnum priceCheckEnum;


    public PriceCheckRequest(BigDecimal goodsPrice, BigDecimal agentPrice, BigDecimal supplyPrice) {
        this.goodsPrice = goodsPrice;
        this.agentPrice = agentPrice;
        this.supplyPrice = supplyPrice;
    }

    public PriceCheckRequest(Product product) {
        this.goodsPrice = Optional.ofNullable(product.getProductPrice()).orElse(BigDecimal.ZERO);
        this.agentPrice = Optional.ofNullable(product.getAgentPrice()).orElse(BigDecimal.ZERO);
        this.supplyPrice = Optional.ofNullable(product.getSupplyPrice()).orElse(BigDecimal.ZERO);
        priceCheckEnum = PriceCheckEnum.DEFAULT;
    }
}

结果枚举类

@Getter
public enum PriceCheckEnum {

/*    request.setNeedLock(true);
            request.setReason("代理价>销售价");
            request.setReasonType("1");

             request.setNeedLock(true);
                request.setReason("（销售价-代理价）/代理价<5%");
                request.setReasonType("2");

                 request.setNeedLock(true);
            request.setReason("供货价大于代理价");
            request.setReasonType("5");
            */

    DEFAULT("0", "", false),
    AGENT_PRICE_GREATER_THAN_SALE_PRICE("1", "代理价>销售价", true),
    SALE_PRICE_DIFFERENCE_PERCENTAGE("2", "（销售价-代理价）/代理价<5%", true),
    SUPPLIER_PRICE_GREATER_THAN_AGENT_PRICE("5", "供货价>代理价", true);

    private final String reasonType;
    private final String reason;
    private final Boolean needLock;

    PriceCheckEnum(String reasonType, String reason, boolean needLock) {
        this.reasonType = reasonType;
        this.reason = reason;
        this.needLock = needLock;
    }

解下类就要创建一个 价格检查的抽象类 

PriceCheckHandler 其中 next 属性是执行 下一个处理器
@Setter
public abstract class PriceCheckHandler {

    protected PriceCheckHandler next;

    public abstract void handle(PriceCheckRequest request);

    public  void check(PriceCheckRequest request){
        if (!request.getPriceCheckEnum().getNeedLock()){
            if (next != null) {
                next.handle(request);
            }
        }
    }
}

代理价大于销售价 处理器

AgentPriceGreaterThanGoodsPriceHandler
public class AgentPriceGreaterThanGoodsPriceHandler extends PriceCheckHandler {

    @Override
    public void handle(PriceCheckRequest request) {
        if (BigDecimalUtil.isGreaterThan(request.getAgentPrice(),request.getGoodsPrice())) {
            request.setPriceCheckEnum(PriceCheckEnum.AGENT_PRICE_GREATER_THAN_SALE_PRICE);
        }
        check(request);
    }
}

供货价大于代理价处理器

SupplyPriceGreaterThanAgentPriceHandler
public class SupplyPriceGreaterThanAgentPriceHandler extends PriceCheckHandler {

    @Override
    public void handle(PriceCheckRequest request) {
        if (BigDecimalUtil.isGreaterThan( request.getSupplyPrice(), request.getAgentPrice())) {
            request.setPriceCheckEnum(PriceCheckEnum.SUPPLIER_PRICE_GREATER_THAN_AGENT_PRICE);
        }
        check(request);
    }
}
（销售价-代理价）/代理价<5% 处理器
AgentPricePercentageDifferenceHandler
public class AgentPricePercentageDifferenceHandler extends PriceCheckHandler {

    @Override
    public void handle(PriceCheckRequest request) {
        if ( BigDecimalUtil.isGreaterThan(request.getAgentPrice(),BigDecimal.ZERO) ) {
            double num = (request.getGoodsPrice().subtract(request.getAgentPrice()))
                    .divide(request.getAgentPrice(), 6, RoundingMode.HALF_UP)
                    .multiply(new BigDecimal(100))
                    .doubleValue();
            if (num < 5) {
                request.setPriceCheckEnum(PriceCheckEnum.SALE_PRICE_DIFFERENCE_PERCENTAGE);
            }
            check(request);
        }
        check(request);
    }
}

默认处理器

DefaultPriceHandler 默认返回价格检查通过，需要把它放在责任链的最后处理器
public class DefaultPriceHandler extends PriceCheckHandler {

    @Override
    public void handle(PriceCheckRequest request) {
        request.setPriceCheckEnum(PriceCheckEnum.DEFAULT);
    }
}

责任链创建类 (简单的建造者模式)

ChainBuilder
public class ChainBuilder {

    private PriceCheckHandler head;

    public static ChainBuilder chainBuilder = new ChainBuilder();
    static {
        chainBuilder.addFirst(new DefaultPriceHandler());
        chainBuilder.addFirst(new AgentPricePercentageDifferenceHandler());
        chainBuilder.addFirst(new SupplyPriceGreaterThanAgentPriceHandler());
        chainBuilder.addFirst(new AgentPriceGreaterThanGoodsPriceHandler());

    }


    public void addFirst(PriceCheckHandler handler) {
        handler.setNext(head);
        head = handler;
    }

    public void process(PriceCheckRequest request) {
        if (head != null) {
            head.handle(request);
        }
    }
}

最后测试


@Slf4j
public class ChainBuilderTest {

    @Test
    public void testChain(){
        Product product = new Product();
        product.setAgentPrice(new BigDecimal("59.00"));
        product.setProductPrice(new BigDecimal("60.00"));
        product.setSupplyPrice(new BigDecimal("50.00"));

        PriceCheckRequest priceCheckRequest = new PriceCheckRequest(product);
        ChainBuilder.chainBuilder.process(priceCheckRequest);
        log.info("商品价格校验结果：{}", JSONUtil.toJsonStr(priceCheckRequest) );

        product.setAgentPrice(new BigDecimal("70.00"));
        product.setProductPrice(new BigDecimal("60.00"));
        product.setSupplyPrice(new BigDecimal("50.00"));
        //AGENT_PRICE_GREATER_THAN_SALE_PRICE
        priceCheckRequest = new PriceCheckRequest(product);
        ChainBuilder.chainBuilder.process(priceCheckRequest);
        log.info("商品价格校验结果：{}", JSONUtil.toJsonStr(priceCheckRequest) );

        product.setAgentPrice(new BigDecimal("60.00"));
        product.setProductPrice(new BigDecimal("60.00"));
        product.setSupplyPrice(new BigDecimal("80.00"));
        //SUPPLIER_PRICE_GREATER_THAN_AGENT_PRICE
        priceCheckRequest = new PriceCheckRequest(product);
        ChainBuilder.chainBuilder.process(priceCheckRequest);
        log.info("商品价格校验结果：{}", JSONUtil.toJsonStr(priceCheckRequest) );

        product.setAgentPrice(new BigDecimal("60.00"));
        product.setProductPrice(new BigDecimal("80.00"));
        product.setSupplyPrice(new BigDecimal("60.00"));
        //DEFAULT
        priceCheckRequest = new PriceCheckRequest(product);
        ChainBuilder.chainBuilder.process(priceCheckRequest);
        log.info("商品价格校验结果：{}", JSONUtil.toJsonStr(priceCheckRequest) );
    }


}

输出结果，

好了今天就到这里，有兴趣的同学可以自己试一下。

另外将 AgentPricePercentageDifferenceHandler 放到倒数第二个，是可以延迟计算。

还可以再在处理类处理了请求的时候，将处理次数加一进行统计，经过一段时间，用定时任务统计每个处理器的次数，将次数多的处理器动态调整放到前面。

DS_Watson
关注
专栏目录
责任链模式加建造者模式结合使用改造多个ifelse
zsj777的专栏
05-05 243
抽象处理者（ Handler ） 角色： 定义出一个处理请求的接口， 维护一个自身的对象， 如果 需要， 接口可以定义出一个方法， 以返回对下家的引用。 package com.example.demo.util; import lombok.Data; import java.util.Objects; @Data public abstract class Handler { public Handler nextHandler; public String handle(
java 状态模式 替代 if else_用设计模式来替代if-else
weixin_39617484的博客
02-25 688
前言物流行业中，通常会涉及到EDI报文(XML格式文件)传输和回执接收，每发送一份EDI报文，后续都会收到与之关联的回执(标识该数据在第三方系统中的流转状态)。这里枚举几种回执类型：MT1101、MT2101、MT4101、MT8104、MT8105、MT9999，系统在收到不同的回执报文后，会执行对应的业务逻辑处理。当然，实际业务场景并没有那么笼统，这里以回执处理为演示案例模拟一个回执类@Dat...
设计模式-使用责任链模式改造if else并优化传统责任链
abcnull 的博客
07-24 2317
文章目录简介代码实现优缺点应用场景 简介 普通的 if else 或者 switch case 语句虽然可以做选择，但是一旦条件增加，就显得混乱。责任链模式的的思想其实和 if else 或者 switch case 很类似都是一步步做过滤，只不过责任链是通过对象来过滤罢了，责任链可以看做一条单链表的数据结构，一个对象一个对象的过滤条件，符合的就执行然后结束，不符合的就往后传递，如果每个对象都无法处理，一般会有一个最终的处理器来处理 代码实现 我们先看故事场景 假如你朋友有一辆豪车，但是它坏掉了，朋友委托
if-else结构嵌套多逻辑太复杂？来试试责任链模式 一个例子教会你责任链模式
qishuang6的博客
07-05 1661
接着来看看每个处理具体的Handler类是如何修改的，在责任链模式中，每个处理器都应该有一个方法来处理请求，并且应该有一个机制来决定是否将请求传递给链中的下一个处理器。在责任链模式中，每个处理器都应该有一个方法来处理请求，并且应该有一个机制来决定是否将请求传递给链中的下一个处理器。看完基础的定义是不是发觉每次请求的传递有点像函数之间的调用，是的这就是类似于递归这种方法，递归和责任链模式都涉及到一种层级或链式的方式来处理问题，即问题（或请求）在某种结构上逐层或逐个传递，直到被处理。时，它将有机会处理该请求；
Spring Boot使用责任链模式优化业务逻辑中的if-else代码
m0_63437643的博客
09-20 147
@Override public void handleRequest(Request request) { if (request.getCondition().equals("conditionA")) { // 处理条件A下的逻辑 } else { // 将请求传递给下一个处理者 nextHandler.handleRequest(request);通过使用责任链模式，我们可以将复杂的if-else逻辑转化为一系列相互连接的处理者，提高代码的可维护性和扩展性。在业务逻辑中使用责任链模式。
Java之使用策略模式替代 if-else
m0_51014049的博客
06-27 552
通过策略模式，我们将不同的算法（即折扣计算逻辑）封装到独立的策略类中，客户端根据需要选择具体的策略对象。在Java中，通常情况下 if-else 语句用于根据不同条件执行不同的逻辑。而策略模式则是一种设计模式，它允许在运行时选择算法的行为。策略模式的主要思想是将算法封装成独立的对象，使得它们可以相互替换，使得算法的变化独立于使用算法的客户。假设我们有一个根据不同类型的用户给予不同折扣的需求。结构，使得代码更加清晰、扩展性更好，同时也符合面向对象设计的开闭原则（对扩展开放，对修改关闭）。
设计模式学习（十二）用设计模式干掉 if-else，太优雅了！
ACGkaka的博客
10-13 506
设计模式学习（十二）用设计模式干掉 if-else，太优雅了！
巧用Java策略模式取代 if else
GodSea_611的博客
01-22 1145
策略模式可以将分类细分到不同的类进行处理，有较高代码可读性和可维护性，但也不是所有场景都适用，对于一些简单的分支处理，使用 if else 就完全可以解决，这种情况下强行使用策略模式反而适得其反，增加的工作量，所以还是需要结合业务场景做选择。
策略模式解决if-else问题
weixin_43005845的博客
01-10 981
这种模式支持开闭原则，在不修改现有代码的前提下，动态的添加、删除、替换算法。策略模式是一种行为设计模式，它允许在运行时根据不同的情况来选择不同的策略。：它是一个接口，具体的策略实现类去实现这个接口，就可以提供不同的实现方式。2、提高代码可读性：不同的业务处理在不同的策略实现类中，易于理解和维护。1、易于拓展：不需要修改原有代码，方便的增加、删除算法。可以根据需要来修改策略，或者定义一个工厂类。以Strategy接口实现某具体算法。3、避免大量的if-else语句。
使用策略模式改造if分支过多的方法
12-22
在软件设计中，面对复杂的业务逻辑，特别是涉及多种条件判断的情况，传统的做法是使用if-else语句或者switch语句来实现。然而，随着需求的不断变化，这种做法可能导致代码结构变得臃肿且难以维护。在这种场景下，...
在Java中用规则引擎模式替代ifelse - Vitali
m0_64354070的博客
12-06 653
规则引擎模式：这种模式的本质是if - else ，拆分if - else每个分支到规则类中，然后，主规则引擎类将保存所有规则并找到与客户端请求匹配的规则。 定义规则类 为了确保所有规则类都实现相同的方法，让我们定义一个每个类都将实现的接口： <b>public</b> <b>interface</b> AncestorRule { Optional<AncestorResult> evaluate(String selector);
Java函数式实现替代策略模式解决 if...else代码，Map+函数式接口方法
不受天磨非好汉，不遭人妒是庸才——着实着迷゛
01-26 2167
之前记录过用自定义注解和策略模式实现发不同消息的功能笔记： 文章地址：发送不同类型的消息----------策略模式_不受天磨非好汉，不遭人妒是庸才——着实着迷゛-CSDN博客r一：首先看下代码结构annotation：注解context：调度容器（会存放不同消息策略实现列表）enums：不同消息类型的枚举listener：springboot项目初始化的时候初始化消息策略实现与枚举类型的绑定关系并加入到调度容器里面service：消息接口定义impl：具体消息策略实现二：具体代码讲解1：消息类型枚举：M
Python编码系列—Python责任链模式：打造灵活的请求处理流程
u013889591的专栏
09-27 985
在复杂的软件系统中，经常需要通过多个处理器（或过滤器）来处理同一个请求，每个处理器完成自己的任务后，将请求传给下一个处理器。责任链模式（Chain of Responsibility Pattern）提供了一种优雅的方式来实现这种处理流程。本文将深入探讨Python中的责任链模式，包括其背景、原理、使用场景、代码实现和实际应用案例。责任链模式是一种行为型设计模式，它允许一个请求沿着一个链条（或链表）的处理器传递，直到有一个处理器处理它为止。
《 Spring Boot实战：优雅构建责任链模式投诉处理业务》
欢迎每一位朋友不吝赐教，无论是宝贵的建议还是中肯的批评，都将是我前进路上不可或缺的灯塔
09-25 995
本文详细介绍了在Spring Boot中如何实现责任链模式，通过构建投诉处理系统作为实际场景。从定义投诉请求类开始，逐步实现了抽象处理者类和多个具体的处理者类，并成功创建了投诉处理链。通过控制器处理来自API的投诉请求，展示了责任链模式在Spring Boot应用中的灵活性和扩展性。本文还讨论了责任链模式如何解决传统处理方式的不足，提高了系统的维护性和可扩展性。最后，通过API测试验证了实现的有效性，为开发者在Spring Boot项目中应用责任链模式提供了宝贵的参考。
设计模式之责任链模式
一个老Java开发的自白
09-29 893
责任链模式是一种行为型设计模式，通过创建对象链来解耦请求的发送者和接收者。该模式涉及抽象处理者、具体处理者和客户端三个角色，请求在链上传递直到被处理或到达链尾。其优点在于解耦请求与处理、提高系统灵活性和简化代码。责任链模式广泛应用于请求处理链、日志记录、身份认证、资源分配和异常处理等场景。
六、设计模式-6.3、责任链模式
weixin_61769871的博客
09-26 417
Java面试八股文、设计模式、责任链模式
基于Hive和Hadoop的哔哩哔哩网站分析系统
图南的博客
09-27 597
本项目是一个基于大数据技术的哔哩哔哩平台分析系统，旨在为用户提供全面的哔哩哔哩视频数据和深入的用户行为分析。系统采用 Hadoop 平台进行大规模数据存储和处理，利用 MapReduce 进行数据分析和处理，通过 Sqoop 实现数据的导入导出，以 Spark 为核心进行高效的数据处理。整个系统结合了大数据处理技术，为用户提供精准的内容推荐和深入的用户兴趣分析，帮助平台更好地了解视频趋势和用户需求。
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 242
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值