Utilizzo di RxJava e Okhttp

Question

Desidero richiedere un URL utilizzando okhttp in un altro thread (come il thread IO) e ottenere Response nella thread principale di Android, ma non so come creare un Observable.

Answer 1

Prima aggiungere RxAndroid alle vostre dipendenze, quindi creare il Observable in questo modo:

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

       } 
      }); 

Sarà richiedere l'URL in un altro thread (io filo) ed osservare sul thread principale Android.

Infine, quando si esce dallo schermo, utilizzare subsribtion.unsubscribe() per evitare perdite di memoria.

Quando si utilizza Observable.create, si dovrebbe scrivere molto codice di codice, inoltre è necessario gestire l'abbonamento da soli. Un'alternativa migliore è usare defer. Formare il doc:

non creano osservabile fino sottoscritti osservatori, e creare una nuova osservabili per ogni osservatore

I Posticipa attese operatore fino a quando un osservatore sottoscrive, e poi genera una funzione Osservabile, tipicamente con una fabbrica osservabile . Lo fa di nuovo per ogni abbonato, quindi anche se ogni sottoscrittore di può pensare di iscriversi allo stesso Osservabile, in effetti ogni iscritto ottiene la propria sequenza individuale.

Così come Marcin Koziński detto, non vi resta che fare questo:

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); 
     } 
    } 
}); 

Answer 2

E 'più facile e sicuro da usare Observable.defer() invece di Observable.create():

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); 
     } 
    } 
}); 

Che disiscrizione modo e contropressione sono gestite per te. Ecco a great post by Dan Lew su create() e defer().

Se si desidera percorrere il percorso Observable.create(), dovrebbe apparire più simile a this library con chiamate isUnsubscribed() sparse ovunque. E credo che questo ancora non gestisca la contropressione.

Answer 3

Mi rendo conto che questo post è un po 'vecchio, ma c'è un modo nuovo e più conveniente di fare questo ora

Observable.fromCallable { 
     client.newCall(Request.Builder().url("your url").build()).execute() 
    } 

Maggiori informazioni: https://artemzin.com/blog/rxjava-defer-execution-of-function-via-fromcallable/