策略模式是一种行为设计模式，它能让你定义一系列算法，并将每种算法分别放入独立的类中，以使算法的对象能够相互替换。
当你有许多仅在执行某些行为时略有不同的相似类时，可使用策略模式。使用该模式能将类的业务逻辑与其算法实现细节隔离开来。
说白了，其实还是解耦
策略模式的结构如上图所示，主要包含三个角色：
- 抽象角色：通常是一个接口
- 具体角色：接口的具体实现
- 环境角色：调用接口的上下文环境，通常是一段业务逻辑方法
举个常见的例子：支付
先定义一个接口 PayStrategy.java
package com.example.service;
import com.example.domain.dto.PayDTO;
import com.example.domain.dto.PayDetailDTO;
public interface PayStrategy {
PayDTO prepay();
PayDetailDTO query();
void cancel();
void refund();
}
然后是具体实现
AlipayStrategy.java
package com.example.service.impl;
import com.alipay.api.AlipayClient;
import com.alipay.api.request.AlipayTradePrecreateRequest;
import com.alipay.api.response.AlipayTradeCancelResponse;
import com.example.domain.dto.PayDTO;
import com.example.domain.dto.PayDetailDTO;
import com.example.service.PayStrategy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class AlipayStrategy implements PayStrategy {
@Autowired
private AlipayClient alipayClient;
@Override
public PayDTO prepay() {
AlipayTradePrecreateRequest request = new AlipayTradePrecreateRequest();
AlipayTradeCancelResponse response = alipayClient.execute(request);
return null;
}
@Override
public PayDetailDTO query() {
return null;
}
@Override
public void cancel() {
}
@Override
public void refund() {
}
public void payNotify(String data) {
}
public void refundNotify() {
}
}
WeixinPayStrategy.java
package com.example.service.impl;
import com.example.domain.dto.PayDTO;
import com.example.domain.dto.PayDetailDTO;
import com.example.service.PayStrategy;
import com.github.binarywang.wxpay.bean.notify.WxPayOrderNotifyResult;
import com.github.binarywang.wxpay.bean.request.WxPayOrderQueryRequest;
import com.github.binarywang.wxpay.bean.request.WxPayUnifiedOrderRequest;
import com.github.binarywang.wxpay.service.WxPayService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
@Component
public class WeixinPayStrategy implements PayStrategy {
@Autowired
private WxPayService wxPayService;
@Override
public PayDTO prepay() {
WxPayUnifiedOrderRequest request = new WxPayUnifiedOrderRequest();
wxPayService.createOrder(request);
return null;
}
@Override
public PayDetailDTO query() {
WxPayOrderQueryRequest request = new WxPayOrderQueryRequest();
wxPayService.queryOrder(request);
return null;
}
@Override
public void cancel() {
}
@Override
public void refund() {
}
public void payNotify(String data) {
WxPayOrderNotifyResult result = wxPayService.parseOrderNotifyResult(data);
}
public void refundNotify(String data) {
WxPayOrderNotifyResult result = wxPayService.parseRefundNotifyResult(data);
}
}
上下文
package com.example.service.impl;
import com.example.domain.dto.PayDTO;
import com.example.service.PayService;
import com.example.service.PayStrategy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class PayServiceImpl implements PayService {
@Autowired
private AlipayStrategy alipayStrategy;
@Autowired
private WeixinPayStrategy weixinPayStrategy;
@Override
public void prePay(PayDTO payDTO) {
// 创建支付订单
// 组装参数
PayStrategy payStrategy = null;
if (payDTO.getChannel() == 1) {
payStrategy = alipayStrategy;
} else {
payStrategy = weixinPayStrategy;
}
payStrategy.prepay();
}
}
这样就将算法的细节与业务逻辑隔离开，开发始终要遵循的原则是：高内聚，低耦合
其余部分代码补充如下：
pom.xml
com.alipay.sdk alipay-sdk-java4.11.8.ALL com.github.binarywang weixin-java-pay4.0.0
AlipayConfig.java
package com.example.config;
import com.alipay.api.AlipayClient;
import com.alipay.api.DefaultAlipayClient;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class AlipayConfig {
@Value("${alipay.appId}")
private String appId;
@Value("${alipay.privateKey}")
private String privateKey;
@Value("${alipay.publicKey}")
private String publicKey;
@Bean
public AlipayClient alipayClient() {
AlipayClient alipayClient = new DefaultAlipayClient("https://openapi.alipay.com/gateway.do", appId, privateKey, "json", "UTF-8", publicKey, "RSA2");
return alipayClient;
}
}
WeixinPayConfig.java
package com.example.config;
import com.github.binarywang.wxpay.config.WxPayConfig;
import com.github.binarywang.wxpay.service.WxPayService;
import com.github.binarywang.wxpay.service.impl.WxPayServiceImpl;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class WeixinPayConfig {
@Value("${weixin.pay.appId}")
private String appId;
@Value("${weixin.pay.mchId}")
private String mchId;
@Value("${weixin.pay.mchKey}")
private String mchKey;
@Value("${weixin.pay.notifyUrl}")
private String notifyUrl;
@Bean
public WxPayService wxPayService() {
WxPayConfig payConfig = new WxPayConfig();
payConfig.setAppId(appId);
payConfig.setMchId(mchId);
payConfig.setMchKey(mchKey);
payConfig.setNotifyUrl(notifyUrl);
WxPayService wxPayService = new WxPayServiceImpl();
wxPayService.setConfig(payConfig);
return wxPayService;
}
}
2. 模板方法模式
模板方法模式是一种行为设计模式，它在超类中定义了一个算法的框架，允许子类在不修改结构的情况下重写算法的特定步骤。
当多个类的算法除一些细微不同之外几乎完全一样时，可使用该模式。
这里，“算法”应理解为一个功能，或者一段业务逻辑
模板方法模式的结构如上图所示，主要实现方式是
- 将一些公共的逻辑抽象出来，将功能实现分解为多个步骤
- 定义抽象类，将有差异的步骤声明为抽象方法
- 子类继承抽象基类，实现其中的抽象方法
模板方法减少了重复代码，将公共代码提到基类中，子类只需关注各自差异化的逻辑
上面的支付，也可以用模板方法模式来实现。
个人觉得，策略模式、工厂方法模式、模板方法模式，这三个都比较像。能用模板方法模式的地方，通常也可以用策略模式。
只是它们的侧重点不一样，策略模式的侧重点在于可以动态切换算法，即同样的参数，用不同的策略执行，可以得到不同的结果。
而模板方法模式的侧重点在于算法结构不变，中间的某些步骤的具体实现可以不同。
如果我们把策略模式中的上下文看成一个算法的话，那策略模式中的具体实现就是特定的步骤，这么一想，感觉二者太像了。
模板方法模式有一个活生生的例子是java.io.InputStream。InputStream中定义了一个抽象的read()方法，从流中读取数据的方法时一样的，只是从什么流中读取的问题，可以从文件流中读，也可以从网络流中读。
最后，不要为了用设计模式而用设计模式。
以上就是Java 策略模式与模板方法模式相关总结的详细内容，更多关于Java 策略模式与模板方法模式的资料请关注考高分网其它相关文章！
