设计模式——策略模式实战
六大设计原则
单一职责原则
一个类只负责一个功能领域中的相应职责。高内聚、低耦合。
理解：不同的类具备不同的职责，各司其职。做系统设计是，如果发现有一个类拥有了两种职责，那么就要问一个问题：可以将这个类分成两个类吗？如果真的有必要，那就分开，千万不要让一个类干的事情太多。
开闭原则
对拓展开放，对修改关闭。不修改原有代码的情况下进行拓展。
理解：类、模块、函数，可以去扩展，但不要去修改。如果要修改代码，尽量用继承或组合的方式来扩展类的功能，而不是直接修改类的代码。当然，如果能保证对整个架构不会产生任何影响，那就没必要搞的那么复杂，直接改这个类吧。
里氏代替原则
所有引用基类（父类）的地方必须能透明的使用其子类的对象。
理解：父类可被子类替换，但反之不一定成立。也就是说，代码中可以将父类全部替换为子类，程序不会出现异常，但反过来就不一定了。
依赖倒置原则
抽象不应该依赖于细节，细节应当依赖于抽象。
理解：高层模块不应该依赖于底层模块，而应该依赖于抽象。抽象不应依赖于细节，细节应依赖于抽象。应该面向接口编程，不该面向实现类编程。面向实现类编程相当于就事论事，那是正向依赖；面向接口编程，相当于透过现象看本质，抓住事务的共性，那就是反向依赖，即依赖倒置。
接口隔离原则
接口拆分。当一个接口太大时，我们需要将它分割成一些更细小的接口。
理解：不要对外暴露没有实际意义的接口。也就是说，尽量保证接口的实用性。当需要对外暴露接口时，需要再三斟酌，若没必要对外提供就删了吧，因为一旦提供了就意味着，将来要多做一件事情，何苦给自己找事做呢。
迪米特法则
理解：减少依赖。一个软件实体应当尽可能少地与其他实体发生相互作用。
例子1：
/**
* 打折接口
*/
public double sale(String userType,double fee){
if("normal".equals(userType)){
return fee*1.2;
}else if("vip".equals(userType)){
return fee*0.8;
}else if("svip".equals(userType)){
return fee*0.6;
}
return fee;
}
改进后代码：把每个折扣的计算方法分开，新增normalCalculate和sVipCalculate计算类
@Autowired
NormalCalculate normalCalculate;
@Autowired
VipCalculate vipCalculate;
@Autowired
SVipCalculate sVipCalculate;
public double sale(String userType,double fee){
//单一职责
if("normal".equals(userType)){
return normalCalculate.discount(fee);
}else if("vip".equals(userType)){
return vipCalculate.discount(fee);
}else if("svip".equals(userType)){
return sVipCalculate.discount(fee);
}
return fee;
}
@Service
public class VipCalculate {
public double discount(double fee) {
return fee*0.8;
}
}
@Service
public class NormalCalculate {
public double discount(double fee) {
BigDecimal xs=new BigDecimal(String.valueOf(1.1));
return new BigDecimal(Double.toString(fee)).multiply(xs).doubleValue();
}
}
继续改进：新增计算接口ICalculate，NormalCalculate和VipCalculate进行修改
public interface ICalculate {
public String userType();
public double discount(double fee);
}
/**
* @Author: yechongbai
* @Date: 2020/4/23 0:51
* @Copyright: www.zektech.cn
* @since 1.0
*/
@Service
public class NormalCalculate implements ICalculate {
@Override
public String userType() {
return "normal";
}
@Override
public double discount(double fee) {
BigDecimal xs=new BigDecimal(String.valueOf(1.1));
return new BigDecimal(Double.toString(fee)).multiply(xs).doubleValue();
}
}
/**
* @Author: yechongbai
* @Date: 2020/4/23 0:51
* @Copyright: www.zektech.cn
* @since 1.0
*/
@Service
public class VipCalculate implements ICalculate {
@Override
public String userType() {
return "vip";
}
@Override
public double discount(double fee) {
return fee*0.8;
}
}
/**
* @Author: yechongbai
* @Date: 2020/4/23 0:51
* @Copyright: www.zektech.cn
* @since 1.0
*/
@Service
public class SVipCalculate implements ICalculate {
@Override
public String userType() {
return "svip";
}
@Override
public double discount(double fee) {
return fee*0.6;
}
}
然后SaleService类进行调整
//icalculateList 改用一个map存起来
HashMap<String,ICalculate> calculateHashMap=new HashMap<>();
//1.改注入的方式 spring特殊功能 --注入list,map
@Autowired
public SaleService(List<ICalculate> iCalculateList){
for (ICalculate iCalculate:iCalculateList){
calculateHashMap.put(iCalculate.userType(),iCalculate);
}
}
public double sale(String userType,double fee){
//TODO 根据不同用户类型，选用不同的对象，调用同样的接口
//本质来说就是一个 获取对象的逻辑
ICalculate iCalculate=calculateHashMap.get(userType);
if(iCalculate==null){
return fee;
}
return iCalculate.discount(fee);
}
例子2：原支付逻辑
/**
* 微信公众号/小程序预下单
* @param businessId 业务id-发起支付主键id，用来关联业务用
* @param userId 用户id/学生id
* @param spbillIp 微信支付手机ip
* @param schoolId 学校id
*/
public String unifiedorderJH(String businessId ,String userId,String spbillIp,String schoolId) throws Exception {
if(StringUtils.isBlank(businessId)){
return buildResult(SystemStatusEnum.ReqParamNull.getValue(),"业务id不能为空");
}
if(StringUtils.isBlank(userId)){
return buildResult(SystemStatusEnum.ReqParamNull.getValue(),"角色id不能为空");
}
if(StringUtils.isBlank(schoolId)){
return buildResult(SystemStatusEnum.ReqParamNull.getValue(),"学校id不能为空");
}
//获取学校配置
SysSchoolConfigVO configVO = sysSchoolConfigService.getInfoById(schoolId);
if(StringUtils.isBlank(configVO.getMiniAppid1())){
return buildResult(SystemStatusEnum.ReqParamNull.getValue(),"小程序id为空，请查看学校是否已经配置信息");
}
String mchId=sysConfigService.getConfigValue(schoolId, SysConfigConfig.GF_MCHID);
String instId=sysConfigService.getConfigValue(schoolId, SysConfigConfig.GF_INSTID);
String publicKey=sysConfigService.getConfigValue(schoolId, SysConfigConfig.GF_PUK);
String privateKey=sysConfigService.getConfigValue(schoolId, SysConfigConfig.GF_PVK);
String judgeRes=payParamJudge(configVO,mchId,instId,publicKey,privateKey);
if (judgeRes!=null){
return judgeRes;
}
SysWxUserVO wxUser=new SysWxUserVO();
wxUser.setUserId(userId);
SysWxUser wxUserObj =sysWxUserService.getWxUser(wxUser);
if(wxUserObj==null||StringUtils.isBlank(wxUserObj.getOpenId1())){
return buildResult(SystemStatusEnum.NoData.getValue(),"用户不存在");
}
SmNoticePaymoneyVO noticePaymoney=new SmNoticePaymoneyVO();
noticePaymoney.setStId(userId);
noticePaymoney.setNoticeId(businessId);
noticePaymoney=smNoticePaymoneyService.findSmNoticePaymoneyByStId(noticePaymoney);
if(noticePaymoney==null){
return buildResult(SystemStatusEnum.NoData.getValue(),"订单不存在");
}
if(noticePaymoney.getCost()==null){
return buildResult(SystemStatusEnum.NoData.getValue(),"支付金额为空");
}
if(SmNoticePaymoneyEnum.DELIVERED.getStatus().equals(noticePaymoney.getStatus())){
return buildResult(SystemStatusEnum.InvalidParams.getValue(),"该订单已缴费或作废，无法继续缴费");
}
SmNoticeVO notice=new SmNoticeVO();
notice.setNoticeId(businessId);
SmNoticeVO noticeObj = smNoticeService.getOneData(notice);
if (noticeObj==null) {
return buildResult(SystemStatusEnum.NoData.getValue(),"业务数据不存在");
}
String subject=noticeObj.getSubject();
//1.校验数据
if(noticePaymoney.getCost()==null){
return buildResult(SystemStatusEnum.ReqParamNull.getValue(),"费用不能为空");
}
if(StringUtils.isBlank(wxUserObj.getOpenId1())){
return buildResult(SystemStatusEnum.ReqParamNull.getValue(),"用户openid不能为空");
}
if(StringUtils.isBlank(subject)){
return buildResult(SystemStatusEnum.ReqParamNull.getValue(),"费用名称不能为空");
}
//元转分-判断金额是否小于等于0
if(noticePaymoney.getCost().compareTo(BigDecimal.ZERO)<=0)
{
return buildResult(SystemStatusEnum.ReqParamNull.getValue(),"订单金额必须大于0");
}
StBaseInfoVO stObj=stBaseInfoService.getByStName(userId);
//判断支付方式
switch (configVO.getPayWay()){
//聚合支付
case 0:
return payService.unifiedorderJH(configVO.getMiniAppid1(),mchId,businessId,BusinessTypeEnum.CLASS_ACTIVITY,userId,noticePaymoney.getCost().toString(),
wxUserObj.getOpenId1(),spbillIp,subject,schoolId,stObj.getClassName(),stObj.getName());
//富友支付
case 1:
return fyPayService.wxPreCreate(instId,mchId,configVO.getMiniAppid1(),businessId,BusinessTypeEnum.CLASS_ACTIVITY,userId,noticePaymoney.getCost().toString(),
wxUserObj.getOpenId1(),spbillIp,subject,schoolId,"01_WXPAY_PBPM",publicKey,privateKey,stObj.getClassName(),stObj.getName());
default:
return buildResult(SystemStatusEnum.InvalidParams.getValue(),"请检查学校是否配置了支付方式");
}
}
主要问题在判断支付方式上面,如果继续对接相应的支付，是否是要继续在相应的下单，退款，查询等接口都增加判断，会让这个代码越来越难维护。。。
//判断支付方式
switch (configVO.getPayWay()){
//聚合支付
case 0:
return payService.unifiedorderJH(configVO.getMiniAppid1(),mchId,businessId,BusinessTypeEnum.CLASS_ACTIVITY,userId,noticePaymoney.getCost().toString(),
wxUserObj.getOpenId1(),spbillIp,subject,schoolId,stObj.getClassName(),stObj.getName());
//富友支付
case 1:
return fyPayService.wxPreCreate(instId,mchId,configVO.getMiniAppid1(),businessId,BusinessTypeEnum.CLASS_ACTIVITY,userId,noticePaymoney.getCost().toString(),
wxUserObj.getOpenId1(),spbillIp,subject,schoolId,"01_WXPAY_PBPM",publicKey,privateKey,stObj.getClassName(),stObj.getName());
default:
return buildResult(SystemStatusEnum.InvalidParams.getValue(),"请检查学校是否配置了支付方式");
}
违反代码六大设计原则之一：开闭原则，如何进行优化修改？
利用设计模式之一：策略模式进行修改
定义一个支付的接口，里面包含：下单，退款，交易查询，退款查询等无论接入哪个支付通道都要用到的方法。
步骤1：新增支付接口IPayServiceImp
public interface IPayServiceImp {
//支付类型
public String payType();
/**
* 下单
* @return
*/
public String unifiedorderJH(String businessId ,String userId,String spbillIp,String schoolId);
/**
* 退款
* @return
*/
public String refundJH(String userId,String tradeNo,String schoolId,String refundFee,String remark);
/**
* 交易查询
* @return
*/
public String findOrderJH(String tradeNo,String schoolId);
/**
* 退款查询
* @return
*/
public String findRefOrderJH(String tradeNo,String refundNo,String schoolId);
}
步骤2：分别新增富友支付和聚合支付实现类：FuyouPayService和JuhePayService
@Service
public class FuyouPayService implements IPayServiceImp{
@Override
public String payType() {
return "fuyou";
}
@Override
public String unifiedorderJH(String businessId, String userId, String spbillIp, String schoolId) {
//TODO 编写逻辑
return "成功调用富有支付下单方法";
}
@Override
public String refundJH(String userId, String tradeNo, String schoolId, String refundFee, String remark) {
return "成功调用富有支付退款方法";
}
@Override
public String findOrderJH(String tradeNo, String schoolId) {
return null;
}
@Override
public String findRefOrderJH(String tradeNo, String refundNo, String schoolId) {
return null;
}
}
@Service
public class JuhePayService implements IPayServiceImp {
@Override
public String payType() {
return "juhe";
}
@Override
public String unifiedorderJH(String businessId, String userId, String spbillIp, String schoolId) {
//TODO 编写逻辑
return "成功调用聚合支付下单方法";
}
@Override
public String refundJH(String userId, String tradeNo, String schoolId, String refundFee, String remark) {
return "成功调用聚合支付退款方法";
}
@Override
public String findOrderJH(String tradeNo, String schoolId) {
return null;
}
@Override
public String findRefOrderJH(String tradeNo, String refundNo, String schoolId) {
return null;
}
}
步骤3：实现支付调用，创建一个支付业务类ArcPayService，根据传输的支付类型自动匹配相应的支付接口，该方法利用了设计模式之一：策略模式。具体原理：利用spring的特性，在类初始化的时候，注入所有的支付list，然后以payType为key，把这个list存储在map中，每次接口调用，根据payType这个key，找到相应的支付实现类，完成支付功能的正确调用。
@Service
public class ArcPayService {
/**
* iPayServiceImpList用一个map存起来
*/
HashMap<String,IPayServiceImp> iPayMap=new HashMap<>();
/**
* 初始化，注入所有的支付List
*/
@Autowired
public ArcPayService(List<IPayServiceImp> iPayServiceImpList){
for (IPayServiceImp iPayServiceImp:iPayServiceImpList){
iPayMap.put(iPayServiceImp.payType(),iPayServiceImp);
}
}
/**
* 下单
* @param payType
* @return
*/
public String unifiedorderJH(String payType){
IPayServiceImp iPayServiceImp=iPayMap.get(payType);
if(iPayServiceImp==null){
return "支付方式不存在";
}
return iPayServiceImp.unifiedorderJH("","","","");
}
/**
* 退款
* @param payType
* @return
*/
public String refundJH(String payType){
IPayServiceImp iPayServiceImp=iPayMap.get(payType);
if(iPayServiceImp==null){
return "支付方式不存在";
}
return iPayServiceImp.refundJH("","","","","");
}
}
步骤4:测试，新增测试类ArcPayServiceTest
@SpringBootTest
@RunWith(SpringRunner.class)
public class ArcPayServiceTest {
@Autowired
ArcPayService arcPayService;
@Test
public void unifiedorderJH() {
String fuyou= arcPayService.unifiedorderJH("fuyou");
System.out.println("富有："+fuyou);
String juhe= arcPayService.unifiedorderJH("juhe");
System.out.println("聚合："+juhe);
String xx= arcPayService.unifiedorderJH("xxx");
System.out.println("其他："+xx);
}
@Test
public void refundJH() {
}
}
输出相应的结果如下：
富有：成功调用富有支付下单方法
聚合：成功调用聚合支付下单方法
其他：支付方式不存在
