使用RxJava和Okhttp [英] Using RxJava and Okhttp

问题描述

我想在另一个线程（如IO线程）中使用okhttp请求一个url并在Android主线程中获取 Response 但我不知道如何创建一个 Observable 。

解决方案

首先添加 RxAndroid 到您的依赖项，然后像这样创建 Observable ：

 订阅订阅= Observable.create（新的Observable.OnSubscribe< Response>（）{
 OkHttpClient client = new OkHttpClient（）; 
 @Override 
 public void call（Subscriber< ;？super Response> subscriber）{
 try {
 Response response = client.newCall（new request.Builder（）。url（your url）。build（））。execute（）; 
 if（response.isSuccessful（））{
 if（！subscriber.isUnsubscribed（））{
 subscriber.onNext（response）; 
} 
 subscriber.onCo mpleted（）; 
} else if（！response.isSuccessful（）&&！subscriber.isUnsubscribed（））{
 subscriber.onError（new Exception（error））; 
} 
} catch（IOException e）{
 if（！subscriber.isUnsubscribed（））{
 subscriber.onError（e）; 
} 
} 
} 
}）
 .subscribeOn（Schedulers.io（））
 .observeOn（AndroidSchedulers.mainThread（））
 .subscribe（新订阅者<响应>（）{
 @Override 
 public void onCompleted（）{
 
} 
 
 @Override 
 public void onError（Throwable e）{
 
} 
 
 @Override 
 public void onNext（响应响应）{
 
} 
}）; 
  

它会在另一个线程（io线程）中请求你的url并在android主线程上观察它。 / p>

最后当你离开屏幕时，使用 subsribtion.unsubscribe（）以避免内存泄漏。

当你使用 Observable.create 时，你应该编写很多样板代码，你也必须自己处理订阅。更好的选择是使用推迟。
形成文档：

在观察者订阅之前不要创建Observable，并为每个创建
a新的Observable观察者

Defer运算符等待观察者订阅它，然后
它生成一个Observable，通常带有一个Observable工厂
函数。它为每个订阅者重新执行此操作，因此尽管每个
订阅者可能认为订阅了相同的Observable，但实际上
每个订阅者都有自己的序列。

因此，MarcinKoziński提及，您只需要这样做：

  final OkHttpClient client = new OkHttpClient（）; 
 Observable.defer（new Func0< Observable< Response>>（）{
 @Override public Observable< Response> call（）{
 try {
 Response response = client。 newCall（new Request.Builder（）。url（your url）。build（））。execute（）; 
 return Observable.just（response）; 
} catch（IOException e）{
返回Observable.error（e）; 
} 
} 
}）; 
  

I want to request to a url using okhttp in another thread (like IO thread) and get Response in the Android main thread, But I don't know how to create an Observable.

解决方案

First add RxAndroid to your dependencies, then create your Observable like this:

 Subscription subscription =   Observable.create(new Observable.OnSubscribe<Response>() {
        OkHttpClient client = new OkHttpClient();
          @Override
          public void call(Subscriber<? super Response> subscriber) {
            try {
              Response response = client.newCall(new Request.Builder().url("your url").build()).execute();
              if (response.isSuccessful()) {
                  if(!subscriber.isUnsubscribed()){
                     subscriber.onNext(response);
                  }
                  subscriber.onCompleted();
              } else if (!response.isSuccessful() && !subscriber.isUnsubscribed()) {
                  subscriber.onError(new Exception("error"));
                }
            } catch (IOException e) {
              if (!subscriber.isUnsubscribed()) {
                  subscriber.onError(e);
              }
            }
          }
        })
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Subscriber<Response>() {
              @Override
              public void onCompleted() {

              }

              @Override
              public void onError(Throwable e) {

              }

              @Override
              public void onNext(Response response) {

              }
            });

It will request your url in another thread (io thread) and observe it on android main thread.

And finally when you leave the screen use subsribtion.unsubscribe() to avoid memory leak.

When you use Observable.create, you should write a lot of boilerplate code, also you must handle subscription by your own. A better alternative is to use defer. Form the doc:

do not create the Observable until the observer subscribes, and create a fresh Observable for each observer

The Defer operator waits until an observer subscribes to it, and then it generates an Observable, typically with an Observable factory function. It does this afresh for each subscriber, so although each subscriber may think it is subscribing to the same Observable, in fact each subscriber gets its own individual sequence.

So as Marcin Koziński mentioned, you just need to do this:

final OkHttpClient client = new OkHttpClient();
Observable.defer(new Func0<Observable<Response>>() {
    @Override public Observable<Response> call() {
        try {
            Response response = client.newCall(new Request.Builder().url("your url").build()).execute();
            return Observable.just(response);
        } catch (IOException e) {
            return Observable.error(e);
        }
    }
});

这篇关于使用RxJava和Okhttp的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！