设计模式第八讲：常见重构技巧 - 去除多余的if else

最新推荐文章于 2024-05-07 18:00:22 发布
最新推荐文章于 2024-05-07 18:00:22 发布
阅读量1k 收藏 1
点赞数
分类专栏： Java 设计模式详解 文章标签： 设计模式 重构 工厂模式 命令模式 规则引擎 策略模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_28959087/article/details/132504554
版权

设计模式第八讲：常见重构技巧 - 去除多余的if else

最为常见的是代码中使用很多的if/else，或者switch/case；如何重构呢？方法特别多，本文是设计模式第八讲，带你学习其中的技巧。

文章目录

1、出现if/else和switch/case的场景

通常业务代码会包含这样的逻辑：每种条件下会有不同的处理逻辑。比如两个数a和b之间可以通过不同的操作符（+，-，*，/）进行计算，初学者通常会这么写：

public int calculate(int a, int b, String operator) {
    int result = Integer.MIN_VALUE;
 
    if ("add".equals(operator)) {
        result = a + b;
    } else if ("multiply".equals(operator)) {
        result = a * b;
    } else if ("divide".equals(operator)) {
        result = a / b;
    } else if ("subtract".equals(operator)) {
        result = a - b;
    }
    return result;
}

或者用switch/case：

public int calculateUsingSwitch(int a, int b, String operator) {
    switch (operator) {
    case "add":
        result = a + b;
        break;
    // other cases    
    }
    return result;
}

这种最基础的代码如何重构呢？

2、重构思路

有非常多的重构方法来解决这个问题, 这里会列举很多方法，在实际应用中可能会根据场景进行一些调整；另外不要纠结这些例子中显而易见的缺陷（比如没用常量，没考虑多线程等等），而是把重心放在学习其中的思路上。

2.1、方式一 - 工厂类

工厂设计模式可以参考这篇文章：JAVA设计模式第二讲：创建型设计模式

  • 第8.2节

  • 定义一个操作接口

public interface Operation {
    int apply(int a, int b);
}
  • 实现操作， 这里只以add为例
public class Addition implements Operation {
    @Override
    public int apply(int a, int b) {
        return a + b;
    }
}
  • 实现操作工厂
public class OperatorFactory {
    static Map<String, Operation> operationMap = new HashMap<>();
    static {
        operationMap.put("add", new Addition());
        operationMap.put("divide", new Division());
        // more operators
    }
 
    public static Optional<Operation> getOperation(String operator) {
        return Optional.ofNullable(operationMap.get(operator));
    }
}
  • 在Calculator中调用
public int calculateUsingFactory(int a, int b, String operator) {
    Operation targetOperation = OperatorFactory
      .getOperation(operator)
      .orElseThrow(() -> new IllegalArgumentException("Invalid Operator"));
    return targetOperation.apply(a, b);
}

对于上面为什么方法名是apply,Optional怎么用? 请参考这篇：

2.2、方式二 - 枚举

枚举适合类型固定，可枚举的情况，比如如下操作符；同时枚举中是可以提供方法实现的，这就是我们可以通过枚举进行重构的原因。

  • 定义操作符枚举
public enum Operator {
    ADD {
        @Override
        public int apply(int a, int b) {
            return a + b;
        }
    },
    // other operators
    
    public abstract int apply(int a, int b);

}
  • 在Calculator中调用
public int calculate(int a, int b, Operator operator) {
    return operator.apply(a, b);
}
  • 写个测试用例测试下：
@Test
public void whenCalculateUsingEnumOperator_thenReturnCorrectResult() {
    Calculator calculator = new Calculator();
    int result = calculator.calculate(3, 4, Operator.valueOf("ADD"));
    assertEquals(7, result);
}

看是否很简单?

2.3、方法三 - 命令模式

命令模式也是非常常用的重构方式，把每个操作符当作一个Command。

  • 首先让我们回顾下什么是命令模式

    • 看这篇文章：JAVA设计模式第四讲：行为型设计模式

      • 第10.8节

    • 命令模式(Command pattern)：将"请求"封闭成对象，以便使用不同的请求、队列或者日志来参数化其他对象。命令模式也支持可撤销的操作。

      • Command: 命令
      • Receiver: 命令接收者，也就是命令真正的执行者
      • Invoker: 通过它来调用命令
      • Client: 可以设置命令与命令的接收者

      img

  • Command接口

public interface Command {
    Integer execute();
}
  • 实现Command
public class AddCommand implements Command {
    // Instance variables
 
    public AddCommand(int a, int b) {
        this.a = a;
        this.b = b;
    }
 
    @Override
    public Integer execute() {
        return a + b;
    }
}
  • 在Calculator中调用
public int calculate(Command command) {
    return command.execute();
}
  • 测试用例
@Test
public void whenCalculateUsingCommand_thenReturnCorrectResult() {
    Calculator calculator = new Calculator();
    int result = calculator.calculate(new AddCommand(3, 7));
    assertEquals(10, result);
}

注意，这里new AddCommand(3, 7)仍然没有解决动态获取操作符问题，所以通常来说可以结合简单工厂模式来调用：

  • 创建型 - 简单工厂(Simple Factory)
    • 简单工厂(Simple Factory)，它把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个具体子类来实例化，这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类

2.4、方法四 - 规则引擎

规则引擎适合规则很多且可能动态变化的情况，在先要搞清楚一点Java OOP，即类的抽象：

  • 这里可以抽象出哪些类？// 头脑中需要有这种自动转化
    • 规则Rule
      • 规则接口
      • 具体规则的泛化实现
    • 表达式Expression
      • 操作符
      • 操作数
    • 规则引擎
  • 定义规则
public interface Rule {
    boolean evaluate(Expression expression);
    Result getResult();
}
  • Add 规则
public class AddRule implements Rule {
    @Override
    public boolean evaluate(Expression expression) {
        boolean evalResult = false;
        if (expression.getOperator() == Operator.ADD) {
            this.result = expression.getX() + expression.getY();
            evalResult = true;
        }
        return evalResult;
    }    
  	@Override
    public Result getResult() {
       ...
    }
}
  • 表达式
public class Expression {
    private Integer x;
    private Integer y;
    private Operator operator;        
}
  • 规则引擎
public class RuleEngine {
    private static List<Rule> rules = new ArrayList<>();
 
    static {
        rules.add(new AddRule());
    }
 
    public Result process(Expression expression) {
        Rule rule = rules
          .stream()
          .filter(r -> r.evaluate(expression))
          .findFirst()
          .orElseThrow(() -> new IllegalArgumentException("Expression does not matches any Rule"));
        return rule.getResult();
    }
}
  • 测试用例
@Test
public void whenNumbersGivenToRuleEngine_thenReturnCorrectResult() {
    Expression expression = new Expression(5, 5, Operator.ADD);
    RuleEngine engine = new RuleEngine();
    Result result = engine.process(expression);
 
    assertNotNull(result);
    assertEquals(10, result.getValue());
}

2.5、方法五 - 策略模式

策略模式比命令模式更为常用，而且在实际业务逻辑开发中需要注入一定的（比如通过Spring的@Autowired来注入bean），这时通过策略模式可以巧妙的重构

  • 什么是策略模式？

    • 我们再复习下：JAVA设计模式第四讲：行为型设计模式
      • 第10.3节
    • 策略模式(strategy pattern)：定义了算法族，分别封闭起来，让它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户
      • Strategy 接口定义了一个算法族，它们都具有 behavior() 方法。
      • Context 是使用到该算法族的类，其中的 doSomething() 方法会调用 behavior()，setStrategy(in Strategy) 方法可以动态地改变 strategy 对象，也就是说能动态地改变 Context 所使用的算法。

    img

  • Spring中需要注入资源重构？

如果是在实现业务逻辑需要注入框架中资源呢？比如通过Spring的@Autowired来注入bean。可以这样实现：

  • 操作 // 很巧妙
public interface Opt {
    int apply(int a, int b);
}

@Component(value = "addOpt")
public class AddOpt implements Opt {
  	// 这里通过Spring框架注入了资源
    @Autowired
    xxxAddResource resource; 

    @Override
    public int apply(int a, int b) {
       return resource.process(a, b);
    }
}

@Component(value = "devideOpt")
public class devideOpt implements Opt {
  	// 这里通过Spring框架注入了资源
    @Autowired
    xxxDivResource resource; 

    @Override
    public int apply(int a, int b) {
       return resource.process(a, b);
    }
}
  • 策略
@Component
public class OptStrategyContext{
 

    private Map<String, Opt> strategyMap = new ConcurrentHashMap<>();
 
    @Autowired
    public OptStrategyContext(Map<String, Opt> strategyMap) {
        this.strategyMap.clear();
        this.strategyMap.putAll(strategyMap);
    }
 
    public int apply(Sting opt, int a, int b) {
        return strategyMap.get(opt).apply(a, b);
    }
}

上述代码在实现中非常常见。

3、一些反思

最怕的是刚学会成语，就什么地方都想用成语。

  • 真的要这么重构吗？
    • 在实际开发中，切记最怕的是刚学会成语，就什么地方都想用成语; 很多时候不是考虑是否是最佳实现，而是折中（通常是业务和代价的折中，开发和维护的折中…），在适当的时候做适当的重构。
    • 很多时候，让团队可持续性的维护代码便是最佳；
    • 重构后会生成很多类，一个简单业务搞这么复杂？所以你需要权衡

4、参考文章

  • https://www.baeldung.com/java-replace-if-statements
程序员 jet_qi
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
使用设计模式解决if-else冗余的问题
Chen__xiu的博客
03-11 529
为了避免项目开发中if-else冗余、代码臃肿的问题，结合设计模式，现在提供一种新的修改思路供大家参考。
如何优雅地重构 Java 中的 if-else
网络技术联盟站
04-15 718
在Java中优雅地重构if-else语句，我们可以采用多种方法，包括使用设计模式、映射表和函数式编程等。选择合适的重构方法取决于具体的场景和需求，但无论采用何种方法，重构的目的都是提高代码质量、可读性和可维护性，使得代码更加简洁优雅。
高级程序员优化if-else必会的几种方案，设计模式-Java
weixin_43844698的博客
02-02 2054
高级程序员优化if-else必会的几种方案，设计模式-Java
【设计模式实战】用三种设计模式去优化if-else屎山代码！！！
最新发布
小杰不秃头的博客
05-07 660
我们之前也学习了不少设计模式，今天给大家介绍一个案例，帮助大家更加熟悉设计模式，并能够在自己写项目的时候能够下意识的使用设计模式，避免写出屎山代码。🌈。
设计模式：干掉if else的几种方法
weixin_45754452的博客
05-22 2668
1.将所有的策略中存储在一个Map中，这样当我们需要增加逻辑时只需要增加一个put即可，代码可扩展性很强，而且getStrategy()里面的代码和使用getStrategy()方法的核心逻辑都无需修改。使用策略模式，可以发现策略模式和多态其实也没有多大的区别，但关键就在于getStrategy()方法，它的实现的多变，可以大大提高代码的可扩展性，无需修改了核心代码。2.策略名可以在最开始的配置代码中传入，如配置类中就传入。
设计模式学习（十二）用设计模式干掉 if-else，太优雅了！
ACGkaka的博客
10-13 374
设计模式学习（十二）用设计模式干掉 if-else，太优雅了！
设计模式-策略模式(彻底消除if-else结构)
hey_lie的博客
02-10 1500
策略模式属于11种行为型模式之一策略模式(strategy pattern)的原始定义是：定义一系列算法，将每一个算法封装起来，并使它们可以相互替换。策略模式让算法可以独立于使用它的客户端而变化实际生活中常常遇到需要选择策略的场景，比如乘坐交通工具，可以选择飞机火车等在开发中，比如网购支付功能，支付时可以选择支付算法，可以是支付宝支付，也可以是xxx银行支付等待，这些提供的算法一致(付款),就是一种策略。
重构_基本方式
z_yemu的博客
05-02 2443
重构
Java编程细节重构之为什么if-else不是好代码详析
08-27
Java编程细节重构是一个非常重要的概念，特别是在面向对象设计中，if-else语句是非常常用的条件判断语句，但是，如果滥用if-else语句，会导致代码变得难以维护和阅读。今天，我们将通过示例代码，介绍关于Java编程...
软件设计模式与重构大作业-心算大师游戏
03-12
西南科技大学软件设计模式与重构大作业-心算大师游戏（高分作业）
If-Else-Block-Refactoring:使用嵌套的ifelse代码块重构业务逻辑
05-14
在`If-Else-Block-Refactoring-master`这个压缩包中，可能包含了具体的代码示例、博客文章和练习，帮助读者理解和实践上述重构技巧。通过深入研究这些资源，开发者能够提升代码质量，减少维护成本，并且增强对业务...
深入Python设计模式：从原理到实战的重构源码
03-25
项目标题：《深入Python设计模式：原理与实践的重构之旅》 项目概述： 本项目致力于探索和学习Python中的设计模式，通过实际的代码重构来深化理解。项目包含35个文件，主要以Python语言编写，同时涉及Java语言的一...
网站设计分析：模块化--高效重构
09-25
今天来分析一下网站模块化,网站高效重构
【设计模式-2】策略模式 - 避免冗余的if-else判断。数据库迁移框架、flink 类型转换框架例子对策略模式的使用
hiliang521的博客
11-16 1730
【设计模式-2】策略模式 - 避免冗余的if-else判断。数据库迁移框架、flink 类型转换框架例子对策略模式的使用
设计模式(21) 状态模式
zhixin9001的博客
09-07 590
状态模式允许一个对象在其内部状态改变时改变它的行为。用电梯来举例，电梯可以认为具有开门、关门、运行、停止四种状态，这四种状态之间的切换具有多种限制，比如在开门状态下不电梯不能运行，只能转为关门状态；在运行状态下，电梯只能转为停止状态… 设想一下，如果要常规的if-else或者switch-case描述电梯的这几种状态间的切换，将生成非常复杂的、逻辑相互交织的代码，可读性差且不易维护。 而如果用状态模式来实现，会是怎样的呢？ 首先创建LiftState，代表抽象的电梯状态，包含了电梯的四个动作（方法），通过这
步步为营 .NET 代码重构学习笔记系列总结
weixin_33735077的博客
01-08 237
历时一个多月的时间,代码重构系列终于写完了,代码的坏味道大家一看都不会陌生，绝对是在我们的编程中如影随形的，现在把相应的重构方法和设计模式总结出来，以供大家参考.因为不论是重构还是应用设计模式，一切的目的都是为了软件构架的“优雅”，而不是炫耀技术。 步步为营 .NET 代码重构学习笔记系列 步步为营 .NET 代码重构学习笔记 一、为何要代码重构 步步为营 .NET 代码重构学习笔记 二、...
干货 去掉 if...else 的七种绝佳方法
03-09 298
在一些语言中，如 C++11 和 Java 14 之后的版本，可以使用 switch 表达式来简化多个条件分支的处理。在面向对象编程中，多态允许我们根据对象的实际类型执行不同的行为。通过将行为定义在子类中，可以避免在父类中使用复杂的。通过将对象的行为定义在不同的状态类中，可以避免在对象中大量使用。通过将函数作为参数传递给其他函数，可以根据传入的函数来执行不同的逻辑，从而避免。语句转换为数据驱动的查询，从而提高代码的可读性和可维护性。语句的使用，从而提高代码的质量和可维护性。在 Java 中，可以使用。
干掉if else！试试这三种设计模式，优化代码贼顺手！
芋艿V
06-21 2459
点击上方“芋道源码”，选择“设为星标”管她前浪，还是后浪？能浪的浪，才是好浪！每天 10:33更新文章，每天掉亿点点头发...源码精品专栏原创 | Java 2021超神之路，很肝~中文详细注释的开源项目RPC 框架 Dubbo 源码解析网络应用框架 Netty 源码解析消息中间件 RocketMQ 源码解析数据库中间件 Sharding-JDBC 和 MyCAT ...
软件配置管理（五）常用重构技巧
weixin_45668903的博客
06-15 695
文章目录一、重构列表二、重新组织函数三、在对象之间搬移特性四、重新组织数据五、简化条件表达式六、 简化函数调用七、处理概括关系八、大型重构 一、重构列表 二、重新组织函数 三、在对象之间搬移特性 四、重新组织数据 五、简化条件表达式 六、 简化函数调用 七、处理概括关系 八、大型重构 ...
java消除if else设计模式
09-10
在Java中，可以使用一些设计模式来减少或消除if-else语句的使用。以下是一些常用的设计模式示例： 1. 策略模式（Strategy Pattern）：该模式允许根据不同的策略执行不同的操作，而不需要使用大量的if-else语句。你可以创建一个接口或抽象类来定义策略，然后针对每个具体的策略实现相应的类。 2. 工厂模式（Factory Pattern）：该模式可以用来创建对象，而不需要在客户端代码中使用if-else语句来决定实例化哪个具体类。你可以创建一个工厂类，该类负责根据特定条件返回相应的对象实例。 3. 观察者模式（Observer Pattern）：该模式允许一个对象（主题）维护一系列依赖于它的对象（观察者），并自动通知它们任何状态的变化。通过使用观察者模式，你可以避免使用大量的if-else语句来处理不同的观察者逻辑。 4. 模板方法模式（Template Method Pattern）：该模式定义了一个算法的骨架，将某些步骤延迟到子类中实现。通过使用模板方法模式，你可以避免在父类中使用if-else来判断具体的实现。 5. 状态模式（State Pattern）：该模式允许对象在内部状态发生改变时改变它的行为。通过使用状态模式，你可以避免在一个对象中使用复杂的if-else语句来根据不同的状态执行不同的操作。 这些设计模式提供了一种更优雅和可维护的方式来处理复杂的逻辑，减少了if-else语句的使用。在实际开发中，根据具体的需求选择适合的设计模式可以更好地组织代码。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员 jet_qi

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值