使用数据流的思想处理文件

先上一波使用方式，有用过Rxjava的童鞋应该感觉很熟悉吧，里面参考了很多Rxjava里面的想法（虽然代码完全不一样）

TaskFlow.create()
        .with(file)
        .flatMap(new ScanPlugin() {
            @Override
            public FileNameFilter getFileNameFilter() {
                return new FileNameFilter() {
                    @Override
                    public boolean accept(String fileName) {
                        if (fileName.endsWith("XML")){
                            return true;
                        }
                        return false;
                    }
                };
            }
        })
        .doOnNext(new TransferPlugin() {
            @Override
            public String getDistPath() {
                return path;
            }
        })
        .doOnNext(new Plugin<String, Integer>() {
            private Integer mSuccess;

            @Override
            public String excute() {
                if (mSuccess>1) {
                    return "haha";
                }else {
                    return "aaaa";
                }
            }
            @Override
            public void setParameter(Integer success) {
                mSuccess = success;
            }
        })
        .start(new TaskFlow.Excuter() {
            @Override
            public void onNext(Object obj) {
                SuperLogger.e(obj);
            }

            @Override
            public void onError(Throwable e) {
                SuperLogger.e("任务出错了");
                e.printStackTrace();
            }

            @Override
            public void onComplete() {
                SuperLogger.e("完成了");
            }
        });

做过文件扫描入库应该都能明显感觉到，入库流程里面有很多动作是可复用的，文件的处理是多个动作的组合。不同的文件可能执行的顺序不一样，需要的执行的动作有些不同。

TaskFlow 解决什么问题：

1、数据有了明确的流向，从上往下，上一个点的输出是下一个点的输入，代码再长，一眼便知处理的流程;
2、处理步骤可以无限多，可随意组合，每一个任务就是一个plugin，强大的扩展性；

特别功能介绍：

1、扫描后的文件的List，可以通过flatMap可以拆分成一个个的单元发射给后面的任务（此处是核心）
2、能获取每个任务处理后的结果，每次处理后的结果都会传递给Excuter 的onNext方法
3、异常唯一出口

关键代码：

1、将普通的plugin包装成FlatPlugin，跟其它plugin作区分

public <R,T> TaskFlow flatMap(final Plugin<List<R>,T> plugin) {
        FlatPlugin flatPlugin = new FlatPlugin<List<R>,T>() {
            @Override
            public List<R> excute() throws Exception {
                return plugin.excute();
            }

            @Override
            public void setParameter(T t) {
                plugin.setParameter(t);
            }
        };
        flatPlugin.setPlugin(plugin);
        doOnNext(flatPlugin);
        return this;
    }

2、这个很简单，只是将每个plugin添加到任务列表

public <R,T> TaskFlow doOnNext(Plugin<R,T> plugin) {
        if (plugin==null){
            throw new RuntimeException("Plugin 不能为空");
        }
        if (mPlugins == null) {
            mPlugins = new ArrayList<>();
        }
        mPlugins.add(plugin);
        return this;
    }

3、重头戏来了，整个任务执行的核心。使用递归可以使任务flatMap个数不受限制

private void excute(Excuter excuter,List<Plugin> plugins, Object result) throws Exception {
        for (int i = 0; i < plugins.size(); i++) {
            Plugin plugin = plugins.get(i);
            plugin.setParameter(result);
            if (plugin instanceof FlatPlugin){
                List list = (List) plugin.excute();
                List<Plugin> pluginList = plugins.subList(i+1,plugins.size());//去掉flatMap之前的那些任务
                plugins = plugins.subList(0,i);//不加会造成flatMap最后一个任务会多执行一次
                for (int j = 0; j < list.size(); j++) {
                    result=list.get(j);
                    excute(excuter,pluginList,result);
                }
            }else {
                result = plugin.excute();
                excuter.onNext(result);
            }
        }
    }

github走起

最后编辑于：2018.07.26 20:55:50