按顺序执行处理器、校验器

朱雀 2020-10-25 03:12 586阅读 0赞

![20191231150253482.png][]

关于上面，一步接一步处理数据、校验数据的流程（类似于过滤器），映射到我们代码里该怎么写呢？

### 方法一、 ###

可以按照这个流程图一步一步的写代码，把这个流程给写完；但是缺点是不够灵活，不好扩展；

### 方法二、 ###

1、既然是一步一步的，有时候下一步的操作需要用到上一步处理之后的数据，所有优先级是需要的；

2、把处理和校验分别当作一个接口，新增了处理器、校验器直接实现前面的接口即可；

3、基类里帮我们做与业务无关的事情比如排序，具体的处理、校验逻辑由具体的实现类实现。

### 撸码： ###

优先级接口Priority，这个不论是处理器还是校验器都需要实现的接口

public interface Priority {
    
        /**
         * 优先级 数字越大， 优先级越高
         * @return
         */
        int getPriority();
    }

处理器接口Processor

public interface Processor extends Priority {
    
        /**
         * 处理器
         * @param map
         */
        void process(Map<String, Object> map);
    }

处理器基类AbstractProcessor

public abstract class AbstractProcessor implements Processor {
    
        /**
         * 需要的话，做doProcess
         * @param map
         */
        @Override
        public void process(Map<String, Object> map) {
            if (need(map)) {
                doProcess(map);
            }
        }
    
        protected abstract boolean need(Map<String, Object> map);
    
        protected abstract void doProcess(Map<String, Object> map);
    
    }

具体的实现类，这个根据你的业务来实现，我这里实现三个，但是第三个我不想要了，直接把need改为false。

@Component
    public class FirstProcessor extends AbstractProcessor{
    
        @Override
        public boolean need(Map<String, Object> map) {
            return true;
        }
    
        @Override
        public void doProcess(Map<String, Object> map) {
            System.out.println("need为true，优先级为100，第一步处理");
        }
    
        @Override
        public int getPriority() {
            return 100;
        }
    }

@Component
    public class SecondProcessor extends AbstractProcessor{
    
        @Override
        public boolean need(Map<String, Object> map) {
            return true;
        }
    
        @Override
        public void doProcess(Map<String, Object> map) {
            System.out.println("need为true，优先级为99，第二步处理");
        }
    
        @Override
        public int getPriority() {
            return 99;
        }
    }

@Component
    public class ThirdProcessor extends AbstractProcessor {
        @Override
        public boolean need(Map<String, Object> map) {
            return false;
        }
    
        @Override
        public void doProcess(Map<String, Object> map) {
            System.out.println("need为false，第三步不处理");
        }
    
        @Override
        public int getPriority() {
            return 98;
        }
    }

处理器就结束了，下面开始写 校验器，和处理器很类似

校验器接口Validator

public interface Validator extends Priority {
    
        /**
         * 校验器
         * @param map
         */
        void validate(Map<String, Object> map);
    }

校验器基类AbstractValidator

public abstract class AbstractValidator implements Validator {
    
        @Override
        public void validate(Map<String, Object> map) {
            if (need(map)) {
                doValidate(map);
            }
        }
    
        protected abstract boolean need(Map<String, Object> map);
    
        protected abstract void doValidate(Map<String, Object> map);
    
    }

具体的实现类，这个根据你的业务来实现，我这里实现三个，但是第二个我不想要了，直接把need改为false。

@Component
    public class FirstValidator extends AbstractValidator {
    
        @Override
        protected boolean need(Map<String, Object> map) {
            return true;
        }
    
        @Override
        protected void doValidate(Map<String, Object> map) {
            System.out.println("need为true，优先级为100，第一步校验");
        }
    
        @Override
        public int getPriority() {
            return 100;
        }
    }

@Component
    public class SecondValidator extends AbstractValidator {
    
        @Override
        protected boolean need(Map<String, Object> map) {
            return false;
        }
    
        @Override
        protected void doValidate(Map<String, Object> map) {
            System.out.println("need为false，第二步不做校验");
        }
    
        @Override
        public int getPriority() {
            return 99;
        }
    }

@Component
    public class ThirdValidator extends AbstractValidator {
    
        @Override
        protected boolean need(Map<String, Object> map) {
            return true;
        }
    
        @Override
        protected void doValidate(Map<String, Object> map) {
            System.out.println("need为true，优先级为98，第三步校验");
        }
    
        @Override
        public int getPriority() {
            return 98;
        }
    }

准备工作做完之后，我们把处理器、校验器整合在一起

执行接口ProcessManager

public interface ProcessManager {
    
        void process(Map<String, Object> map);
    }

执行接口实现类ProcessManagerImpl，里面做处理器、校验器的排序

@Service
    public class ProcessManagerImpl implements ProcessManager, InitializingBean {
    
        @Resource
        private List<Processor> processors;
    
        @Resource
        private List<Validator> validators;
    
        @Override
        public void process(Map<String, Object> map) {
            for (Processor processor : processors) {
                processor.process(map);
            }
    
            for (Validator validator : validators) {
                validator.validate(map);
            }
        }
    
        @Override
        public void afterPropertiesSet() {
            sort(processors);
            sort(validators);
        }
    
        public <R extends Priority> void sort(List<R> objs) {
            if (!CollectionUtils.isEmpty(objs)) {
                Collections.sort(objs, new PriorityComparator());
            }
        }
    
        class PriorityComparator implements Comparator<Priority> {
            @Override
            public int compare(Priority p1, Priority p2) {
                if (p1.getPriority() > p2.getPriority()) {
                    return -1;
                } else if (p1.getPriority() == p2.getPriority()) {
                    return 0;
                }
                return 1;
            }
        }
    }

### 测试 ###

@RestController
    public class TestPAndV {
    
        @Resource
        private ProcessManager processManager;
    
        @RequestMapping("/testPAndV")
        public void test(){
            Map<String,Object> map = new HashMap<>();
            map.put("name","王弘博");
            processManager.process(map);
        }
    }

### 测试结果 ###

![20191231152856466.png][]

### 总结： ###

这样子的话，我哪一个处理器、校验器不想用了，直接把need改为false即可

当我想加一个新的处理器、校验器的时候，只需要再新增一个业务类，继承超类，给上优先级大小，然后编写自己的业务逻辑即可。

代码结构：

![2019123115372053.png][]

[20191231150253482.png]: /images/1603595520870.png
[20191231152856466.png]: /images/1603595507256.png
[2019123115372053.png]: /images/1603595491118.png