使用資料流的思想處理檔案

先上一波使用方式，有用過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走起