一个策略模式结合spring-boot的starter (设计模式:策略模式 工厂模式 单例模式)
一个spring-boot自动注入策略工厂的starter (设计模式:策略模式 工厂模式 单例模式)
这个项目写了几天了 想写个博客记录一下 这个心路历程 也是和大家的一份分享 但是比较懒 一直没写 今天是2020年12月31日 2020年的最后一天了 这一年发生了一些众所周知的事情 想到这些事 我提起笔想记录一下
代码链接
项目需求
最近在做 数据可视化 的项目 有一些excel导入的结构化数据. 虽然数据比较完整的 有一部分是从其他系统中导出的数据 但是也有一部分是手填的数据 还是需要做一下数据审计的 把 缺失值 异常值 偏离值 找出来
- 缺失值 : NULL NONE NaN 空格 空字符
- 异常值 : 0值 负值 小于1的数
- 离群值: 箱线图模型超过上界下界的值
简单技术实现
遍历数据库表的字段 查找 缺失值 异常值 加入列表 再把列表合并成了 异常值 的列表
for(String table : tableList){
for(String field : fieldList){
// 数据库中查询到的数据
List<Map> dataList = new ArrayList();
// a/b/c/d表 a/b/c/d字段
if("a".equals(table)){
if("a".equals(field)){
dataList = aDao.listFieldA();
} else if("b".equals(field)){
dataList = aDao.listFieldB();
} else if("c".equals(field)){
dataList = aDao.listFieldC();
} else if("d".equals(field)){
dataList = aDao.listFieldD();
}
} else if("b".equals(table)){
if("a".equals(field)){
dataList = bDao.listFieldA();
}
} else if("c".equals(table)){
if("a".equals(field)){
dataList = cDao.listFieldA();
} else if("b".equals(field)){
dataList = cDao.listFieldB();
} else if("c".equals(field)){
dataList = cDao.listFieldC();
}
} else if("d".equals(table)){
if("a".equals(field)){
dataList = dDao.listFieldA();
} else if("b".equals(field)){
dataList = dDao.listFieldB();
} else if("c".equals(field)){
dataList = dDao.listFieldC();
} else if("d".equals(field)){
dataList = dDao.listFieldD();
}
}
if(Collections.isEmpty(dataList)){
return;
}
JSONArray nullArr=new JSONArray();
JSONArray zeroArr=new JSONArray();
JSONArray negativeArr=new JSONArray();
JSONArray smallArr=new JSONArray();
// 全部异常值
JSONArray allArr=new JSONArray();
for (Map<String,Object> map : totalPowerAllMonth) {
String electricity_consumption_str_list = (String) map.get("electricity_consumption_list");
String[] list = StringUtils.split(electricity_consumption_str_list, ',');
if (Objects.isNull(list)) {
continue;
}
JSONObject data;
data = new JSONObject();
List<Integer> nullIndexList=new ArrayList();
List<Integer> zeroIndexList=new ArrayList();
List<Integer> negativeIndexList=new ArrayList();
List<Integer> smallIndexList=new ArrayList();
int month = 0;
for (String electricity_consumption_str : list) {
month++;
Double current = null;
try {
current = Double.valueOf(electricity_consumption_str);
} catch (Exception e) {
nullIndexList.add(month);
continue;
}
if (Objects.isNull(current)) {
nullIndexList.add(month);
}else if("0".equals(current.toString())){
zeroIndexList.add(month);
}else if(current<0){
negativeIndexList.add(month);
}else if(current<1){
smallIndexList.add(month);
}
}
data.put("electricity_consumption", pre.toString());
data.put("province", map.get("province"));
data.put("data_year", map.get("data_year"));
data.put("kpi_num", map.get("kpi_num"));
if(nullIndexlist.size()>0){
data.put("index_list", month);
data.put("type","空值");
nullArr.add(data);
}else if(zeroIndexlist.size()>0){
data.put("index_list", month);
data.put("type","零值");
zeroArr.add(data);
}else if(negativeIndexlist.size()>0){
data.put("index_list", month);
data.put("type","负值");
negativeArr.add(data);
}else if(smallIndexlist.size()>0){
data.put("index_list", month);
data.put("type","小数");
smallArr.add(data);
}
}
allArr.addAll(nullArr);
allArr.addAll(zeroArr);
allArr.addAll(negativeArr);
allArr.addAll(smallArr);
}
}
这是一个简单的实现了 可以满足我们的要求 但是问题来了 我们是通过嵌套 if else 的方式 来获取数据的 当我们的表和字段发生了改变我们再来 修改数据是很麻烦的 这不符合 开闭原则(对扩展开放,对修改关闭) 代码也不优雅 会影响我们对代码的复用以及后续的维护
那么我们需要对代码进行重构
代码重构-使用策略模式
这段代码中 我们需要对不同表的指定几个字段进行处理 也需要对不同的异常值类型进行处理 那么我们可以
- 将表定义为一个策略
- 将异常值类型定义为一个策略
表的策略中包括了需要处理的字段 然后字段需要处理的异常值类型通过表策略定义
策略的实现需要继承自策略接口 这样我们再利用 spring-boot 的Map注入 将所有的策略实现注入到一个Map中 我们可以根据名称直接get
表策略接口
需要两个方法 一个是获取全部字段的方法 一个是获取指定字段的数据
public interface IAuditStrategy {
List<String> listField();
List<Map> listData(String field);
}
四个表策略实现
@Component("auditStrategy_one")
public class OneAuditStrategyImpl implements IAuditStrategy {
@Autowired
private Dao dao;
@Override
public List<String> listField() {
List<String> fieldList = new ArrayList<>();
fieldList.add("a");
fieldList.add("b");
fieldList.add("c");
fieldList.add("d");
return fieldList;
}
@Override
public List<Map> listData(String field) {
switch (field) {
case "a":
return dao.listA();
case "b":
return dao.listB();
case "c":
return dao.listC();
case "d":
return dao.listD();
}
return null;
}
}
@Component("auditStrategy_two")
public class TwoAuditStrategyImpl implements IAuditStrategy {
@Override
public List<String> listField() {
...
}
@Override
public List<Map> listData(String field) {
...
}
}
@Component("auditStrategy_three")
public class ThreeAuditStrategyImpl implements IAuditStrategy {
@Override
public List<String> listField() {
...
}
@Override
public List<Map> listData(String field) {
...
}
}
@Component("auditStrategy_four")
public class FourAuditStrategyImpl implements IAuditStrategy {
@Override
public List<String> listField() {
...
}
@Override
public List<Map> listData(String field) {
...
}
}
异常值策略接口
可以设置异常类型 放入值 生成索引列表 值列表
数据结构: List< Map< String, Object > >
[
{
type: '空值',
indexList: [ 0 , 1 , 2 ],
...
}
]
public interface IAuditInvalidStrategy<T> extends Strategy {
/**
* @param type 异常值类型
*/
void setType(String type);
/**
* @return 异常值类型
*/
String getType();
/**
* 手动设置值列表
*
* @param valueList 值列表
*/
void setValueList(List<T> valueList);
/**
* 添加值
*
* @param value 值
*/
void addValue(T value);
/**
* 添加索引 需要维护一个索引列表
*
* @param index 索引
* @param value 值
*/
void addIndex(Integer index, T value);
/**
* 获取添加的索引列表
*
* @return 索引列表
*/
List<Integer> getIndexList();
/**
* 添加异常值 map 添加后会清空索引列表 值列表
*
* @param map map
*/
void add(Map map);
/**
* 获取全部的map 获取后会清空 list
*
* @return 全部map
*/
List<Map> getList();
/**
* @return list是否为空
*/
boolean isEmpty();
/**
* @return list是否不为空
*/
boolean isNotEmpty();
}
异常值策略抽象类
抽象类是主要的对数据结构的实现 是策略核心方法的实现 异常值策略实现需要继承这个抽象类 定义了索引列表和值列表 以及全部的列表
简化了一些实现 文章里只展示业务逻辑
public abstract class AbsInvalidStrategy<T> implements IAuditInvalidStrategy<T> {
private String type;
private boolean isIndexEmpty = true;
private boolean isEmpty = true;
protected List<T> valueList;
protected List<Integer> indexList;
private List<Map> list;
protected boolean isNull(T value) {
// 异常值判断简化了实现 这里只展示业务逻辑
return Objects.isNull(value);
}
protected boolean isZero(T value) {
// 异常值判断简化了实现 这里只展示业务逻辑
if (isNull(value)) {
return false;
}
return isZero(value);
}
protected boolean isNegative(T value) {
if (isNull(value) || isZero(value)) {
return false;
}
return isNegative();
}
protected boolean isSmall(T value) {
if (isNull(value) || isZero(value) || isNegative(value)) {
return false;
}
return isSmall();
}
@Override
public void setType(String type) {
this.type = type;
}
@Override
public String getType() {
return type;
}
@Override
public void setValueList(List<T> valueList) {
this.valueList = valueList;
}
@Override
public void addValue(T value) {
if (Objects.isNull(valueList)) {
valueList = new ArrayList<>();
}
valueList.add(value);
}
@Override
public void beforeAddIndex() {
if (Objects.isNull(indexList)) {
indexList = new ArrayList<>();
}
if (isIndexEmpty) {
isIndexEmpty = false;
}
}
@Override
public List<Integer> getIndexList() {
if (Objects.isNull(indexList)) {
indexList = new ArrayList<>();
}
return indexList;
}
@Override
public void add(Map map) {
if (isIndexEmpty) {
indexList = new ArrayList<>();
valueList = new ArrayList<>();
return;
}
if (Objects.isNull(list)) {
list = new ArrayList<>();
}
list.add(map);
if (isEmpty) {
isEmpty = false;
}
indexList = new ArrayList<>();
isIndexEmpty = true;
valueList = new ArrayList<>();
}
@Override
public List<Map> getList() {
isIndexEmpty = true;
indexList = new ArrayList<>();
valueList = new ArrayList<>();
isEmpty = true;
List<Map> ret = Arrays.asList(new Map[list.size()]);
Collections.copy(ret, list);
list = new ArrayList<>();
return ret;
}
@Override
public boolean isEmpty() {
return isEmpty;
}
@Override
public boolean isNotEmpty() {
return !isEmpty;
}
}
异常值策略实现
主要的实现在抽象类里面已经实现了 不同的策略只需要实现 addIndex 方法 如果是当前异常类型就把索引加入索引列表
@Component("auditStrategyInvalid_零值")
public class AuditZeroStrategyImpl<T> extends AbsInvalidStrategy<T> {
@Override
public void addIndex(Integer index, T value) {
if (isZero(value)) {
beforeAddIndex();
indexList.add(index);
}
}
}
策略注入与使用
@Service
public class AuditService{
@Autowired
private Map<String,IAuditStrategy> auditStrategyMap;
@Autowired
private Map<String,IInvalidStrategy> invalidStrategyMap;
public JSONArray audit(String table,String field,String type){
IAuditStrategy auditStrategy = auditStrategyMap.get("auditStrategy_"+table);
List<Map> dataList = auditStrategy.listData(field);
IInvalidStrategy invalidHandler = invalidStrategyMap.get("auditStrategyInvalid_"+type);
int index=0;
for(Map data:dataList){
List<String> valueList=data.get("valueList");
for(String value_str:valueList){
invalidHandler.addValue(value_str);
invalidHandler.addIndex(index++, value_str);
}
Map invalidMap=new HashMap();
invalidMap.put("dataIndex", invalidHandler.getIndexList());
...
invalidHandler.add(invalidMap);
}
return invalidHandler.getList();
}
}
策略模式重构后的代码变得优雅了将实现与主业务逻辑解耦 如果需要再加入表字段 或者异常值处理类型 只需要创建对应的文件 实现策略接口 使用 @Component 注解 交由spring-boot管理 spring-boot 会自动注入到策略Map 我们只需要提供一个字符串就可以获取对应的策略 无需if else判断
成员变量 线程安全问题
spring-boot 中的 bean 是单例的 一个 bean 的成员变量会被多个线程访问 我们的异常值策略实现中的 indexlist 和 list 并发访问会出现 线程安全 的问题 这个时候我们可以引入一个策略工厂 strategyFatctory
public abstract class AbsInvalidStrategy<T> implements IAuditInvalidStrategy<T> {
protected List<T> valueList;
protected List<Integer> indexList;
private List<Map> list;
}
spring-boot-starter 策略工厂
通过 spring-boot-starter 注入一个 策略工厂 每个线程从工厂中创建map避免共享成员变量导致的 线程安全 问题
1.策略注解
策略注解 结合了 @Component 会将策略注入到 spring-boot 中 可以通过默认的map方式注入 也可以通过 策略工厂 生产
@Target({
ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface StrategyComponent {
String value();
}
使用注解
@StrategyComponent("auditStrategy_one")
public class OneAuditStrategyImpl implements IAuditStrategy {
...
}
2.策略接口
策略接口只做为一个标识 没有任何的方法
public interface Strategy {
}
表策略和异常值策略接口继承策略接口
public interface IAuditStrategy extends Strategy {
...
}
public interface IAuditInvalidStrategy<T> extends Strategy {
...
}
3.策略工厂
public class StrategyFactory {
// 策略工厂实例单例
private static volatile StrategyFactory instance = null;
// 策略接口Map<策略接口包名,Map<策略StrategyComponent名,策略实现类class>>
protected Map<String, Map<String, Class>> interfaceStrategyMap;
private StrategyFactory() {
}
// 单例模式
static StrategyFactory getInstance() {
if (Objects.isNull(instance)) {
synchronized (StrategyFactory.class) {
if (Objects.isNull(instance)) {
instance = new StrategyFactory();
}
}
}
return instance;
}
void setMap(Map<String, Map<String, Class>> interfaceStrategyMap) {
this.interfaceStrategyMap = interfaceStrategyMap;
}
/**
* 根据策略接口获取实现自该接口的所有策略实现
*
* @param strategyInterfaceClass 策略接口
* @param 策略接口类型
* @return 返回实现自该接口的所有策略实现的对象实例
*/
public <T> Map<String, T> getStrategyMap(Class<? extends T> strategyInterfaceClass) {
Map<String, T> strategyMap = new HashMap<>();
// 从策略接口Map中获取实现自该接口的map
Map<String, Class> strategyClassMap = interfaceStrategyMap.get(strategyInterfaceClass.getName());
// 遍历map获取class文件生成策略对象实例
for (Map.Entry<String, Class> entry : strategyClassMap.entrySet()) {
Class strategyClass = entry.getValue();
T strategy = null;
try {
strategy = (T) strategyClass.newInstance();
} catch (InstantiationException | IllegalAccessException e) {
throw new RuntimeException(e);
}
strategyMap.put(entry.getKey(), strategy);
}
return strategyMap;
}
}
策略工厂使用 通过
@Service
public class auditService{
@Autowired
private StrategyFactory strategyFactory;
public JSONArray audit(){
// 策略模式
Map<String, IAuditStrategy> auditStrategyMap = strategyFactory.getStrategyMap(IAuditStrategy.class);
}
}
4.配置
@Configuration
public class StrategyConfiguration {
@Autowired
private ApplicationContext applicationContext;
/**
* 策略工厂 bean 生成
*
* @return 策略工厂 bean
*/
@ConditionalOnMissingBean
@Bean
public StrategyFactory getStrategyFactory() {
Map<String, Map<String, Class>> strategyInterfaceMap = new HashMap<>();
// 获取实现自策略接口的所有strategyComponent bean
Map<String, Strategy> strategyMap = applicationContext.getBeansOfType(Strategy.class);
for (Map.Entry<String, Strategy> strategyEntry : strategyMap.entrySet()) {
// 策略实现bean的class
Class strategyClass = strategyEntry.getValue().getClass();
// 策略接口的包名列表
List<String> interfaceNameList = getInterfaceNameList(strategyClass);
if (CollectionUtils.isEmpty(interfaceNameList)) {
continue;
}
// 遍历策略接口包名生成策略Map
for (String interfaceName : interfaceNameList) {
Map<String, Class> strategyClassMap = strategyInterfaceMap.get(interfaceName);
if (Objects.isNull(strategyClassMap)) {
strategyClassMap = new HashMap<>();
strategyInterfaceMap.put(interfaceName, strategyClassMap);
}
strategyClassMap.put(strategyEntry.getKey(), strategyClass);
}
}
// 策略工厂单例
StrategyFactory strategyFactory = StrategyFactory.getInstance();
// 放入全部的策略
strategyFactory.setMap(strategyInterfaceMap);
return strategyFactory;
}
/**
* 通过策略实现class 反射 获取实现的全部策略接口名称
*
* @param strategyClass
* @return
*/
private List<String> getInterfaceNameList(Class strategyClass) {
List<String> interfaceNameList = new ArrayList<>();
// 从递归全部父类中找到实现的接口
getExtendsOf(strategyClass, interfaceNameList);
return interfaceNameList;
}
/**
* 从递归全部父类中找到实现的接口
*
* @param strategyClass 当前类
* @param interfaceNameList 接口名称列表
*/
public void getExtendsOf(Class strategyClass, List<String> interfaceNameList) {
// 获取父类
Class supperClass = strategyClass.getSuperclass();
if (Objects.nonNull(supperClass)) {
// 如果存在父类 递归调用
getExtendsOf(supperClass, interfaceNameList);
}
// 获取实现的接口数组
Class<?>[] interfaces = strategyClass.getInterfaces();
if (ArrayUtils.isNotEmpty(interfaces)) {
// 获取继承自Strategy接口的策略接口
getImplementsOf(strategyClass, interfaceNameList);
}
}
/**
* 递归查找继承自Strategy接口的策略接口
*
* @param strategyClass 实现了策略接口的策略类
* @param interfaceNameList 策略接口名称列表
* @return 返回是否为Strategy
*/
public boolean getImplementsOf(Class strategyClass, List<String> interfaceNameList) {
// 获取策略接口中的继承或者多继承的接口数组
Class[] interfaces = strategyClass.getInterfaces();
if (ArrayUtils.isNotEmpty(interfaces)) {
// 遍历接口查询继承自Strategy的接口
for (Class inter : interfaces) {
// 如果是Strategy返回true
if (Objects.equals(inter.getName(), Strategy.class.getName())) {
return true;
}
// 如果继承的接口列表中有Strategy 把接口包名加入列表
if (getImplementsOf(inter, interfaceNameList)) {
interfaceNameList.add(inter.getName());
}
}
}
return false;
}
}
spring-boot-starter
我们需要写一个 spring-boot-starter 在pom中引入这个starter 就会自动加载这个 策略工厂
org.springframework.boot.autoconfigure.EnableAutoConfiguration = com.colagy.starter.strategy.StrategyConfiguration
代码连接