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

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