Android代码重构之-优雅的解决顺序调用方法之间的耦合

背景

before:

在咱们APP启动过程,咱们可能经常有这样的需求:在APP第一次进入的时候根据网络请求的结果弹一个对话框式的广告, ok~ 很简单,那么代码大体就是这样(这边都是伪代码,为了方便理解):java

@Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
       checkFirstDialogIfNeed();
    }
    /** * step 1 */
    private void checkFirstDialogIfNeed(){
        Utils.fakeRequest("http://www.api1.com", new HttpCallBack() {
            @Override
            public void onOk() {
                showADialog();
            }

            @Override
            public void onFailure() {
               //do nothing
            }
        });
    }
复制代码

ok,作完上线node

step1

过了一阵子,产品同窗又跑过来了说: “老板的需求,咱们要在首页第一次进来的时候加一个注册协议的弹框” 程序员小A: “但是首页已经以前有一个弹框了,直接一块儿展现吗?” 产品同窗: “一块儿弹出来体验很差,那你放在A弹框以后吧!”git

ok,那么程序员小A寻思了一下,那应该就是这么改了:程序员

@Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
           checkFirstDialogIfNeed();
    }

    private void checkFirstDialogIfNeed(){
        Utils.fakeRequest("http://www.api1.com", new HttpCallBack() {
            @Override
            public void onOk() {
                showADialog();
            }

            @Override
            public void onFailure() {
                //请求失败直接跳过，请求注册协议
                checkRegisterAgreement();
            }
        });
    }

    private void showADialog() {
        new AlertDialog.Builder(this)
                .setTitle("这是一条有态度的广告")
                .setPositiveButton("我看完了", null)
                .setOnDismissListener(new DialogInterface.OnDismissListener() {
                    @Override
                    public void onDismiss(DialogInterface dialogInterface) {
                    	//弹框结束后请求注册协议
                        checkRegisterAgreement();
                    }
                }).create().show();
    }
    private void checkRegisterAgreement() {
        Utils.fakeRequest("http://www.api2.com", new HttpCallBack() {
            @Override
            public void onOk() {
                showBDialog();
            }

            @Override
            public void onFailure() {
                //do nothing
            }
        });
    }
复制代码

这么下来,咱们先请求接口APi1,若是成功了弹广告弹框A,弹框结束了调用注册协议的方法,若是APi1 请求失败,直接跳过广告弹框A,继而请求注册协议,当注册协议请求成功了弹出咱们的注册协议弹框,这么下来,咱们确实能够保证注册协议弹框在广告弹框以后~github

step2

过了几天,产品同窗又来了:“此次咱们首页初次进来再加一个H5页面跳转,此次就加在广告和注册协议之间吧....”api

因而乎,小A继续改了改代码,整个代码就成了这样:数组

@Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        checkFirstDialogIfNeed();
    }

    private void checkFirstDialogIfNeed() {
        Utils.fakeRequest("http://www.api1.com", new HttpCallBack() {
            @Override
            public void onOk() {
                showADialog();
            }

            @Override
            public void onFailure() {
// //请求失败直接跳过，请求注册协议
// checkRegisterAgreement();
                checkNeedShowH5();
            }
        });
    }

    private void showADialog() {
        new AlertDialog.Builder(this)
                .setTitle("这是一条有态度的广告")
                .setPositiveButton("我看完了", null)
                .setOnDismissListener(new DialogInterface.OnDismissListener() {
                    @Override
                    public void onDismiss(DialogInterface dialogInterface) {
                        // //弹框结束后请求注册协议
// checkRegisterAgreement();
                        //如今产品要插入一个H5页面优先请求
                        checkNeedShowH5();

                    }
                }).create().show();
    }
    
    private void checkRegisterAgreement() {
        Utils.fakeRequest("http://www.api2.com", new HttpCallBack() {
            @Override
            public void onOk() {
                showBDialog();
            }

            @Override
            public void onFailure() {
                //do nothing
            }
        });
    }

    private void showBDialog() {
        new AlertDialog.Builder(this)
                .setTitle("这是注册协议")
                .setPositiveButton("我看完了", null)
                .setOnDismissListener(new DialogInterface.OnDismissListener() {
                    @Override
                    public void onDismiss(DialogInterface dialogInterface) {
                        //do nothing
                    }
                }).create().show();
    }

    private void checkNeedShowH5() {
        Utils.fakeRequest("http://www.api3.com", new HttpCallBack() {
            @Override
            public void onOk() {
                toH5Page();
            }

            @Override
            public void onFailure() {
                checkRegisterAgreement();
            }
        });
    }

    private void toH5Page() {
        startActivityForResult(new Intent(this, TestH5Activity.class), REQUEST_CODE_H5);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        switch (requestCode) {
            case REQUEST_CODE_H5:
                checkRegisterAgreement();
                break;
            default:
                break;
        }
    }
复制代码

首先将原有step1 结束以后再也不调用注册协议,而是调用请求H5的方法
因为去H5是一个Activity的跳转,因此咱们在onActivityResult里咱们继续以前的注册协议的调用.

看看大体demo效果: markdown

再后来......几经迭代,首页首次的弹框和页面跳转已经有七、8个了,当每次产品有相似需求的时候,咱们又要重复上面的过程了,每次大概梳理个大半天吧.网络

你们是否有发现什么问题吗? 1.首页次序之间强耦合,每次一旦要在两者以前插入一个其余弹框或者页面,咱们每次都要修改在它以前和以后的调用链,至少要修改三处,很容易漏掉,可是实际上它们彼此之间除了次序以外,没有其余关联. 2.每次新需求来的时候都要完整梳理原有逻辑,比较浪费时间,影响效率.数据结构

思考:

1.可否在一个链中统一管理要处理的事情,每一个事情之间互相不关联,只要简单配置就能够轻松替换它们之间的顺序. 2.后来维护者,很清晰的就能知道调用的次序,无需每次从新梳理整个业务代码.

设计:

1.咱们是否能够把每件要作的事情抽象成一个节点,每一个节点只关心本身的任务是否完成,它并不知道它是第几个,也不知道它前面或者后面的是谁. 2.每一个节点统一由一个流来管理,它做为全局统筹者,能够控制从任意节点开始、控制整个流的开启与结束等,每一个节点的顺序由流来管理.

实现:

after:

带着以上设计思路,我对代码作了一下重构,代码变成了这样:

public class AfterActivity extends AppCompatActivity {

    private static final int REQUEST_CODE_H5 = 1;

    /** * 初次广告弹框 */
    private static final int NODE_FIRST_AD = 10;

    /** * 初次进入h5页 */
    private static final int NODE_CHECK_H5 = 20;

    /** * 初次进入的注册协议 */
    private static final int NODE_REGISTER_AGREEMENT = 30;

    private WorkFlow workFlow;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        startWorkFlow();
    }

    private void startWorkFlow() {
        workFlow = new WorkFlow.Builder()
                .withNode(getFirstAdNode())
                .withNode(getShowRegisterAgreementNode())
                .withNode(getShowH5Node())
                .create();
        workFlow.start();
    }

    private WorkNode getFirstAdNode() {
        return WorkNode.build(NODE_FIRST_AD, new Worker() {
            @Override
            public void doWork(final Node current) {
                Utils.fakeRequest("http://www.api1.com", new HttpCallBack() {
                    @Override
                    public void onOk() {
                        new AlertDialog.Builder(AfterActivity.this)
                                .setTitle("这是一条有态度的广告")
                                .setPositiveButton("我看完了", null)
                                .setOnDismissListener(new DialogInterface.OnDismissListener() {
                                    @Override
                                    public void onDismiss(DialogInterface dialogInterface) {
                                        //仅仅只需关心本身是否完成，下一个节点会自动执行
                                        current.onCompleted();
                                    }
                                }).create().show();
                    }

                    @Override
                    public void onFailure() {
                        //仅仅只需关心本身是否完成，下一个节点会自动执行
                        current.onCompleted();
                    }
                });
            }
        });
    }

    private WorkNode getShowRegisterAgreementNode() {
        return WorkNode.build(NODE_REGISTER_AGREEMENT, new Worker() {
            @Override
            public void doWork(final Node current) {
                Utils.fakeRequest("http://www.api2.com", new HttpCallBack() {
                    @Override
                    public void onOk() {
                        new AlertDialog.Builder(AfterActivity.this)
                                .setTitle("这是注册协议")
                                .setPositiveButton("我看完了", null)
                                .setOnDismissListener(new DialogInterface.OnDismissListener() {
                                    @Override
                                    public void onDismiss(DialogInterface dialogInterface) {
                                        current.onCompleted();
                                    }
                                }).create().show();
                    }

                    @Override
                    public void onFailure() {
                        current.onCompleted();
                    }
                });
            }
        });
    }

    private WorkNode getShowH5Node() {
        return (WorkNode.build(NODE_CHECK_H5, new Worker() {
            @Override
            public void doWork(final Node current) {
                Utils.fakeRequest("http://www.api3.com", new HttpCallBack() {
                    @Override
                    public void onOk() {
                        startActivityForResult(new Intent(AfterActivity.this, TestH5Activity.class), REQUEST_CODE_H5);
                    }

                    @Override
                    public void onFailure() {
                        current.onCompleted();
                    }
                });
            }
        }));
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        switch (requestCode) {
            case REQUEST_CODE_H5:
                workFlow.continueWork();
                break;
            default:
                break;
        }
    }
}
复制代码

通过上述重构,如今的首页流程:

进入首页要作的几件事之间相互无关联,它们的位置能够任意切换,只需改变id大小即可轻松调整它们的执行顺序.
想要加入或者插入节点无需改动原有逻辑.

项目源码传送门

实现思路:

设计每一个工做节点

1.我但愿每一个任务间彼此独立,只关心本身的事情是否完成,我把它抽象成一个节点,每一个节点只有本身的节点id 和完成的方法:

public interface Node {
    /** * 节点id * * @return 当前节点id */
    int getId();
    /** * 任务完成时触发 */
    void onCompleted();
}
复制代码

至于为何要提供id,后面会讲到.

咱们再来看看它的实现类WorkNode的核心代码:

public class WorkNode implements Node {
    /** * 节点id */
    private int nodeId;

    /** * 节点工做者 */
    private Worker worker;

    private WorkCallBack callBack;

  	public static WorkNode build(int nodeId, Worker worker) {
        return new WorkNode(nodeId, worker);
    }

    /** * @param worker 调用者传入，即真正执行要作的事情 */
    public WorkNode(int nodeId, Worker worker) {
        this.nodeId = nodeId;
        this.worker = worker;
    }

    /** * 由workFlow来决定调用 * * @param callBack 当调用onCompleted 以后回调给WorkFlow */
    void doWork(WorkCallBack callBack) {
        this.callBack = callBack;
        worker.doWork(this);
    }

    @Override
    public int getId() {
        return nodeId;
    }

    @Override
    public void onCompleted() {
        if (null != callBack) {
            callBack.onWorkCompleted();
        }
    }

    interface WorkCallBack {

        /** * 当前任务完成 */
        void onWorkCompleted();

    }
}
复制代码

构造方法中传入了节点id,和Worker, 这个Worker的doWork方法的实现就是咱们这个节点真正要作的事情:

public interface Worker {
    /** * 执行任务 * * @param current 当前节点 */
    void doWork(Node current);

}
复制代码

至此咱们回看下demo中对WorkNode的构建:

private WorkNode getFirstAdNode() {
        return WorkNode.build(NODE_FIRST_AD, new Worker() {
            @Override
            public void doWork(final Node current) {
                Utils.fakeRequest("http://www.api1.com", new HttpCallBack() {
                    @Override
                    public void onOk() {
                        new AlertDialog.Builder(AfterActivity.this)
                                .setTitle("这是一条有态度的广告")
                                .setPositiveButton("我看完了", null)
                                .setOnDismissListener(new DialogInterface.OnDismissListener() {
                                    @Override
                                    public void onDismiss(DialogInterface dialogInterface) {
                                        //仅仅只需关心本身是否完成，下一个节点会自动执行
                                        current.onCompleted();
                                    }
                                }).create().show();
                    }

                    @Override
                    public void onFailure() {
                        //仅仅只需关心本身是否完成，下一个节点会自动执行
                        current.onCompleted();
                    }
                });
            }
        });
    }
复制代码

是否是很清晰?节点只须要关心本身是否作完了,调用完onCompleted以后,一切与我无关了,后续作什么就交给WorkFlow去处理了.

那节点的doWork方法是何时被调用的呢? 它内部是怎么安排工做的呢?,咱们来设计WorkFlow.

设计工做流:

首先做为全部节点的管理者,固然要把它们存下来,用什么数据结构来存呢?回顾一下个人需求: 能够灵活控制节点的执行顺序, so...通过反复筛选,我最终选择了SparseArray来存放咱们全部的节点,由于咱们为每一个节点提供id做为key:

一来能够提升代码可读性.
二来,SparseArray内部是数组实现的,并且是按照key的大小升序排列的,基于这个特性,咱们只须要改变定义Key值的大小关系就能够改变它们在数组中的顺序.

若是你对SparseArray 的原理不是特别了解,能够参考个人上一篇文章:

SparseArray 那些事儿（带给你更细致的分析）

咱们再来看看用SparseArray来实现的WorkFlow:

public class WorkFlow {

    private SparseArray<WorkNode> flowNodes;

    public WorkFlow(SparseArray<WorkNode> flowNodes) {
        this.flowNodes = flowNodes;
    }

    /** * 开始工做，默认从第一个节点 */
    public void start() {
        startWithNode(flowNodes.keyAt(0));
    }

    /** * 基于某个节点Id 开始工做 * * @param startNodeId 节点id */
    public void startWithNode(int startNodeId) {
        final int startIndex = flowNodes.indexOfKey(startNodeId);
        WorkNode startNode = flowNodes.valueAt(startIndex);
        startNode.doWork(new WorkNode.WorkCallBack() {
            @Override
            public void onWorkCompleted() {
                findAndExecuteNextNodeIfExist(startIndex);
            }
        });
    }

    private void findAndExecuteNextNodeIfExist(int startIndex) {
        final int nextIndex = startIndex + 1;
        final WorkNode nextNode = flowNodes.valueAt(nextIndex);
        if (null != nextNode) {
            nextNode.doWork(new WorkNode.WorkCallBack() {
                @Override
                public void onWorkCompleted() {
                    findAndExecuteNextNodeIfExist(nextIndex);
                }
            });
        }
    }
    
}
复制代码

咱们在demo中调用的start()的方法,其实内部调用的是 startWithNode 方法,这个方法接收一个参数 startNodeId ,也就是咱们构建节点的id,咱们在 SparseArray 中找到节点,直接开始执行.
当咱们在节点内部调用完 onCompleted 方法以后, 会直接回调 onWorkCompleted 方法,此时咱们再看看是否有下一个节点,当有下一个节点以后,一直递归到下一个没有节点为止.

至此,咱们原理基本分析完成,经过内部 SparseArray的设计,咱们能够灵活从任意节点开始执行,外部的WorkFlow就是一个全局的管理者,咱们能够拓展不少其余功能,好比 continueWork() :当咱们在节点之外但愿让流程继续执行下去的时候(参考Demo的 onActivityResult), revert():回退到上一节点等等

总结:

WorkFlow,很好的接耦了各个次序任务直接的相互依赖,提升了开发效率
它也很好的提升了代码的可维护性和可读性,很是便于后来新次序任务的拓展