rxjava等系列产品.思想是很好的,但是被大多数人用成了一坨屎!

就拿rx最经典的那个例子来说:

假设有这样一个需求:界面上有一个自定义的视图 imageCollectorView ,它的作用是显示多张图片,并能使用 addImage(Bitmap) 方法来任意增加显示的图片。现在需要程序将一个给出的目录数组 File[] folders 中每个目录下的 png 图片都加载出来并显示在imageCollectorView 中。需要注意的是,由于读取图片的这一过程较为耗时,需要放在后台执行,而图片的显示则必须在 UI 线程执行。常用的实现方式有多种,我这里贴出其中一种:

newThread() {
@Overridepublic voidrun() {super.run();for(File folder : folders) {
File[] files=folder.listFiles();for(File file : files) {if (file.getName().endsWith(".png")) {final Bitmap bitmap =getBitmapFromFile(file);
getActivity().runOnUiThread(newRunnable() {
@Overridepublic voidrun() {
imageCollectorView.addImage(bitmap);
}
});
}
}
}
}
}.start();
猛一看有点繁琐,应该可以优化下,别急先看看rx怎么实现.
rxjava :
Observable.from(folders)
.flatMap(new Func1>() {
@Overridepublic Observablecall(File file) {returnObservable.from(file.listFiles());
}
})
.filter(new Func1() {
@OverridepublicBoolean call(File file) {return file.getName().endsWith(".png");
}
})
.map(new Func1() {
@OverridepublicBitmap call(File file) {returngetBitmapFromFile(file);
}
})
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1() {
@Overridepublic voidcall(Bitmap bitmap) {
imageCollectorView.addImage(bitmap);
}
});
猛一看mdzz(玛德制杖),仔细一看mdzzz(玛德真制杖)----> 代码写成这样不脑残么?知不知道什么叫做解耦合啊?
我的实现:
//----------开始加载所有图片
public voidaddAllImg(){
x.task().run(new Runnable() {//我用xutils3异步任务
@Overridepublic voidrun() {for (File folder : folders) { //遍历文件夹
File[] files =folder.listFiles();for (File file : files) { //遍历文件
addAllImg_1(file); //调用后续方法处理
}
}
}
});
}private void addAllImg_1(File file){ //处理,更新ui等 if (file.getName().endsWith(".png")) {final Bitmap bitmap =getBitmapFromFile(file);
getActivity().runOnUiThread(newRunnable() {
@Overridepublic voidrun() {
imageCollectorView.addImage(bitmap);
}
});
}
}
//----------加载所有图片完毕
rx系列缺点太多了,任意一条都够理由不用他了       因为有更好的实现呀
1.过度使用设计模式,逻辑是只有一条但是代码被你们写成了屎呀  还链式也是醉人
什么叫链式,看我的实现...     支持继续扩展 2 3 4 5 6 ... n
private void addAllImg_2()
private void addAllImg_3()
...
2.好的思想不懂合理利用,看看Android-LessCallBack是怎么用的
//按id顺序执行的
public classTest2 {
@TaskFlow(thread= true, id = 0)public voiddoTask1() {
System.out.println(Thread.currentThread().getName()+":"+"任务1");
waitTime();
}
@TaskFlow(thread= false, id = 1)public voiddoTask1Finish() {
System.out.println(Thread.currentThread().getName()+":"+"任务1执行结束");
}
@TaskFlow(thread= true, id = 2)public voiddoTask2() {
System.out.println(Thread.currentThread().getName()+":"+"任务2");
waitTime();
}
@TaskFlow(thread= false, id = 3)public voiddoTask2Finish() {
System.out.println(Thread.currentThread().getName()+":"+"任务2执行结束");
}public static voidmain(String[] args) {
TaskFlowUtils.inject(newTest2()).run();;
}public static voidwaitTime(){int x = new Random().nextInt(1000) + 500;try{
System.out.println("等待"+x+"毫秒");
Thread.sleep(x);
}catch(InterruptedException e) {//TODO Auto-generated catch block
e.printStackTrace();
}
}
}

线程:任务1

等待515毫秒

ui线程:任务1执行结束

线程:任务2

等待655毫秒

ui线程:任务2执行结束

在我看来其与rx类似,都用到next这一思想,不同的是:

lesscallback 实现复杂,调用简单

rx实现复杂,调用也特么复杂

3.耦合度太大导致调试困难的问题...满眼的next  subscribe observe

有写问题写时候,你可能没发现   维护时候你就懂了

4.学习难度大,想要吃个牛肉串你让我先学宰牛?

5.少用interface 如果可以,尽量不要用  (interface是一种挖洞行为,除非不可避免否则不要挖洞)

对于你们那些  网络请求还先写个interface的我表示无法理解  每个页面都有自己的功能,在各自的页面(函数里)实现自己的功能 更是一种分布式的思想

随便搜一下都是rx怎么怎么好,支持什么什么  可以扩展什么什么  巴拉巴拉... 真正有自己的理解的有几个?

一群小菜比

大道至简,如果理解深刻,用起来会非常简单,搞出来那么复杂的东西  只说明你们理解不太深刻.