您所在的位置: > 主页 > 华夏经济网 > 科技 > 正文
Android 代码优化:“这个需求很简单,怎么实现我不管”来源: 日期:2020-04-04 10:54:24  阅读:-


    Android 代码优化:“这个需求很简单,怎么实现我不管”

    背景

    before:

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

      @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,做完上线

    step1

    过了一阵子,产品同学又跑过来了说:

    “老板的需求,我们要在首页第一次进来的时候加一个注册协议的弹框”

    程序员小A: “可是首页已经之前有一个弹框了,直接一起展示吗?”

    产品同学: “一起弹出来体验不好,那你放在A弹框之后吧!”

    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,继而请求注册协议,当注册协议请求成功了弹出我们的注册协议弹框,这么下来,我们确实可以保证注册协议弹框在广告弹框之后~

    step2

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

    于是乎,小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效果:

    Android 代码优化:“这个需求很简单,怎么实现我不管”

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

    大家是否有发现什么问题吗?

    1.首页次序之间强耦合,每次一旦要在二者之前插入一个其他弹框或者页面,我们每次都要修改在它之前和之后的调用链,至少要修改三处,很容易漏掉,但是实际上它们彼此之间除了次序之外,没有其他关联.

    2.每次新需求来的时候都要完整梳理原有逻辑,比较浪费时间,影响效率.

    怎么办?

    思考:

    1.能否在一个链中统一管理要处理的事情,每个事情之间互相不关联,只要简单配置就可以轻松替换它们之间的顺序.

    2.后来维护者,很清晰的就能知道调用的次序,无需每次重新梳理整个业务代码.

    设计:

    1.我们是否可以把每件要做的事情抽象成一个节点,每个节点只关心自己的任务是否完成,它并不知道它是第几个,也不知道它前面或者后面的是谁.

    2.每个节点统一由一个流来管理,它作为全局统筹者,可以控制从任意节点开始、控制整个流的开启与结束等,每个节点的顺序由流来管理.

    实现:

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

    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;
    }
    }
    }

    经过上述重构,现在的首页流程:

    1. 进入首页要做的几件事之间相互无关联,它们的位置可以任意切换,只需改变id大小便可轻松调整它们的执行顺序.

    2. 想要加入或者插入节点无需改动原有逻辑.

    Android 代码优化:“这个需求很简单,怎么实现我不管”

    实现思路

    设计每个工作节点

    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来实现的WorkFlow:

    public class WorkFlow {

    private SparseArray flowNodes;

    public WorkFlow(SparseArray 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,很好的接耦了各个次序任务直接的相互依赖,提高了开发效率。
    • 它也很好的提高了代码的可维护性和可读性,非常便于后来新次序任务的拓展。

    最后对于程序员来说,要学习的知识内容、技术有太多太多,要想不被环境淘汰就只有不断提升自己,从来都是我们去适应环境,而不是环境来适应我们!

    这里附上上述的技术体系图相关的几十套腾讯、头条、阿里、美团等公司19年的面试题,把技术点整理成了视频和PDF(实际上比预期多花了不少精力),包含知识脉络 + 诸多细节,由于篇幅有限,这里以图片的形式给大家展示一部分。

    相信它会给大家带来很多收获:

    Android 代码优化:“这个需求很简单,怎么实现我不管”

    上述【高清技术脑图】以及【配套的架构技术PDF】可以 私信我【面试】免费获取!

    当程序员容易,当一个优秀的程序员是需要不断学习的,从初级程序员到高级程序员,从初级架构师到资深架构师,或者走向管理,从技术经理到技术总监,每个阶段都需要掌握不同的能力。早早确定自己的职业方向,才能在工作和能力提升中甩开同龄人。

    (正文已结束)

    免责声明及提醒:此文内容为本网所转载企业宣传资讯,该相关信息仅为宣传及传递更多信息之目的,不代表本网站观点,文章真实性请浏览者慎重核实!任何投资加盟均有风险,提醒广大民众投资需谨慎!