项目重构:设计模式(策略模式）
策略模式（Strategy Pattern）属于对象的行为模式。其用意是针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。策略模式使得算法可以在不影响到客户端的情况下发生变化。
其主要目的是通过定义相似的算法，替换if else 语句写法，并且可以随时相互替换。
本文参考文章 设计模式最佳套路—— 愉快地使用策略模式
由于项目中，有个需求，通过计费引擎对不同类型进行计费，但是每个类型的计费参数又不一样，一开始通过if-else解决
if (typeA) {
逻辑1
} else if (typeB) {
逻辑2
} else if (typeC) {
逻辑3
} else {
逻辑4
}
虽然问题解决了，但是每次我们添加一个类型就要修改这段代码，而且代码也不美观；所以，对代码进行了重构
在spring框架中，我们可以通过getBean获取到Spring容器中已初始化的bean，如果我们实现了一个计算参数的接口，然后获取到不同的类型其实现类，这样就可以避免我们增加一个类型就要修改if-else分支
流程图
获取计费接口
public interface FeeChargingParamsHandler {
/**
* FeeChargingParamsHandler :: getChargingType
* <p>TO:获得计费类型
* <p>DO:确定一个唯一性的计费参数方法类型，相当于beanName
* <p>HISTORY: 2020/11/28 liuha : Created.
*
* @return String 计费数据实现类型
*/
String getChargingType();
/**
* FeeChargingParamsHandler :: getChargingData
* <p>TO:获取记录计费数据
* <p>DO:返回ChargingDataVO格式数据
* <p>HISTORY: 2020/11/28 liuha : Created.
*
* @param originalRecordId 计费记录id
* @return ChargingDataVO 计费数据
*/
ChargingDataVO getChargingData(String originalRecordId);
}
返回参数的类
@Data
public class ChargingDataVO {
/**
* 参数的名称
*/
private String name;
/**
* 参数类型
*/
private String type;
/**
* 参数值
*/
private List<List<Map>> value;
/**
* ChargingDataVO:: addMApValue
* <p>TO:添加value值
* <p>DO:初始化value,添加值到value
* <p>HISTORY: 2020/11/28 liuha : Created.
*
* @param mapList 变量
*/
public void addMApValue(List<Map> mapList) {
//初始化数据
if (this.value == null) {
this.value = new ArrayList<>();
}
this.value.add(mapList);
}
}
这里是由于业务的要求，参数值一个二维码数组，这里避免掉业务会乱传入数据，所以才会使用了 List<List<Map> 的一个数据结构
建立简单工厂
@Component
public class FeeChargingHandlerFactory implements InitializingBean, ApplicationContextAware {
private static final
Map<String, FeeChargingParamsHandler> FEE_CHARGING_HANDLER_MAP = new HashMap(8);
private ApplicationContext appContext;
/**
* FeeChargingHandlerFactory ::
* <p>TO:传入类型获取对应的处理器
* <p>HISTORY: 2020/11/28 liuha : Created.
* @param chargingType 计费类型
* @return 返回类型对应的处理器
*/
public FeeChargingParamsHandler getHandler(String chargingType) {
return FEE_CHARGING_HANDLER_MAP.get(chargingType);
}
@Override
public void afterPropertiesSet() {
// 将 Spring 容器中所有的 FeeChargingParamsHandler 注册到 FEE_CHARGING_HANDLER_MAP
appContext.getBeansOfType(FeeChargingParamsHandler.class)
.values()
.forEach(handler -> FEE_CHARGING_HANDLER_MAP.put(handler.getChargingType(), handler));
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) {
appContext = applicationContext;
}
}
实现计费参数接口
@Component
public class TestFeeChargingParamsHandler implements FeeChargingParamsHandler {
/**
* TestFeeChargingParamsHandler:: getChargingType
* <p>TO:获得实现方法的计费数据实现类型
* <p>DO:确定一个唯一性的计费参数方法类型，相当于beanName
* <p>HISTORY: 2020/11/28 liuha : Created.
*
* @return String 计费数据实现类型
*/
@Override
public String getChargingType() {
return "test";
}
/**
* TestFeeChargingParamsHandler:: getChargingData
* <p>TO:获取记录计费数据
* <p>DO:返回ChargingDataVO格式数据
* <p>HISTORY: 2020/11/28 liuha : Created.
*
* @param originalRecordId 计费记录id
* @return ChargingDataVO 计费数据
*/
@Override
public ChargingDataVO getChargingData(String originalRecordId) {
ChargingDataVO chargingDataVO = new ChargingDataVO();
chargingDataVO.setName("管道");
chargingDataVO.setType("String");
List<Map> mapList = new ArrayList<>();
Map<String, String> map = new HashMap<>();
map.put("name", "铺设方式");
map.put("value", "架空");
mapList.add(map);
Map<String, String> map1 = new HashMap<>();
map1.put("name", "压力管道级别");
map1.put("value", "GC3");
mapList.add(map1);
Map<String, String> map2 = new HashMap<>();
map2.put("name", "管道外径");
map2.put("value", "60");
mapList.add(map2);
Map<String, String> map3 = new HashMap<>();
map3.put("name", "管道长度]);
map3.put("value", "1");
mapList.add(map3);
chargingDataVO.addMApValue(mapList);
return chargingDataVO;
}
}
代码调用
在业务中中，我们通过 FeeChargingHandlerFactory 来获取类型实现的计费接口实现类，从而获取到计费的参数：
@Autowired
private FeeChargingHandlerFactory handlerFactory;
......... 业务代码
/**
* ITjFeeChargingServiceImpl:: getChargingData
* <p>TO:获取业务实现计费参数数据
* <p>DO:从handlerFactory获取到FeeChargingParamsHandler;调用实现类;返回结果
* <p>HISTORY: 2020/11/29 liuha : Created.
*
* @param recordId 计费的业务数据id
* @param type 实现类的type类型
* @return ChargingParamData 类型的计费参数
*/
private ChargingParamData getChargingData(String recordId, String type) {
//查找策略实现
FeeChargingParamsHandler handler = handlerFactory.getHandler(type);
if (handler == null) {
throw new JeecgBootException("未找到实现二维表取的实现类");
}
return handler.getChargingData(recordId);
}
这样便可以解决了多层if-else的代码了，如果添加了一个类型，只需要添加一个新的策略实现即可，其实还有一个问题，由于工厂模式中，我们使用了map存入实现类，
@Override
public void afterPropertiesSet() {
// 将 Spring 容器中所有的 FeeChargingTableParamsHandler 注册到 FEE_CHARGING_HANDLER_MAP
appContext.getBeansOfType(FeeChargingTableParamsHandler.class)
.values()
.forEach(handler -> FEE_CHARGING_HANDLER_MAP.put(handler.getChargingType(), handler));
}
如果存在一样的类型参数，就会把之前存入的策略实现，替换掉，所以可以在遍历过程中判断是否存在重复的type，由于我是，内部方法调用，可以不做校验。另外，如果类型可以确定，使用switch-case的方法也实现分支，策略模式在项目还可以和模板方法结合使用，这样就可以解决主体方法一样，但是部分代码存在分支的情况，比如业务实现工作