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效果:

再后来…几经迭代,首页首次的弹框和页面跳转已经有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. 想要加入或者插入节点无需改动原有逻辑.

项目源码传送门

实现思路

设计每个工作节点

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

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

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

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

上述【高清技术脑图】以及【配套的架构技术PDF】可以 加我wx：X1524478394 免费获取

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

原文地址：https://blog.51cto.com/14332859/2459389

时间： 2024-10-28 23:51:11

Android 代码优化：“这个需求很简单，怎么实现我不管”的相关文章

OSChina 周一乱弹 —— 这个需求很简单！

周一,第一次闹钟其实我是拒绝的!无奈长得漂亮,总是要早起的,听说长得丑的还在被窝里? @刘越  : 今天早上居然没起床成功,你以为是我的错,错!是我写的闹钟有BUG...Android闪光灯闹钟1.2版本登场啦,修复任何逃出闹钟的按键BUG,增加震动功能,APK文件更是瘦身到了65.2KB,哈哈哈,明日绝对起床啦 地址:http://git.oschina.net/voyageliu/FlashAlarm 牛逼闪闪的闹钟,看来 OSCer 的全勤奖都有希望了哈- 起床呼吸呼吸新鲜空气,不知道帝都

需求很简单：实现win10的开机自启Flask网站，可这一点都不简单

最近写了一个python发udp包的小程序(具体干什么的就不说了,一猜就知道不是干什么好事的 呵呵)然后用flask启个web,网页操作方便.由于公司内网也没台服务器啥的,只能启在自己电脑上了- -. 不需要性能,想脚本启动,加到shell:startup里就行了 start.bat     python e:\flask\index.py

[电子书] 《Android编程入门很简单》

<Android编程入门很简单>是一本与众不同的Android学习读物,是一本化繁为简,把抽象问题具体化,把复杂问题简单化的书.本书避免出现云山雾罩.晦涩难懂的讲解,代之以轻松活泼.由浅入深的剖析.这必将使得阅读本书的堵着少走弯路,快速上手,从而建立学习Android开发的信心. 链接: http://pan.baidu.com/s/1sj2xesH 密码: juab

Android代码优化小技巧

这篇文章主要介绍一些小细节的优化技巧,当这些小技巧综合使用起来的时候,对于整个App的性能提升还是有作用的,只是不能较大幅度的提升性能而已.选择合适的算法与数据结构才应该是你首要考虑的因素,在这篇文章中不会涉及这方面.你应该使用这篇文章中的小技巧作为平时写代码的习惯,这样能够提升代码的效率. 通常来说,高效的代码需要满足下面两个规则: 不要做冗余的工作 如果能避免,尽量不要分配内存 在优化App时最难解决的问题之一就是让App能在各种类型的设备上运行.不同版本的虚拟机在不同的处理器上会有不同的运

Android 设计随便说说之简单实践（合理组合）

上一篇(Android 设计随便说说之简单实践(模块划分))例举了应用商店设计来说明怎么做模块划分.模块划分主要依赖于第一是业务需求,具体是怎么样的业务.应用商店则包括两个业务,就是向用户展示applist,和下载app.第二是运行环境,在Android平台,有androidsdk提供socket等API支持.因此将模块大体换发了5个模块.(当然了图片加载可以额外提出,用开源组件去做,但是这里为了说明如何设计,暂不提到.还有下载也可以利用开源组件)分别是如下: 模块1 UI模块,负责展示信息和用

读书笔记：《写给大家看的面向对象设计》，《程序员的职业素养》，《设计模式其实很简单》

按照上次的计划 看了三本书,笔记现在才贴出来. <写给大家看的面向对象设计>: 使用接口开发的作用 规范函数命名,特别在项目人数比较多,在设计时,定了接口命名与参数. 可以把前台与后台的脱离.定义接口后,实现接口并返回模拟的数据,例如DataTable等,前台不需等后台就可以做UI与交互,改善UI与需要的数据,发现问题并不断完善接口.后台按照需求把数据库设计好了(如果是领域驱动开发,是Model创建),按照这个接口来开发功能,完成之后前台切换过来即可.前后台是并行开发. 便于单元测试的编写,其

自定义控件其实很简单7/12

尊重原创转载请注明:From AigeStudio(http://blog.csdn.net/aigestudio)Power by Aige 侵权必究! 炮兵镇楼 要在数量上统计中国菜的品种,在地域上毫无争议地划分菜系,在今天,是一件几乎不可能完成的事--Cut----抱歉--忘吃药了,再来一遍.如果非要对自定义控件的流程进行一个简单的划分,我会尝试将其分为三大部分:控件的绘制.控件的测量和控件的交互行为.前面我们用了六节的篇幅和一个翻页的例子来对控件的绘制有了一个全新的认识但是我们所做出的所

老猪带你玩转android自定义控件一——打造最简单viewpagerindicator

viewpagerindicator,既使用viewpager翻页时候,标题的指示条随着改变的控件,是常用android控件之一,几乎所有的新闻类APP中都有使用.如下图所示: 今天,我们将从0到1实现这一控件. 其实,实现这一控件思路很简单: ①对头部的标题栏进行布局,头部标题栏,只能进行单选,这符合radiobutton的特质,但是普通的radiobutton,不是这样的吗? 显然,我们在这里需要写样式进行处理,由于头部标题栏的条目非常的多,一个屏幕放不下,因此我们需要一个水平滚动条来盛放这

自定义控件其实很简单1/4

尊重原创转载请注明:From AigeStudio(http://blog.csdn.net/aigestudio)Power by Aige 侵权必究! 炮兵镇楼 上一回关羽操刀怒砍秦桧子龙拼命相救,岂料刘备这狗贼耍赖以张飞为祭品特殊召唤黑暗大法师消灭了场上所有逗逼,霎时间血流成河,鲜红的血液与冰冷的大地融合交汇在一起焕发出血液的煞气……那么,问题来了,请问这是使用了哪种PorterDuffXfermode? 在上一节的最后一个Example中我们做了一个橡皮擦的View,但是这个View虽然