• 9条消除if...else绝招，写出的代码效率更高了

    前言

    最近在做代码重构，发现了很多代码的烂味道。其他的不多说，今天主要说说那些又臭又长的if...else要如何重构。

    在介绍更更优雅的编程之前，让我们一起回顾一下，不好的if...else代码

    一、又臭又长的if...else

    废话不多说，先看看下面的代码。

    1. public interface IPay {  
    2.     void pay();  
    3. }  
    4.  
    5. @Service  
    6. public class AliaPay implements IPay {  
    7.      @Override  
    8.      public void pay() {  
    9.         System.out.println("===发起支付宝支付===");  
    10.      }  
    11. }  
    12.  
    13. @Service  
    14. public class WeixinPay implements IPay {  
    15.      @Override  
    16.      public void pay() {  
    17.          System.out.println("===发起微信支付===");  
    18.      }  
    19. }  
    20.   
    21. @Service  
    22. public class JingDongPay implements IPay {  
    23.      @Override  
    24.      public void pay() {  
    25.         System.out.println("===发起京东支付===");  
    26.      }  
    27. }  
    28.  
    29. @Service  
    30. public class PayService {  
    31.      @Autowired  
    32.      private AliaPay aliaPay;  
    33.      @Autowired  
    34.      private WeixinPay weixinPay;  
    35.      @Autowired  
    36.      private JingDongPay jingDongPay;  
    37.     
    38.    
    39.      public void toPay(String code) {  
    40.          if ("alia".equals(code)) {  
    41.              aliaPay.pay();  
    42.          } else if ("weixin".equals(code)) {  
    43.               weixinPay.pay();  
    44.          } else if ("jingdong".equals(code)) {  
    45.               jingDongPay.pay();  
    46.          } else {  
    47.               System.out.println("找不到支付方式");  
    48.          }  
    49.      }  
    50. }

    PayService类的toPay方法主要是为了发起支付，根据不同的code，决定调用用不同的支付类（比如：aliaPay）的pay方法进行支付。

    这段代码有什么问题呢？也许有些人就是这么干的。

    试想一下，如果支付方式越来越多，比如：又加了百度支付、美团支付、银联支付等等，就需要改toPay方法的代码，增加新的else...if判断，判断多了就会导致逻辑越来越多？

    很明显，这里违法了设计模式六大原则的：开闭原则 和 单一职责原则。

    ❝

    开闭原则：对扩展开放，对修改关闭。就是说增加新功能要尽量少改动已有代码。

    ❞
    ❝

    单一职责原则：顾名思义，要求逻辑尽量单一，不要太复杂，便于复用。

    ❞

    那有什么办法可以解决这个问题呢？

    二、消除if...else的锦囊妙计

    1、使用注解

    代码中之所以要用code判断使用哪个支付类，是因为code和支付类没有一个绑定关系，如果绑定关系存在了，就可以不用判断了。

    我们先定义一个注解。

    1. @Retention(RetentionPolicy.RUNTIME)  
    2. @Target(ElementType.TYPE)  
    3. public @interface PayCode {  
    4.  
    5.      String value();    
    6.      String name();  
    7. }

    在所有的支付类上都加上该注解

    1. @PayCode(value = "alia", name = "支付宝支付")  
    2. @Service  
    3. public class AliaPay implements IPay {  
    4.  
    5.      @Override  
    6.      public void pay() {  
    7.          System.out.println("===发起支付宝支付===");  
    8.      }  
    9. }  
    10.  
    11.  
    12. @PayCode(value = "weixin", name = "微信支付")  
    13. @Service  
    14. public class WeixinPay implements IPay {  
    15.  
    16.      @Override  
    17.      public void pay() {  
    18.          System.out.println("===发起微信支付===");  
    19.      }  
    20. } 
    21.  
    22.  
    23. @PayCode(value = "jingdong", name = "京东支付")  
    24. @Service  
    25. public class JingDongPay implements IPay {  
    26.  
    27.      @Override  
    28.      public void pay() {  
    29.         System.out.println("===发起京东支付===");  
    30.      }  
    31. }

    然后增加最关键的类：

    1. @Service  
    2. public class PayService2 implements ApplicationListener<ContextRefreshedEvent> {  
    3.  
    4.      private static Map<String, IPay> payMap = null;  
    5.      
    6.      @Override  
    7.      public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {  
    8.          ApplicationContext applicationContext = contextRefreshedEvent.getApplicationContext();  
    9.          Map<String, Object> beansWithAnnotation = applicationContext.getBeansWithAnnotation(PayCode.class);  
    10.         
    11.          if (beansWithAnnotation != null) {  
    12.              payMap = new HashMap<>();  
    13.              beansWithAnnotation.forEach((key, value) ->{  
    14.                  String bizType = value.getClass().getAnnotation(PayCode.class).value();  
    15.                  payMap.put(bizType, (IPay) value);  
    16.              });  
    17.          }  
    18.      }  
    19.     
    20.      public void pay(String code) {  
    21.         payMap.get(code).pay();  
    22.      }  
    23. }

    PayService2类实现了ApplicationListener接口，这样在onApplicationEvent方法中，就可以拿到ApplicationContext的实例。我们再获取打了PayCode注解的类，放到一个map中，map中的key就是PayCode注解中定义的value，跟code参数一致，value是支付类的实例。

    这样，每次就可以每次直接通过code获取支付类实例，而不用if...else判断了。如果要加新的支付方法，只需在支付类上面打上PayCode注解定义一个新的code即可。

    注意：这种方式的code可以没有业务含义，可以是纯数字，只有不重复就行。

    2、动态拼接名称

    该方法主要针对code是有业务含义的场景。

    1. @Service  
    2. public class PayService3 implements ApplicationContextAware {   
    3.      private ApplicationContext applicationContext;  
    4.      private static final String SUFFIX = "Pay";  
    5.  
    6.      @Override  
    7.      public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {  
    8.         this.applicationContext = applicationContext;  
    9.      }  
    10.  
    11.      public void toPay(String payCode) {  
    12.          ((IPay) applicationContext.getBean(getBeanName(payCode))).pay();  
    13.      }  
    14.  
    15.      public String getBeanName(String payCode) {  
    16.          return payCode + SUFFIX;  
    17.      }  
    18. }

    我们可以看到，支付类bean的名称是由code和后缀拼接而成，比如：aliaPay、weixinPay和jingDongPay。这就要求支付类取名的时候要特别注意，前面的一段要和code保持一致。调用的支付类的实例是直接从ApplicationContext实例中获取的，默认情况下bean是单例的，放在内存的一个map中，所以不会有性能问题。

    特别说明一下，这种方法实现了ApplicationContextAware接口跟上面的ApplicationListener接口不一样，是想告诉大家获取ApplicationContext实例的方法不只一种。

    3、模板方法判断

    当然除了上面介绍的两种方法之外，spring的源码实现中也告诉我们另外一种思路，解决if...else问题。

    我们先一起看看spring AOP的部分源码，看一下DefaultAdvisorAdapterRegistry的wrap方法

    1.  public Advisor wrap(Object adviceObject) throws UnknownAdviceTypeException {  
    2.      if (adviceObject instanceof Advisor) {  
    3.         return (Advisor) adviceObject;  
    4.      }  
    5.      if (!(adviceObject instanceof Advice)) {  
    6.         throw new UnknownAdviceTypeException(adviceObject);  
    7.      }  
    8.      Advice advice = (Advice) adviceObject;  
    9.      if (advice instanceof MethodInterceptor) {    
    10.         return new DefaultPointcutAdvisor(advice);  
    11.      }  
    12.      for (AdvisorAdapter adapter : this.adapters) {  
    13.          if (adapter.supportsAdvice(advice)) {  
    14.              return new DefaultPointcutAdvisor(advice);  
    15.          }  
    16.      }  
    17.      throw new UnknownAdviceTypeException(advice);  
    18.  }

    重点看看supportAdvice方法，有三个类实现了这个方法。我们随便抽一个类看看

    1. class AfterReturningAdviceAdapter implements AdvisorAdapter, Serializable {  
    2.  
    3.      @Override  
    4.      public boolean supportsAdvice(Advice advice) {  
    5.         return (advice instanceof AfterReturningAdvice);  
    6.      }  
    7.  
    8.      @Override  
    9.      public MethodInterceptor getInterceptor(Advisor advisor) {  
    10.         AfterReturningAdvice advice = (AfterReturningAdvice) advisor.getAdvice();  
    11.         return new AfterReturningAdviceInterceptor(advice);  
    12.      }   
    13. }

    该类的supportsAdvice方法非常简单，只是判断了一下advice的类型是不是AfterReturningAdvice。

    我们看到这里应该有所启发。

    其实，我们可以这样做，定义一个接口或者抽象类，里面有个support方法判断参数传的code是否自己可以处理，如果可以处理则走支付逻辑。

    1. public interface IPay {  
    2.      boolean support(String code);   
    3.      void pay();  
    4. }  
    5.  
    6. @Service  
    7. public class AliaPay implements IPay {   
    8.      @Override  
    9.      public boolean support(String code) {  
    10.         return "alia".equals(code);  
    11.      }  
    12.  
    13.      @Override  
    14.      public void pay() {  
    15.         System.out.println("===发起支付宝支付===");  
    16.      }  
    17. }  
    18.  
    19. @Service  
    20. public class WeixinPay implements IPay {  
    21.  
    22.      @Override  
    23.      public boolean support(String code) {  
    24.         return "weixin".equals(code);  
    25.      }  
    26.  
    27.      @Override  
    28.      public void pay() {  
    29.         System.out.println("===发起微信支付===");  
    30.      }  
    31. }  
    32.  
    33. @Service  
    34. public class JingDongPay implements IPay {  
    35.      @Override  
    36.      public boolean support(String code) {  
    37.         return "jingdong".equals(code);  
    38.      }  
    39.  
    40.      @Override  
    41.      public void pay() {  
    42.         System.out.println("===发起京东支付===");  
    43.      }  
    44. }

    每个支付类都有一个support方法，判断传过来的code是否和自己定义的相等。

    1. @Service  
    2. public class PayService4 implements ApplicationContextAware, InitializingBean {  
    3.  
    4.      private ApplicationContext applicationContext;  
    5.      private List<IPay> payList = null;  
    6.  
    7.      @Override  
    8.      public void afterPropertiesSet() throws Exception {  
    9.          if (payList == null) {  
    10.              payList = new ArrayList<>();  
    11.              Map<String, IPay> beansOfType = applicationContext.getBeansOfType(IPay.class);  
    12.  
    13.              beansOfType.forEach((key, value) -> payList.add(value));  
    14.          }  
    15.      }  
    16.  
    17.      @Override  
    18.      public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {  
    19.         this.applicationContext = applicationContext;  
    20.      }  
    21.  
    22.      public void toPay(String code) {  
    23.          for (IPay iPay : payList) {  
    24.              if (iPay.support(code)) {  
    25.                 iPay.pay();  
    26.              }  
    27.          }  
    28.      }  
    29. }

    这段代码中先把实现了IPay接口的支付类实例初始化到一个list集合中，返回在调用支付接口时循环遍历这个list集合，如果code跟自己定义的一样，则调用当前的支付类实例的pay方法。

    4.策略+工厂模式

    这种方式也是用于code是有业务含义的场景。

    • 策略模式定义了一组算法，把它们一个个封装起来, 并且使它们可相互替换。

    • 工厂模式用于封装和管理对象的创建，是一种创建型模式。

    1. public interface IPay {
    2.     void pay();
    3. }
    4.  
    5. @Service
    6. public class AliaPay implements IPay {
    7.  
    8.     @PostConstruct
    9.     public void init() {
    10.         PayStrategyFactory.register("aliaPay", this);
    11.     }
    12.  
    13.  
    14.     @Override
    15.     public void pay() {
    16.         System.out.println("===发起支付宝支付===");
    17.     }
    18.  
    19. }
    20.  
    21. @Service
    22. public class WeixinPay implements IPay {
    23.  
    24.     @PostConstruct
    25.     public void init() {
    26.         PayStrategyFactory.register("weixinPay", this);
    27.     }
    28.  
    29.     @Override
    30.     public void pay() {
    31.         System.out.println("===发起微信支付===");
    32.     }
    33. }
    34.  
    35. @Service
    36. public class JingDongPay implements IPay {
    37.  
    38.     @PostConstruct
    39.     public void init() {
    40.         PayStrategyFactory.register("jingDongPay", this);
    41.     }
    42.  
    43.     @Override
    44.     public void pay() {
    45.         System.out.println("===发起京东支付===");
    46.     }
    47. }
    48.  
    49. public class PayStrategyFactory {
    50.  
    51.     private static Map<String, IPay> PAY_REGISTERS = new HashMap<>();
    52.  
    53.  
    54.     public static void register(String code, IPay iPay) {
    55.         if (null != code && !"".equals(code)) {
    56.             PAY_REGISTERS.put(code, iPay);
    57.         }
    58.     }
    59.  
    60.  
    61.     public static IPay get(String code) {
    62.         return PAY_REGISTERS.get(code);
    63.     }
    64. }
    65.  
    66. @Service
    67. public class PayService3 {
    68.  
    69.     public void toPay(String code) {
    70.         PayStrategyFactory.get(code).pay();
    71.     }
    72. }

    这段代码的关键是PayStrategyFactory类，它是一个策略工厂，里面定义了一个全局的map，在所有IPay的实现类中注册当前实例到map中，然后在调用的地方通过PayStrategyFactory类根据code从map获取支付类实例即可。

    5.责任链模式

    这种方式在代码重构时用来消除if...else非常有效。

    • 责任链模式：将请求的处理对象像一条长链一般组合起来，形成一条对象链。请求并不知道具体执行请求的对象是哪一个，这样就实现了请求与处理对象之间的解耦。

    常用的filter、spring aop就是使用了责任链模式，这里我稍微改良了一下，具体代码如下：

    1. public abstract class PayHandler {
    2.  
    3.     @Getter
    4.     @Setter
    5.     protected PayHandler next;
    6.  
    7.     public abstract void pay(String pay);
    8.  
    9. }
    10.  
    11. @Service
    12. public class AliaPayHandler extends PayHandler {
    13.  
    14.  
    15.     @Override
    16.     public void pay(String code) {
    17.         if ("alia".equals(code)) {
    18.             System.out.println("===发起支付宝支付===");
    19.         } else {
    20.             getNext().pay(code);
    21.         }
    22.     }
    23.  
    24. }
    25.  
    26. @Service
    27. public class WeixinPayHandler extends PayHandler {
    28.  
    29.     @Override
    30.     public void pay(String code) {
    31.         if ("weixin".equals(code)) {
    32.             System.out.println("===发起微信支付===");
    33.         } else {
    34.             getNext().pay(code);
    35.         }
    36.     }
    37. }
    38.  
    39. @Service
    40. public class JingDongPayHandler extends PayHandler {
    41.  
    42.  
    43.     @Override
    44.     public void pay(String code) {
    45.         if ("jingdong".equals(code)) {
    46.             System.out.println("===发起京东支付===");
    47.         } else {
    48.             getNext().pay(code);
    49.         }
    50.     }
    51. }
    52.  
    53. @Service
    54. public class PayHandlerChain implements ApplicationContextAware, InitializingBean {
    55.  
    56.     private ApplicationContext applicationContext;
    57.     private PayHandler header;
    58.  
    59.  
    60.     public void handlePay(String code) {
    61.         header.pay(code);
    62.     }
    63.  
    64.     @Override
    65.     public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
    66.         this.applicationContext = applicationContext;
    67.     }
    68.  
    69.     @Override
    70.     public void afterPropertiesSet() throws Exception {
    71.         Map<String, PayHandler> beansOfTypeMap = applicationContext.getBeansOfType(PayHandler.class);
    72.         if (beansOfTypeMap == null || beansOfTypeMap.size() == 0) {
    73.             return;
    74.         }
    75.         List<PayHandler> handlers = beansOfTypeMap.values().stream().collect(Collectors.toList());
    76.         for (int i = 0; i < handlers.size(); i++) {
    77.             PayHandler payHandler = handlers.get(i);
    78.             if (i != handlers.size() - 1) {
    79.                 payHandler.setNext(handlers.get(i + 1));
    80.             }
    81.         }
    82.         header = handlers.get(0);
    83.     }
    84. }

    这段代码的关键是每个PayHandler的子类，都定义了下一个需要执行的PayHandler子类，构成一个链式调用，通过PayHandlerChain把这种链式结构组装起来。

    6、其他的消除if...else的方法

    当然实际项目开发中使用if...else判断的场景非常多，上面只是其中几种场景。下面再列举一下，其他常见的场景。

    1.根据不同的数字返回不同的字符串

    1. public String getMessage(int code) {  
    2.      if (code == 1) {  
    3.         return "成功";  
    4.      } else if (code == -1) {  
    5.         return "失败";  
    6.      } else if (code == -2) {  
    7.         return "网络超时";  
    8.      } else if (code == -3) {  
    9.         return "参数错误";  
    10.      }  
    11.      throw new RuntimeException("code错误");  
    12. }

    其实，这种判断没有必要，用一个枚举就可以搞定。

    1. public enum MessageEnum {  
    2.      SUCCESS(1, "成功"),  
    3.      FAIL(-1, "失败"),  
    4.      TIME_OUT(-2, "网络超时"),  
    5.      PARAM_ERROR(-3, "参数错误");  
    6.  
    7.      private int code;  
    8.      private String message;  
    9.  
    10.      MessageEnum(int code, String message) {  
    11.          this.code = code;  
    12.          this.message = message;  
    13.      }  
    14.    
    15.      public int getCode() {  
    16.         return this.code;  
    17.      }  
    18.  
    19.      public String getMessage() {  
    20.         return this.message;  
    21.      }  
    22.   
    23.      public static MessageEnum getMessageEnum(int code) {  
    24.         return Arrays.stream(MessageEnum.values()).filter(x -> x.code == code).findFirst().orElse(null);  
    25.      }  
    26. }

    再把调用方法稍微调整一下

    1. public String getMessage(int code) {  
    2.      MessageEnum messageEnum = MessageEnum.getMessageEnum(code);  
    3.      return messageEnum.getMessage();  
    4. }

    完美。

    2.集合中的判断

    上面的枚举MessageEnum中的getMessageEnum方法，如果不用java8的语法的话，可能要这样写

    1. public static MessageEnum getMessageEnum(int code) {  
    2.      for (MessageEnum messageEnum : MessageEnum.values()) {  
    3.          if (code == messageEnum.code) {  
    4.             return messageEnum;  
    5.          }  
    6.      }  
    7.      return null;  
    8. }

    对于集合中过滤数据，或者查找方法，java8有更简单的方法消除if...else判断。

    1. public static MessageEnum getMessageEnum(int code) {  
    2.      return Arrays.stream(MessageEnum.values()).filter(x -> x.code == code).findFirst().orElse(null);  
    3. }

    3.简单的判断

    其实有些简单的if...else完全没有必要写，可以用三目运算符代替，比如这种情况：

    1. public String getMessage2(int code) {  
    2.      if(code == 1) {  
    3.         return  "成功";  
    4.      }  
    5.      return "失败";  
    6. }

    改成三目运算符：

    1. public String getMessage2(int code) {  
    2.     return code == 1 ? "成功" : "失败";  
    3. }

    修改之后代码更简洁一些。

    4.spring中的判断

    对于参数的异常，越早被发现越好，在spring中提供了Assert用来帮助我们检测参数是否有效。

    1.  public void save(Integer code，String name) {  
    2.      if(code == null) {
    3.        throw Exception("code不能为空");     
    4.      } else {
    5.          if(name == null) {
    6.              throw Exception("name不能为空");     
    7.          } else {
    8.              System.out.println("doSave");
    9.          }
    10.      }
    11.  }
    12.

    如果参数非常多的话，if...else语句会很长，这时如果改成使用Assert类判断，代码会简化很多：

    1.  public String save2(Integer code，String name) {      
    2.      Assert.notNull(code,"code不能为空"); 
    3.      Assert.notNull(name,"name不能为空"); 
    4.      System.out.println("doSave");
    5.  }
    6.

    当然，还有很多其他的场景可以优化if...else，我再这里就不一一介绍了，感兴趣的朋友可以给我留言，一起探讨和研究一下。

    最后说一句(求关注，别白嫖我)

    如果这篇文章对您有所帮助，或者有所启发的话，帮忙关注一下，您的支持是我坚持写作最大的动力。

     

  • 相关阅读:
    prometheus + grafana + node_exporter 搭建监控服务
    Swift中的协议
    关于ORM框架多表增删改查
    ROS1云课→07基础概念
    加密的手机号，如何模糊查询？
    《代码整洁之道》读书笔记（二）
    Linux 认识与学习Bash——2
    你可得知道物理地址与IP地址
    猿创征文 | Win10安全模式知识介绍，看完你就懂了
    NAT模式LVS负载均衡集群
  • 原文地址：https://blog.csdn.net/m0_72088858/article/details/126747370