经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » 设计模式 » 查看文章
策略模式与模板方法模式
来源：cnblogs　　作者：废物大师兄　　时间：2021/1/18 16:28:05　　对本文有异议

1.  策略模式

策略模式是一种行为设计模式，它能让你定义一系列算法，并将每种算法分别放入独立的类中，以使算法的对象能够相互替换。

当你有许多仅在执行某些行为时略有不同的相似类时，可使用策略模式。使用该模式能将类的业务逻辑与其算法实现细节隔离开来。

说白了，其实还是解耦

策略模式的结构如上图所示，主要包含三个角色：

  • 抽象角色：通常是一个接口
  • 具体角色：接口的具体实现
  • 环境角色：调用接口的上下文环境，通常是一段业务逻辑方法

举个常见的例子：支付

先定义一个接口 PayStrategy.java

  1. package com.example.service;
  3. import com.example.domain.dto.PayDTO;
  4. import com.example.domain.dto.PayDetailDTO;
  6. /**
  7.  * @author ChengJianSheng
  8.  * @date 2021/1/11
  9.  */
  10. public interface PayStrategy {
  12.     /**
  13.      * 下单
  14.      */
  15.     PayDTO prepay();
  17.     /**
  18.      * 查询
  19.      */
  20.     PayDetailDTO query();
  22.     /**
  23.      * 撤销
  24.      */
  25.     void cancel();
  27.     /**
  28.      * 退款
  29.      */
  30.     void refund();
  32. } 

然后是具体实现

AlipayStrategy.java 

  1. package com.example.service.impl;
  3. import com.alipay.api.AlipayClient;
  4. import com.alipay.api.request.AlipayTradePrecreateRequest;
  5. import com.alipay.api.response.AlipayTradeCancelResponse;
  6. import com.example.domain.dto.PayDTO;
  7. import com.example.domain.dto.PayDetailDTO;
  8. import com.example.service.PayStrategy;
  9. import org.springframework.beans.factory.annotation.Autowired;
  10. import org.springframework.stereotype.Component;
  12. /**
  13.  * https://opendocs.alipay.com/open/common/abilitymap
  14.  * https://opendocs.alipay.com/open/194/106078
  15.  * 扫码支付
  16.  */
  17. @Component
  18. public class AlipayStrategy implements PayStrategy {
  20.     @Autowired
  21.     private AlipayClient alipayClient;
  23.     @Override
  24.     public PayDTO prepay() {
  25.         AlipayTradePrecreateRequest request = new AlipayTradePrecreateRequest();
  26.         AlipayTradeCancelResponse response = alipayClient.execute(request);
  27.         return null;
  28.     }
  30.     @Override
  31.     public PayDetailDTO query() {
  32.         return null;
  33.     }
  35.     @Override
  36.     public void cancel() {
  38.     }
  40.     @Override
  41.     public void refund() {
  43.     }
  45.     public void payNotify(String data) {
  47.     }
  49.     public void refundNotify() {
  51.     }
  52. }

WeixinPayStrategy.java

  1. package com.example.service.impl;
  3. import com.example.domain.dto.PayDTO;
  4. import com.example.domain.dto.PayDetailDTO;
  5. import com.example.service.PayStrategy;
  6. import com.github.binarywang.wxpay.bean.notify.WxPayOrderNotifyResult;
  7. import com.github.binarywang.wxpay.bean.request.WxPayOrderQueryRequest;
  8. import com.github.binarywang.wxpay.bean.request.WxPayUnifiedOrderRequest;
  9. import com.github.binarywang.wxpay.service.WxPayService;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import org.springframework.stereotype.Component;
  13. /**
  14.  * https://pay.weixin.qq.com/wiki/doc/apiv3/wxpay/pages/index.shtml
  15.  * https://github.com/Wechat-Group/WxJava/wiki/%E5%BE%AE%E4%BF%A1%E6%94%AF%E4%BB%98
  16.  * @author ChengJianSheng
  17.  * @date 2021/1/11
  18.  */
  19. @Component
  20. public class WeixinPayStrategy implements PayStrategy {
  22.     @Autowired
  23.     private WxPayService wxPayService;
  25.     @Override
  26.     public PayDTO prepay() {
  27.         WxPayUnifiedOrderRequest request = new WxPayUnifiedOrderRequest();
  28.         wxPayService.createOrder(request);
  29.         return null;
  30.     }
  32.     @Override
  33.     public PayDetailDTO query() {
  34.         WxPayOrderQueryRequest request = new WxPayOrderQueryRequest();
  35.         wxPayService.queryOrder(request);
  36.         return null;
  37.     }
  39.     @Override
  40.     public void cancel() {
  42.     }
  44.     @Override
  45.     public void refund() {
  47.     }
  49.     public void payNotify(String data) {
  50.         WxPayOrderNotifyResult result = wxPayService.parseOrderNotifyResult(data);
  51.     }
  53.     public void refundNotify(String data) {
  54.         WxPayOrderNotifyResult result = wxPayService.parseRefundNotifyResult(data);
  55.     }
  56. } 

上下文

  1. package com.example.service.impl;
  3. import com.example.domain.dto.PayDTO;
  4. import com.example.service.PayService;
  5. import com.example.service.PayStrategy;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Service;
  9. /**
  10.  * @author ChengJianSheng
  11.  * @date 2021/1/11
  12.  */
  13. @Service
  14. public class PayServiceImpl implements PayService {
  15.     @Autowired
  16.     private AlipayStrategy alipayStrategy;
  17.     @Autowired
  18.     private WeixinPayStrategy weixinPayStrategy;
  20.     @Override
  21.     public void prePay(PayDTO payDTO) {
  22.         //  创建支付订单
  23.         //  组装参数
  24.         PayStrategy payStrategy = null;
  25.         if (payDTO.getChannel() == 1) {
  26.             payStrategy = alipayStrategy;
  27.         } else {
  28.             payStrategy = weixinPayStrategy;
  29.         }
  31.         payStrategy.prepay();
  33.     }
  34. } 

这样就将算法的细节与业务逻辑隔离开，开发始终要遵循的原则是：高内聚，低耦合

其余部分代码补充如下：

pom.xml

  1. <dependency>
  2.     <groupId>com.alipay.sdk</groupId>
  3.     <artifactId>alipay-sdk-java</artifactId>
  4.     <version>4.11.8.ALL</version>
  5. </dependency>
  6. <dependency>
  7.     <groupId>com.github.binarywang</groupId>
  8.     <artifactId>weixin-java-pay</artifactId>
  9.     <version>4.0.0</version>
  10. </dependency>

 AlipayConfig.java

  1. package com.example.config;
  3. import com.alipay.api.AlipayClient;
  4. import com.alipay.api.DefaultAlipayClient;
  5. import org.springframework.beans.factory.annotation.Value;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  9. /**
  10.  * 扫码支付
  11.  * https://opendocs.alipay.com/open/194/106078
  12.  * https://opendocs.alipay.com/open/common/abilitymap
  13.  *
  14.  * @author ChengJianSheng
  15.  * @date 2021/1/11
  16.  */
  17. @Configuration
  18. public class AlipayConfig {
  19.     @Value("${alipay.appId}")
  20.     private String appId;
  21.     @Value("${alipay.privateKey}")
  22.     private String privateKey;
  23.     @Value("${alipay.publicKey}")
  24.     private String publicKey;
  26.     @Bean
  27.     public AlipayClient alipayClient() {
  28.         AlipayClient alipayClient = new DefaultAlipayClient("https://openapi.alipay.com/gateway.do", appId, privateKey, "json", "UTF-8", publicKey, "RSA2");
  29.         return alipayClient;
  30.     }
  31. }

WeixinPayConfig.java 

  1. package com.example.config;
  3. import com.github.binarywang.wxpay.config.WxPayConfig;
  4. import com.github.binarywang.wxpay.service.WxPayService;
  5. import com.github.binarywang.wxpay.service.impl.WxPayServiceImpl;
  6. import org.springframework.beans.factory.annotation.Value;
  7. import org.springframework.context.annotation.Bean;
  8. import org.springframework.context.annotation.Configuration;
  10. /**
  11.  * https://pay.weixin.qq.com/wiki/doc/apiv3/index.shtml
  12.  * https://github.com/Wechat-Group/WxJava/wiki/%E5%BE%AE%E4%BF%A1%E6%94%AF%E4%BB%98
  13.  * @author ChengJianSheng
  14.  * @date 2021/1/11
  15.  */
  16. @Configuration
  17. public class WeixinPayConfig {
  18.     /**
  19.      * 公众号appid
  20.      */
  21.     @Value("${weixin.pay.appId}")
  22.     private String appId;
  23.     /**
  24.      * 商户号.
  25.      */
  26.     @Value("${weixin.pay.mchId}")
  27.     private String mchId;
  28.     /**
  29.      * 商户密钥.
  30.      */
  31.     @Value("${weixin.pay.mchKey}")
  32.     private String mchKey;
  34.     @Value("${weixin.pay.notifyUrl}")
  35.     private String notifyUrl;
  37.     @Bean
  38.     public WxPayService wxPayService() {
  39.         WxPayConfig payConfig = new WxPayConfig();
  40.         payConfig.setAppId(appId);
  41.         payConfig.setMchId(mchId);
  42.         payConfig.setMchKey(mchKey);
  43.         payConfig.setNotifyUrl(notifyUrl);
  45.         WxPayService wxPayService = new WxPayServiceImpl();
  46.         wxPayService.setConfig(payConfig);
  47.         return wxPayService;
  48.     }
  49. }

2.  模板方法模式

模板方法模式是一种行为设计模式，它在超类中定义了一个算法的框架，允许子类在不修改结构的情况下重写算法的特定步骤。 

当多个类的算法除一些细微不同之外几乎完全一样时，可使用该模式。

这里，“算法”应理解为一个功能，或者一段业务逻辑 

模板方法模式的结构如上图所示，主要实现方式是

  1. 将一些公共的逻辑抽象出来，将功能实现分解为多个步骤
  2. 定义抽象类，将有差异的步骤声明为抽象方法
  3. 子类继承抽象基类，实现其中的抽象方法 

模板方法减少了重复代码，将公共代码提到基类中，子类只需关注各自差异化的逻辑 

上面的支付，也可以用模板方法模式来实现。

个人觉得，策略模式、工厂方法模式、模板方法模式，这三个都比较像。能用模板方法模式的地方，通常也可以用策略模式。

只是它们的侧重点不一样，策略模式的侧重点在于可以动态切换算法，即同样的参数，用不同的策略执行，可以得到不同的结果。

而模板方法模式的侧重点在于算法结构不变，中间的某些步骤的具体实现可以不同。

如果我们把策略模式中的上下文看成一个算法的话，那策略模式中的具体实现就是特定的步骤，这么一想，感觉二者太像了。

模板方法模式有一个活生生的例子是java.io.InputStream。InputStream中定义了一个抽象的read()方法，从流中读取数据的方法时一样的，只是从什么流中读取的问题，可以从文件流中读，也可以从网络流中读。

最后，不要为了用设计模式而用设计模式。

https://refactoringguru.cn/design-patterns

原文链接：http://www.cnblogs.com/cjsblog/p/14272184.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

设计模式热门文章

  • java设计模式-装饰者模式详解
  • 设计模式之迭代器与组合模式（四）
  • asp.net Core 中AuthorizationHandler 实现自定义授权
  • 高校宿舍管理系统详细需求分析说明书
  • 依赖注入与控制反转
  • 设计模式-工厂方法模式 实战演习 代码实现 - Code-CHAN
  • 报刊订阅管理系统的设计与实现
  • 深入浅出设计模式 PDF下载高清完整扫描原版
  • TypeScript实现设计模式——生成器模式
  • 小账本软件设计之数据库设计模式构建

    • 设计模式推荐文章

  • 设计模式：代理模式详解
  • 设计模式之工厂模式（学习笔记）
  • Java设计模式总结
  • Java面试题：Spring框架除了IOC和AOP，还有哪些好玩的设计模式？
  • 什么是设计模式？
  • 设计模式学习（一）单例模式的几种实现方式
  • 我们在SqlSugar开发框架中，用到的一些设计模式
  • 3分钟看懂设计模式01：策略模式
  • 设计模式浅析(三) &#183;装饰者模式
  • GOF23--23种设计模式（一）

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号