美文网首页springCloud 学习
一个spring-boot自动注入策略工厂的starter (设

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

作者: Colagy | 来源:发表于2021-01-04 00:06 被阅读0次

    一个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 的成员变量会被多个线程访问 我们的异常值策略实现中的 indexlistlist 并发访问会出现 线程安全 的问题 这个时候我们可以引入一个策略工厂 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
    

    代码连接

    相关文章

      网友评论

        本文标题:一个spring-boot自动注入策略工厂的starter (设

        本文链接:https://www.haomeiwen.com/subject/lqkmoktx.html