别再满屏的 if/else 了,试试策略模式,真香!!

开发 前端
栈长在开发人员的代码中看过太多这样的低级代码了,真的太 low,极不好维护,本文栈长就教你如何用策略模式干掉 if/ else/ switch,让你的代码更优雅。

 [[399910]]

你还在写满屏的 if/ else/ switch 之类的判断逻辑吗?

栈长在开发人员的代码中看过太多这样的低级代码了,真的太 low,极不好维护,本文栈长就教你如何用策略模式干掉 if/ else/ switch,让你的代码更优雅。

什么是策略模式?

比如说对象的某个行为,在不同场景中有不同的实现方式,这样就可以将这些实现方式定义成一组策略,每个实现类对应一个策略,在不同的场景就使用不同的实现类,并且可以自由切换策略。

策略模式结构图如下:

策略模式需要一个策略接口,不同的策略实现不同的实现类,在具体业务环境中仅持有该策略接口,根据不同的场景使用不同的实现类即可。

面向接口编程,而不是面向实现。

策略模式的优点:

1、干掉繁琐的 if、switch 判断逻辑;

2、代码优雅、可复用、可读性好;

3、符合开闭原则,扩展性好、便于维护;

策略模式的缺点:

1、策略如果很多的话,会造成策略类膨胀;

2、使用者必须清楚所有的策略类及其用途;

策略模式实战

举个实际的例子,XX 公司是做支付的,根据不同的客户类型会有不同的支付方式和支付产品,比如:信用卡、本地支付,而本地支付在中国又有微信支付、支付宝、云闪付、等更多其他第三方支付公司,这时候策略模式就派上用场了。

传统的 if/ else/ switch 等判断写法大家都会写,这里就不贴代码了,直接看策略模式怎么搞!

1、定义策略接口

定义一个策略接口,所有支付方式的接口。

策略接口:

  1. /** 
  2.  * 支付接口 
  3.  * @author: 栈长 
  4.  * @from: 公众号Java技术栈 
  5.  */ 
  6. public interface IPayment { 
  7.  
  8.     /** 
  9.      * 支付 
  10.      * @param order 
  11.      * @return 
  12.      */ 
  13.     PayResult pay(Order order); 
  14.  

订单信息类:

  1. /** 
  2.  * 订单信息 
  3.  * @author: 栈长 
  4.  * @from: 公众号Java技术栈 
  5.  */ 
  6. @Data 
  7. public class Order { 
  8.  
  9.     /** 
  10.      * 金额 
  11.      */ 
  12.     private int amount; 
  13.  
  14.     /** 
  15.      * 支付类型 
  16.      */ 
  17.     private String paymentType; 
  18.  

返回结果类:

  1. /** 
  2.  * @author: 栈长 
  3.  * @from: 公众号Java技术栈 
  4.  */ 
  5. @Data 
  6. @AllArgsConstructor 
  7. public class PayResult { 
  8.  
  9.     /** 
  10.      * 支付结果 
  11.      */ 
  12.     private String result; 
  13.  

2、定义各种策略

定义各种支付策略,微信支付、支付宝、云闪付等支付实现类都实现这个接口。

微信支付实现:

  1. /** 
  2.  * 微信支付 
  3.  * @author: 栈长 
  4.  * @from: 公众号Java技术栈 
  5.  */ 
  6. @Service("WechatPay"
  7. public class WechatPay implements IPayment { 
  8.  
  9.     @Override 
  10.     public PayResult pay(Order order) { 
  11.         return new PayResult("微信支付成功"); 
  12.     } 
  13.  

支付宝实现:

  1. /** 
  2.  * 支付宝 
  3.  * @author: 栈长 
  4.  * @from: 公众号Java技术栈 
  5.  */ 
  6. @Service("Alipay"
  7. public class Alipay implements IPayment { 
  8.  
  9.     @Override 
  10.     public PayResult pay(Order order) { 
  11.         return new PayResult("支付宝支付成功"); 
  12.     } 
  13.  

云闪付实现:

  1. /** 
  2.  * 银联云闪付 
  3.  * @author: 栈长 
  4.  * @from: 公众号Java技术栈 
  5.  */ 
  6. @Service("UnionPay"
  7. public class UnionPay implements IPayment { 
  8.  
  9.     @Override 
  10.     public PayResult pay(Order order) { 
  11.         return new PayResult("云闪付支付成功"); 
  12.     } 
  13.  

这里我把所有支付方式类都用 @Service 注解生成 Bean 放入 Spring Bean 容器中了,在使用策略的时候就不用 new 支付对象了,可以直接使用 Bean,这样更贴近业务。Spring 基础教程就不介绍了,大家可以关注公众号Java技术栈,回复:spring,历史教程我都整理好了。

3、使用策略

有的文章使用了枚举、HashMap 的方式来根据策略名称映射策略实现类 ,这样是没有问题,但在使用了 Spring 框架的项目还是有点多此一举,完全可以发挥 Spring 框架的优势,使用 Bean 名称就能找到对应的策略实现类了。

参考示例代码如下:

  1. /** 
  2.  * 支付服务 
  3.  * @author: 栈长 
  4.  * @from: 公众号Java技术栈 
  5.  */ 
  6. @RestController 
  7. public class PayService { 
  8.  
  9.     @Autowired 
  10.     private ApplicationContext applicationContext; 
  11.  
  12.     /** 
  13.      * 支付接口 
  14.      * @param amount 
  15.      * @param paymentType 
  16.      * @return 
  17.      */ 
  18.     @RequestMapping("/pay"
  19.     public PayResult pay(@RequestParam("amount"int amount, 
  20.                     @RequestParam("paymentType") String paymentType) { 
  21.         Order order = new Order(); 
  22.         order.setAmount(amount); 
  23.         order.setPaymentType(paymentType); 
  24.  
  25.         // 根据支付类型获取对应的策略 bean 
  26.         IPayment payment = applicationContext.getBean(order.getPaymentType(), IPayment.class); 
  27.  
  28.         // 开始支付 
  29.         PayResult payResult = payment.pay(order); 
  30.  
  31.         return payResult; 
  32.     } 
  33.  

看示例代码,我并没有像策略模式结构图中那样新建一个 Context 类持有策略接口,那是标准的策略模式,其实道理是一样的,关键是怎么施放策略。

测试一下:

http://localhost:8080/pay?amount=8800&paymentType=WechatPay

测试 OK,传入不同的支付方式会调用不同的策略。

本节教程所有实战源码已上传到这个仓库:https://github.com/javastacks/javastack

策略模式在 JDK 中的应用

现在我们知道如何使用策略模式了,现在我们再看看 JDK 哪些地方运用了策略模式呢。

1、线程池中的拒绝策略

线程池的构造中有一个拒绝策略参数,默认是默认拒绝策略:

其实这就是一个策略接口:

下面有几种拒绝策略的实现:

image-20210329161322406

在创建线程池的时候,就可以传入不同的拒绝策略,这就是 JDK 中策略模式的经典实现了。

2、比较器

JDK 中大量使用了 Comparator 这个策略接口:

策略接口有了,但策略需要开发人员自己定。

集合排序我们比较熟悉的了,不同的排序规则其实就是不同的策略:

这个策略模式使用了函数式编程接口,比较规则使用匿名内部类或者 Lambda 表达式就搞定了,不需要每个规则定义一个实现类,这样就大量省略策略类了。

这个策略模式可能藏的比较深,但也是 JDK 中经典的策略模式的应用了。

不限于这两个,其实还有更多,你还知道别的么?欢迎留言分享……

所以说,策略模式就在你身边,你一直都在用,但可能没有发觉。。

总结

使用策略模式,我们可以轻松干掉大量的 if/ else,代码也更优雅,还能很灵活的扩展。

像本文中支付的案例,后面我们想添加、删除多少个支付方式都不用修改现有的代码,所以就不会影响现有的业务,真正做到对扩展开放,对修改关闭。

当然,完全干掉 if/ else 是不可能的,不能过度设计,不能为了使用设计模式而使用设计模式,否则适得其反。但是,我们每个程序员都需要掌握策略模式,做到在系统中灵活驾驭,这样才能写出更优雅、高质量的代码。

本节教程所有实战源码已上传到这个仓库:

https://github.com/javastacks/javastack

本文转载自微信公众号「Java技术栈」,可以通过以下二维码关注。转载本文请联系Java技术栈公众号。

 

责任编辑:武晓燕 来源: Java技术栈
相关推荐

2020-06-15 08:12:51

try catch代码处理器

2021-03-10 07:20:43

if-else静态代码

2021-04-13 06:39:13

代码重构code

2022-07-11 08:16:55

策略模式if-else

2023-03-28 08:58:47

分库分表TiDB

2020-06-04 09:18:52

CTOif-else代码

2020-04-09 08:29:50

编程语言事件驱动

2022-12-27 08:01:09

设计模式https://mp

2021-04-27 20:04:11

策略模式设计

2022-03-08 13:46:22

httpClientHTTP前端

2022-01-13 10:45:59

if-else代码Java

2022-06-14 10:49:33

代码优化Java

2024-03-11 08:21:49

2021-02-15 22:07:18

项目策略模式

2023-05-16 08:31:09

BrokerReef版本

2021-04-14 14:40:37

forSpringJava

2022-05-27 21:56:55

索引存储MySQL 存储引擎

2022-07-01 14:20:49

Redis策略函数

2022-11-16 08:58:33

Go模版模式策略模式

2024-03-04 10:36:39

点赞
收藏

51CTO技术栈公众号