Android 代码优化:“这个需求很简单,怎么实现我不管”_public class worknode implements node(1)

先自我介绍一下,小编浙江大学毕业,去过华为、字节跳动等大厂,目前阿里P7

深知大多数程序员,想要提升技能,往往是自己摸索成长,但自己不成体系的自学效果低效又漫长,而且极易碰到天花板技术停滞不前!

因此收集整理了一份《2024年最新Android移动开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友。
img
img
img
img
img
img
img

既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上Android开发知识点,真正体系化!

由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新

如果你需要这些资料,可以添加V获取:vip204888 (备注Android)
img

正文

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

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

最后

总而言之,Android开发行业变化太快,作为技术人员就要保持终生学习的态度,让学习力成为核心竞争力,所谓“活到老学到老”只有不断的学习,不断的提升自己,才能跟紧行业的步伐,才能不被时代所淘汰。

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

还有高级架构技术进阶脑图、Android开发面试专题资料,高级进阶架构资料 帮助大家学习提升进阶,也节省大家在网上搜索资料的时间来学习,也可以分享给身边好友一起学习。

网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。

需要这份系统化的资料的朋友,可以添加V获取:vip204888 (备注Android)
img

一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!

图片转存中…(img-bk4DdU6k-1713665902733)]

[外链图片转存中…(img-ALGnVCaD-1713665902733)]

还有高级架构技术进阶脑图、Android开发面试专题资料,高级进阶架构资料 帮助大家学习提升进阶,也节省大家在网上搜索资料的时间来学习,也可以分享给身边好友一起学习。

网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。

需要这份系统化的资料的朋友,可以添加V获取:vip204888 (备注Android)
[外链图片转存中…(img-2fAaY1zJ-1713665902733)]

一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!

  • 12
    点赞
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
实现一个自己的区块链需要考虑到节点之间的同步问题,下面是Java代码实现节点之间同步区块链的示例: 1. Node类 首先定义一个Node类,表示一个区块链节点。该类包含节点的IP地址、端口号以及一个BlockChain对象。 ```java import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.net.Socket; public class Node { private String ip; private int port; private BlockChain blockChain; public Node(String ip, int port, BlockChain blockChain) { this.ip = ip; this.port = port; this.blockChain = blockChain; } public void sync() { try { Socket socket = new Socket(ip, port); ObjectOutputStream out = new ObjectOutputStream(socket.getOutputStream()); ObjectInputStream in = new ObjectInputStream(socket.getInputStream()); // 发送本节点区块链的最后一个区块的哈希值 out.writeObject(blockChain.getLastBlockHash()); // 接收对方节点的区块链 BlockChain remoteBlockChain = (BlockChain) in.readObject(); // 合并本节点和对方节点的区块链 blockChain.merge(remoteBlockChain); in.close(); out.close(); socket.close(); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); } } } ``` 2. BlockChain类 接下来定义一个BlockChain类,表示区块链。该类包含一系列区块、难度值以及一个方法用于合并两个区块链。 ```java import java.util.ArrayList; import java.util.List; public class BlockChain { private int difficulty; private List<Block> blocks; public BlockChain(int difficulty) { this.difficulty = difficulty; this.blocks = new ArrayList<>(); blocks.add(new Block(0, "Genesis Block")); } public String getLastBlockHash() { return blocks.get(blocks.size() - 1).getHash(); } public void addBlock(Block block) { block.mineBlock(difficulty); blocks.add(block); } public void merge(BlockChain other) { if (other.blocks.size() <= blocks.size()) { return; } for (int i = blocks.size(); i < other.blocks.size(); i++) { Block block = other.blocks.get(i); if (block.isValid() && block.getPrevHash().equals(getLastBlockHash())) { blocks.add(block); } else { break; } } } } ``` 3. Block类 最后定义一个Block类,表示区块。该类包含区块的索引、时间戳、交易记录、前一个区块的哈希值以及一个Nonce值。 ```java import java.io.Serializable; import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; import java.util.Date; public class Block implements Serializable { private static final long serialVersionUID = 1L; private int index; private long timestamp; private String data; private String prevHash; private String hash; private int nonce; public Block(int index, String data) { this.index = index; this.timestamp = new Date().getTime(); this.data = data; this.prevHash = ""; this.hash = calculateHash(); this.nonce = 0; } public String getPrevHash() { return prevHash; } public String getHash() { return hash; } public void mineBlock(int difficulty) { String target = new String(new char[difficulty]).replace('\0', '0'); while (!hash.substring(0, difficulty).equals(target)) { nonce++; hash = calculateHash(); } System.out.println("Block mined! Hash: " + hash); } public boolean isValid() { if (!hash.equals(calculateHash())) { return false; } if (!prevHash.isEmpty() && !prevHash.equals(calculatePrevHash())) { return false; } return true; } private String calculateHash() { String data = index + timestamp + this.data + prevHash + nonce; return sha256(data); } private String calculatePrevHash() { String data = (index - 1) + timestamp + data + prevHash + nonce; return sha256(data); } private String sha256(String data) { try { MessageDigest digest = MessageDigest.getInstance("SHA-256"); byte[] hash = digest.digest(data.getBytes()); StringBuffer hexString = new StringBuffer(); for (int i = 0; i < hash.length; i++) { String hex = Integer.toHexString(0xff & hash[i]); if (hex.length() == 1) { hexString.append('0'); } hexString.append(hex); } return hexString.toString(); } catch (NoSuchAlgorithmException e) { e.printStackTrace(); return null; } } } ``` 4. 示例 最后给出一个示例,构建两个节点,它们的IP地址和端口号分别为localhost:8000和localhost:8001。 ```java public class Main { public static void main(String[] args) { BlockChain blockChain1 = new BlockChain(4); blockChain1.addBlock(new Block(1, "Block 1")); blockChain1.addBlock(new Block(2, "Block 2")); BlockChain blockChain2 = new BlockChain(4); blockChain2.addBlock(new Block(1, "Block 1")); Node node1 = new Node("localhost", 8000, blockChain1); Node node2 = new Node("localhost", 8001, blockChain2); node1.sync(); node2.sync(); System.out.println("Node 1: " + blockChain1.getLastBlockHash()); System.out.println("Node 2: " + blockChain2.getLastBlockHash()); } } ``` 在该示例中,节点1先向节点2发送自己区块链的最后一个区块的哈希值,节点2接收到后将自己的区块链发送给节点1,然后节点1将两个区块链合并,最终节点1和节点2的区块链都包含了两个区块。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值