springCloud 学习

一个spring-boot自动注入策略工厂的starter (设

2021-01-04  本文已影响0人  Colagy

一个spring-boot自动注入策略工厂的starter (设计模式:策略模式 工厂模式 单例模式)

这个项目写了几天了 想写个博客记录一下 这个心路历程 也是和大家的一份分享 但是比较懒 一直没写 今天是2020年12月31日 2020年的最后一天了 这一年发生了一些众所周知的事情 想到这些事 我提起笔想记录一下
代码链接

项目需求

最近在做 数据可视化 的项目 有一些excel导入的结构化数据. 虽然数据比较完整的 有一部分是从其他系统中导出的数据 但是也有一部分是手填的数据 还是需要做一下数据审计的 把 缺失值 异常值 偏离值 找出来

  1. 缺失值 : NULL NONE NaN 空格 空字符
  2. 异常值 : 0值 负值 小于1的数
  3. 离群值: 箱线图模型超过上界下界的值
在这里插入图片描述

简单技术实现

遍历数据库表的字段 查找 缺失值 异常值 加入列表 再把列表合并成了 异常值 的列表

    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 的方式 来获取数据的 当我们的表和字段发生了改变我们再来 修改数据是很麻烦的 这不符合 开闭原则(对扩展开放,对修改关闭) 代码也不优雅 会影响我们对代码的复用以及后续的维护

那么我们需要对代码进行重构

代码重构-使用策略模式

这段代码中 我们需要对不同表的指定几个字段进行处理 也需要对不同的异常值类型进行处理 那么我们可以

  1. 将表定义为一个策略
  2. 将异常值类型定义为一个策略

表的策略中包括了需要处理的字段 然后字段需要处理的异常值类型通过表策略定义
策略的实现需要继承自策略接口 这样我们再利用 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 <T>                    策略接口类型
     * @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

代码连接

上一篇下一篇

猜你喜欢

热点阅读