android RxJava使用教程

最新推荐文章于 2024-04-03 20:01:33 发布
最新推荐文章于 2024-04-03 20:01:33 发布
阅读量763 收藏 2
点赞数
分类专栏： android
本文通过实战案例展示了 RxJava 在 Android 开发中的多种应用场景，包括线程切换、接口依赖处理、多数据源合并、构建缓存机制、定时与周期任务执行、数据过滤、界面防抖动、老接口适配以及响应式界面更新。
摘要由CSDN通过智能技术生成

rxjava真实应用场景

在上一篇文章中为解决异常问题，我们引入了rxjava的支持。接下来我们来看看rxjava在实际工程中的显著应用。

场景零：线程切换

rxjava引入让使得线程切换更加的容易，几行代码就可以搞定。RxAnroid的引入更是让我们非常容易的能够切换到UI线程。可以说，引入RxJava，就放弃古老而沉重的AsyncTask吧（初学者还是要学AsyncTask的）。最典型的就是从网络中获取数据，然后在更新界面，很显然获取数据操作需要发生在子线程，更新UI操作发声明在主线程。这里我们以模拟从数据库中获取联系人操作为例：

private void getConcactFromDB() {
    Observable.create(new Observable.OnSubscribe<List<String>>() {
        @Override
        public void call(Subscriber<? super List<String>> subscriber) {
            //模拟从数据库中获取数据
            ArrayList<String> list = new ArrayList<>();
            for (int i = 0; i < 100; i++) {
                list.add("user name:" + i);
            }
            //模拟耗时操作
            SystemClock.sleep(5000);

            subscriber.onNext(list);
            subscriber.onCompleted();
        }
    }).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Action1<List<String>>() {
                @Override
                public void call(List<String> list) {
                    Log.d("MainActivity", "更新界面：" + list.size());
                }
            });
}


场景一：接口依赖(flatmap)

目前大部分服务端接口设计都是通过用户名和密码登录获取access token，后面其他api的请求都是借助该token。对于需要注册功能的产品来说，我们经常面对这样的问题：使用用户名和密码登录成功后，保存服务器返回的access token，再调用服务端接口获取用户的详情信息。不难发现，这里获取用户详情的请求依赖登录请求.我们先来看传统方法是如何解决这问题：

private void handleLogin2(LoginPost post) {
    ApiFactory.getBaseApi().login(post).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new BaseSubscriber<Result<Token>>(this) {
                @Override
                public void onNext(Result<Token> tokenResult) {
                    if (tokenResult.isOk()) {
                        Token data = tokenResult.getData();
                        String token = data.getToken();
                        //保存token操作 ApiFactory.getUserApi().getUserProfile(token).subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                                .subscribe(new BaseSubscriber<Result<User>>(LoginActivity.this) {
                                    @Override
                                    public void onNext(Result<User> userResult) {
                                        //处理用户信息
                                    }

                                    @Override
                                    public void onError(Throwable e) {
                                        //处理错误
                                    }
                                });
                    }
                }

                @Override
                public void onError(Throwable e) {
                    //处理错误
                }
            });
}

开始时，我们大部分人会写出类似以上的代码。当然，这实现了我们想要的逻辑，但当你仔细思考的时候，会发现几个问题：

  1. 回调嵌套看起来令人疑惑。由于我们在大多数情况下是线性思维，那么此时当你看到onNext(Result<Token> tokenResult)中又去嵌套处理获取用户信息的接口你的思维不得不跳跃一下。
  2. 登录功能的异常处理点被分隔了，使我们不得不写出冗余的代码。
  3. 多次线程开销好像可以被进一步优化。

实际上这三个问题的根本原因在于我们在实现登录功能的时候是以方法作为最小单位，而不是以登录逻辑为最小单位，因此看起不是那么的连贯。现在来看看我们应该怎么样让上面的代码具有连贯性：

private void handleLogin(LoginPost post) {
    ApiFactory.getBaseApi().login(post).flatMap(new Func1<Result<Token>, Observable<Result<User>>>() {

        @Override
        public Observable<Result<User>> call(Result<Token> tokenResult) {
            if (tokenResult.isOk()) {//获取token成功
                Token data = tokenResult.getData();
                String token = data.getToken();
                //保存token操作
                return ApiFactory.getUserApi().getUserProfile(token);//获取用户信息
            } else {//获取token，直接触发onError()方法
                return Observable.error(new ApiException(tokenResult.getCode(), tokenResult.getMsg()));
            }
        }
    }).subscribeOn(Schedulers.io())
            .doOnSubscribe(new Action0() {
                @Override
                public void call() {
                    showWaitDialog();
                }
            }).subscribeOn(AndroidSchedulers.mainThread())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new BaseSubscriber<Result<User>>(this) {
                @Override
                public void onCompleted() {
                }

                @Override
                public void onNext(Result<User> userResult) {
                    //处理用户信息

                }

                @Override
                public void onError(Throwable e) {
                    //处理错误
                }
            });


}


通过flatmap操作符，不但解决了接口依赖问题，而且使得代码逻辑相比之前更具有连贯性。另外，这里引入的BaseSubscriber在我们Retrofit响应数据及异常处理策略做过说明了，不明白的同学可以自行查阅。

场景二：接口合并(merge)

很多情况下，一个界面中需要的数据来自多个数据源（请求），而只有当所有的请求的响应数据都拿到之后才能渲染界面。

接口结果同类型

当前数据源来自多个渠道，拿到的结果属于同一类型的，比如有些数据需要从本地数据读取，而另一些数据则从网络中获取，但无论哪个数据源今最后返回的数据类型是一样的，比如：

private Observable<ArrayList<String>> getDataFromNet() {
    ArrayList<String> list = new ArrayList<>();
    for(int i=0;i<10;i++) {
        list.add("data from net:" + i);
    }

    return Observable.just(list);
}

private Observable<ArrayList<String>> getDataFromDisk() {
    ArrayList<String> list = new ArrayList<>();
    for(int i=0;i<10;i++) {
        list.add("data from disk:" + i);
    }

    return Observable.just(list);
}


上面的两个方法分别从磁盘和网络中获取数据，且最后的数据类型都是ArrayList<String>,现在我们来合并这两个接口：

private void getData() {
    Observable.merge(getDataFromDisk(), getDataFromNet()).subscribe(new Subscriber<ArrayList<String>>() {
        @Override
        public void onCompleted() {
            //更新界面
        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(ArrayList<String> list) {
            for (String s : list) {
                Log.d("MainActivity", s);
            }
        }
    });

接口结果不同类型

有些情况下，不同数据源返回的结果类型不一致，那该如何解决呢？比如当前存在两个接口：

@GET("dict/locations")
Observable<Result<ArrayList<String>>> getLocationList();

@GET("user")
Observable<Result<User>> getUserInfo(@Query("id") String id);


只有当这两个请求都完成后才能更新UI，那我们该怎么做呢？同样还是使用merge操作符，关键在于如何区分响应：

private void getData(String uid) {
    Observable<Result<ArrayList<String>>> locationOb = ApiFactory.getUserApi().getLocationList();
    Observable<Result<User>> userOb = ApiFactory.getUserApi().getUserInfo(uid);

    Observable.merge(locationOb,userOb).subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Subscriber<Result<? extends Object>>() {
                @Override
                public void onCompleted() {
                    //更新UI
                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onNext(Result<? extends Object> result) {
                    Object data = result.getData();
                    if (data instanceof User) {
                        //处理用户数据
                    } else if (data instanceof ArrayList) {
                        //处理位置列表
                    }
                }
            });

}


场景三：构建多级缓存（concat）

缓存机制想必是众所周知。这里我们就以常见的三级缓存机制为例：首先从内存中获取数据，如果内存中不存在，则从硬盘中获取数据，如果硬盘中不存在数据，则从网络中获取数据。现在看看RxJava是如何帮我们解决这个问题：

//获取数据
private void getData(String url) {

    Observable.concat(getDataInMemory(url),getDataInDisk(url),getDataInNet(url)).takeFirst(new Func1<Bitmap, Boolean>() {
        @Override
        public Boolean call(Bitmap bitmap) {
            return bitmap!=null;
        }
    }).observeOn(AndroidSchedulers.mainThread()).subscribe(new Action1<Bitmap>() {
        @Override
        public void call(Bitmap bitmap) {
            //处理图片
        }
    });
}

//从内存中获取
private Observable<Bitmap> getDataInMemory(final String url) {
    final Map<String, Bitmap> memoryCache = new HashMap<>();
    //模拟内存中的数据
    //...

    return Observable.create(new Observable.OnSubscribe<Bitmap>() {

        @Override
        public void call(Subscriber<? super Bitmap> subscriber) {
            if (memoryCache.containsKey(url)) {
                subscriber.onNext(memoryCache.get(url));
            }
            subscriber.onCompleted();
        }
    });
}

//从硬盘中获取
private Observable<Bitmap> getDataInDisk(final String url) {
    final Map<String, Bitmap> diskCache = new HashMap<>();
    //模拟内存中的数据
    //...

    return Observable.create(new Observable.OnSubscribe<Bitmap>() {

        @Override
        public void call(Subscriber<? super Bitmap> subscriber) {
            if (diskCache.containsKey(url)) {
                subscriber.onNext(diskCache.get(url));
            }
            subscriber.onCompleted();
        }
    });

}

//从网络中获取
private Observable<Bitmap> getDataInNet(final String url) {
    return Observable.create(new Observable.OnSubscribe<Bitmap>(){

        @Override
        public void call(Subscriber<? super Bitmap> subscriber) {
            Bitmap bitmap=null;
            //从网络获取图片bitmap

            subscriber.onNext(bitmap);
            subscriber.onCompleted();
        }
    }).subscribeOn(Schedulers.io());
}


rxjava为我们提供的concat操作符可以很容的的实现多级缓存机制。这里需要记住在getData()方法中不要忘记使用takeFirst()。concat操作符接受多个Observable，并按其顺序串联， 
在订阅的时候会返回所有Observable的数据（按顺序依次返回）。换言之，如果在getData（）中不实用takeFirst（）,将会并行的从内存，硬盘及网络中检索数据，这显然不是我们想要的。takeFirst操作符可以从返回的数据中取出第一个，并中断数据检索的过程。我们知道，检索速度：内存>硬盘>网络，这就意味着当我们从内存中获取到数据的时候就不会再从硬盘中获取数据，反之，则从硬盘中获取数据；当我们从硬盘中获取到数据的时候就不会再从网络中获取到数据了，反之，则从网络中获取。

这样就实现了我们的最终目标。

场景四：定时任务（timer）

在一些情况下我们需要执行定时任务，传统的做法上有两种方式可选择：Timer和SchelchExector。但是在引入rxjava之后，我们有了第三种选择:

private void startTimerTask() {
    Observable.timer(2, TimeUnit.SECONDS).subscribe(new Action1<Long>() {
        @Override
        public void call(Long aLong) {
            Log.d("MainActivity", "start execute task:" + Thread.currentThread().getName());
        }
    });
}

场景五：周期任务（interval）

当然rxjava通过interval提供了周期任务的支持：

private void startIntervalTask() {
    Observable.interval(5, TimeUnit.SECONDS).subscribe(new Action1<Long>() {
        @Override
        public void call(Long aLong) {
            Log.d("MainActivity", "start task:" + Thread.currentThread().getName());
        }
    });
}


场景六：数据过滤（filter）

在处理集合时，我们经常需要过滤操作，这时候使用filte操作符就非常有用，用个简单示例：

private void dataFilter() {
    final HashSet<String> hashSet = new HashSet<>();
    hashSet.add("1");
    hashSet.add("2");

    ArrayList<String> list = new ArrayList<>();
    list.add("1");
    list.add("2");
    list.add("3");
    list.add("");

    Observable.from(list).filter(new Func1<String, Boolean>() {
        @Override
        public Boolean call(String s) {
            return !TextUtils.isEmpty("") && !hashSet.contains(s);
        }
    }).subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            Log.d("MainActivity", "result: " + s);
        }
    });

}


场景七：界面防抖动（throttleFirst）

所谓的界面防抖动就是用于处理快速点击某控件导致重复打开界面的操作，比如点击某个button可以打开一个Activity，正常情况下，我们一旦点击了该Button便会等待该Activity。在应用响应比较慢，用户以为无响应而多次点击Button或者恶意快速点击的情况下，会重复打开同一个Activity，当用户想要退出该Activity的时候体验会非常差。

通过rxjava提供的throttleFirst操作符我们能够很容易防止按钮在单位时间内被重复点击的问题：

RxView.clicks(mBtnTest2).throttleFirst(1L, TimeUnit.SECONDS).subscribe(new Action1<Void>() {
    @Override
    public void call(Void aVoid) {
        Toast.makeText(MainActivity.this, "button2 clicked", Toast.LENGTH_SHORT).show();
    }
});


场景八：老接口适配(just)

当你在为老项目添加rxjava支持的时候，难免需要将一些方法返回类型转为Observable.通过just操作符不需要对原方法进行任何修改便可实现：

private int oldMethod(int x, int y) {
    return x+y;
}

private void addTest() {
    Observable.just(oldMethod(4, 9)).subscribe(new Action1<Integer>() {
        @Override
        public void call(Integer result) {
            Log.d("MainActivity", "result:" + result);
        }
    });
}


场景九：响应式界面

界面元素更新

在信息填充界面时，我们经常会遇到只有填写完必要的信息之后，提交按钮才能被点击的情况。比如在登录界面时，只有我们填写完用户名和密码之后，登录按钮才能被点击。通过借助rxjava提供的combineLatest操作符我们可以容易的实现这种响应式界面

EditText mEditUsername = (EditText) findViewById(R.id.editText3);
EditText mEditPwd = (EditText) findViewById(R.id.editText4);
final Button mBtnLogin = (Button) findViewById(R.id.button2);
mBtnLogin.setEnabled(false);

Observable<CharSequence> usernameOb = RxTextView.textChanges(mEditUsername);
Observable<CharSequence> pwdOb = RxTextView.textChanges(mEditPwd);

Observable.combineLatest(usernameOb, pwdOb, new Func2<CharSequence, CharSequence, Boolean>() {
    @Override
    public Boolean call(CharSequence username, CharSequence pwd) {

        return !TextUtils.isEmpty(username) && !TextUtils.isEmpty(pwd);
    }
}).subscribe(new Action1<Boolean>() {
    @Override
    public void call(Boolean isLogin) {
        mBtnLogin.setEnabled(isLogin);
    }
});

RxJava内存优化

内存优化

借助rxjava提供的线程调度器Scheduler我们可以很容的实现线程切换，目前Scheduler提供了一下几种调度策略：

  • Schedulers.immediate()：默认的调度策略，不指定线程，也就是运行在当前线程
  • Schedulers。newThread()：运行在一个新创建的线程当中，相当于new Thread()操作。
  • Schedulers.io():采用了线程池机制，内部维护了一个不限制线程数量的线程池，用于IO密集型操作。
  • Schedulers.computation()：同样采用了线程池机制，只不过线程池中线程的数量取决与CPU的核数，以便实现最大性能。通常用于CPU密集型操作，比如图形处理。

通过上面的介绍，我们基本能做出以下使用规则：对于网络请求及读写大量本地数据等操作，既可以采用Schedulers.newThread()也可以采用Schedulers.io()，但是优先采用Schedulers.io()，对于计算量比较大的，当然是采用Schedulers.computation()。 
这样，我们既能达到较好的性能，又尽可能的减少内存占用。

内存泄漏

尽管rxjava非常简单易用，但是随着订阅的增多内存开销也会随之增大，尤其是在配合使用网络请求的时候，稍不注意就容易造成内存泄漏。早期我也犯过多次这种错误。

当我们不需要的时候，主动取消订阅。比如在下面的代码中，我们开启一个周期任务用来不断的输出信息，那么我们需要在该Activity被销毁的时候调用mSubscription.unsubscribe()来主动的解除订阅关系防止内存泄漏。

public class MainActivity extends AppCompatActivity {

    private Subscription mSubscription;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button mBtnTest1 = (Button) findViewById(R.id.btn_test1);

        mBtnTest1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mSubscription = startIntervalTask();
            }
        });
    }

    private Subscription startIntervalTask() {
        return Observable.interval(5, TimeUnit.SECONDS).subscribe(new Action1<Long>() {
            @Override

            public void call(Long aLong) {
                Log.d("MainActivity", "start task:" + Thread.currentThread().getName());
            }
        });
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //主动解除订阅关系
        if (mSubscription != null && !mSubscription.isUnsubscribed()) {
            mSubscription.unsubscribe();
        }
    }
}

看完上面简单的示例，想必你也明白rxjava所造成的内存泄漏往往和组件的生命周期相关。也就是我们要重点关注那些在在组件销毁之后，订阅关系却仍然存在的情况。大部分情况下，当我们的视图销毁之后，订阅关系就没有必要存在了，所以需要我们主动取消订阅即可。

存在一种特殊情况：当我们进入某个界面后，往往会发出网络请求，在返回数据后首先需要缓存数据，然后在更新界面视图。这种情况下当然不能在视图销毁后立刻解除订阅关系。那么这里需要注意的是更新UI之前需要自行判断当前视图是否存在，存在则更新，不存在就没有必要更新了。

在我们的工程中，往往存在很多个视图（Activity，Fragment等），如果在每个视图当中都要手动的解除订阅关系是件很繁琐的事情。这里有两种方式：一是在基类当中，比如BaseActivity，BaseFragment中统一取消订阅，另外一种方式就是使用RxLifeCycle这个库。

总结

这里介绍了有关rxjava一些实际应用场景。尽管rxjava看起来非常容易 使用，但其内存使用问题需要我们重点关注。


本文转自：http://blog.csdn.net/dd864140130/article/details/52714272

RxJava实战技巧大全
Floating Cat
09-30 1万+
这几天一直看《激荡三十年》，感觉非常不错。这篇文章本身并不想写，总觉得没什么含量,后面写着写着，发现其中的有些点还是非常有意思的，因此这篇文章的重点在rxjava使用场景说明及rxjava内存优化上。rxjava的使用场景更多的取决于我们所面临的业务以及当前rxjava的一些操作符是否提供了对业务的支持，而对于内存优化上，则是要求我们尽可能快的解除订阅关系。
Android RxJava： 这是一份全面的 操作符 使用汇总 （含详细实例讲解）(1)
最新发布
2401_84132298的博客
04-22 782
最后为了帮助大家深刻理解Android相关知识点的原理以及面试相关知识，这里放上相关的我搜集整理的24套。
在安卓上使用RxJava
hkg1pek的专栏
04-08 782
如果你做过Android（和Java）的开发，很有可能已经听说过RxJava了。RxJava是由Netflix开发的响应式扩展（Reactive Extensions）的Java实现。引用MSDN上对它的定义，Reactive Extensions是这样一个第三方库：它结合了可观察集合和LINQ式查询以达到异步和基于事件的编程效果。Netflix将这个库托管到了Github上，支持Java6以上的
RxJava使用技巧
09-21 1001
Rxjava简单入门，如果在as使用lambda表达式，以及Retrofit+rxjava+lambda进行网络访问操作。
Android中的RxJava详解
u013495603的专栏
02-29 1125
RxJava 到底是什么一个词：异步。RxJava 在 GitHub 主页上的自我介绍是 “a library for composing asynchronous and event-based programs using observable sequences for the Java VM”（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）。这就是 RxJava
Android中的Rxjava
yuxuehandong的博客
02-21 740
observer 是一个观察者接口，泛型T为观察者观察数据的类型，里面只有三个方法，其中onError()和onCompleted()最后只能调用其中一个，调用了此二方法后onNext()将不会在调用。其中onStart()方法，它会在事件还未发送之前被调用，可以用于做一些准备工作。这是一个可选方法，默认情况下它的实现为空。那么just,from之间的区别是什么呢，通过查看Observable源码,just方法内部也是调用的from方法。onNext()方法可以调用0到多次，观察到的数据处理在此实现。
Android RxJava：这是一份RxJava使用入门学习指南
2401_84009192的博客
04-03 1254
即 开厨房 - 确定对应菜式Next事件、Complete事件 &Error事件。具体如下：具体实现// 1. 创建观察者 （Observer ）对象// 2. 创建对象时通过对应复写对应事件方法 从而 响应对应事件// 观察者接收事件前，默认最先调用复写 onSubscribe（）@OverrideLog.d(TAG, “开始采用subscribe连接”);
Android RxJava使用介绍（二） RxJava的操作符
热门推荐
呼啸而过的专栏
06-03 3万+
上一篇文章我们通过一个简单的例子来给大家展示了RxJava的基本用法，相信大家已经对RxJava有了大概的了解，由于上篇文章对RxJava的使用介绍都是点到为止，并没有进行深入展开，也许你对RxJava有种名不副实的感觉。OK，下面我们就进入正题，一步步的揭开RxJava的神秘面纱！一个例子RxJava的强大之处，在于它提供了非常丰富且功能强悍的操作符，通过使用和组合这些操作符，你几乎能完成所有你想
Android代码-RxJava入门教程例子
08-07
RxJava之扔物线给Android开发者的RxJava详解文章中的例子 Build To build: >$ git clone https://github.com/androidmalin/RengwuxianRxjava.git >$ cd RengwuxianRxjava/ >$ gradle clean --stacktrace(./gradlew ...
Android RxJava： 这是一份全面的 操作符 使用汇总 ，安卓开发基础面试题
m0_69439527的博客
04-12 307
近两年“程序员职业发展”话题，受到越来越多关注，做技术还是转管理？如何保持竞争力？是否要转换新的技术栈？ 每个工作三五年的程序员，都正面临着类似的焦虑。 工作三五年，不能像刚入职场凭着一股子冲劲和能吃苦耐劳的精神赢得升职加薪，而转型管理，是很多技术人员的梦想。 那么，技术骨干朝着管理人才前进的过程中，应该如何培养其管理能力呢? compile ‘io.reactivex.rxjava2:rxjava:2.0.7’ // 注：RxJava2 与 RxJava1 不能共存，即依赖不能同时存在 } 3.1 创建.
安卓中Rxjava
DC1031的博客
07-19 322
RxJava异步 *RxJava 在 GitHub 主页上的自我介绍是 “a library for composing asynchronous and event-based programs using observable sequences for the Java VM”（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）。这就是 RxJava ，概括得非常精...
安卓中使用rxjava
qq_31101655的博客
02-05 290
添加依赖 compile 'io.reactivex:rxjava:2.1.6' compile 'io.reactivex:rxandroid:2.0.1' 简介: 响应式编程是一种面向数据流和变化传播的编程范式。通过Rx框架我们可以很好地使用该范式。 以下为官网对该框架的解释： ReactiveX is a library for composing asynchronous
《给 Android 开发者的 RxJava 详解》笔记
linxi7的博客
10-24 544
这篇文章是看扔物线的《给 Android 开发者的 RxJava 详解》的笔记，在此仅仅做一个笔记，以便日后查用。RxJava的优势 异步（RxJava本质上是一个实现异步操作的库） 简洁（随着程序逻辑变得越来越复杂，它依然能够保持简洁） API 介绍和原理简析RxJava的观察者模式 RxJava 有四个基本概念：Observable (可观察者，即被观察者)、 Observer (观察者)、
RxJava在Android移动端开发中的实战应用之一
门心叼龙的专栏
05-01 7847
文章目录1.时间段选择器，把一天24小时，按照每半个小时作为一个时间段进行分割，共生成48个时间段字符串集合进行返回思路如下：实现步骤：知识点：代码实现：2.地图加载完毕且定位成功之后，显示当前定位点实现步骤：1.创建一个地图加载的发射器2.创建一个地图定位的发射器3.开启地图加载监听，加载成功发射事件4.开启地图定位监听，定位成功发射事件5. 对地图加载发射器和地图定位发射器的事件进行打包合并处...
Rxjava使用手册
sometime here
05-25 205
创建Observables https://github.com/ReactiveX/RxJava/wiki/Creating-Observables#create 1：Observable.fromAction使用效果： Observable<Integer> observable = Observable.fromAction( () ->...
Rxjava使用，没有理论只有实战
parade岁月的博客
06-02 307
线程切换->subscribeOn和observeOn Observable.just(1,2,3,4) .doOnNext { println("parade订阅observeOn${Thread.currentThread().name}") //当subscribeOn在Schedulers.io()时 打印parade订阅observeOnRxCachedThreadScheduler-1 //当subscribeOn在Androi..
RxJava 实例
xiaowang_lj的博客
10-20 613
三种方式：Observable.create、Observable.just、Observable.fromArray@Override}});}使用observer或者subscriber@Override}@Override}@Override}@Override}};特别注意：2种方法的区别，即Subscriber 抽象类与Observer 接口的区别。
RxJava在Android移动端开发中的实战应用之二
门心叼龙的专栏
05-01 6817
###1.实现简单的网络请求 Observable .create(new ObservableOnSubscribe<Response>() { @Override public void subscribe(@NonNull ObservableEmitter<Response> e) throws Exception {...
Android RxJava
因为热爱,所以专注
09-14 103
Android Retrofit与RxJava网络请求实战教程
"这篇文章主要探讨了在Android平台上如何结合Retrofit和RxJava进行网络请求，提供了相关库的导入以及简单的接口定义示例。" 在Android应用开发中，Retrofit和RxJava是两个非常流行的库，它们能帮助开发者更加便捷、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值