Android
Retrofit2 mit RxJava

Retrofit2 mit RxJava

Fügen Sie zunächst relevante Abhängigkeiten in die Datei build.gradle ein.

dependencies {
    ....
    compile 'com.squareup.retrofit2:retrofit:2.3.0'
    compile 'com.squareup.retrofit2:converter-gson:2.3.0'
    compile 'com.squareup.retrofit2:adapter-rxjava:2.3.0'
    ....
}

Dann erstellen Sie das Modell, das Sie erhalten möchten:

public class Server {
    public String name;
    public String url;
    public String apikey;
    public List<Site> siteList;
}

Erstellen Sie eine Schnittstelle, die Methoden für den Datenaustausch mit Remote-Server enthält:

public interface ApiServerRequests {

    @GET("api/get-servers")
    public Observable<List<Server>> getServers();
}

Dann erstellen Sie eine Retrofit Instanz:

public ApiRequests DeviceAPIHelper ()
{
    Gson gson = new GsonBuilder().create();

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("http://example.com/")
            .addConverterFactory(GsonConverterFactory.create(gson))
            .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
            .build();

    api = retrofit.create(ApiServerRequests.class);
    return api;
}

Rufen Sie dann an beliebiger Stelle des Codes die Methode auf:

apiRequests.getServers()
   .subscribeOn(Schedulers.io()) // the observable is emitted on io thread
   .observerOn(AndroidSchedulers.mainThread()) // Methods needed to handle request in background thread
   .subscribe(new Subscriber<List<Server>>() {
       @Override
       public void onCompleted() {
                    
       }

       @Override
       public void onError(Throwable e) {

       }

       @Override
       public void onNext(List<Server> servers) {
           //A list of servers is fetched successfully
       }
   });

Retrofit mit RxJava, um Daten asynchron abzurufen

RxJava ist eine Java VM-Implementierung von Reactive Extensions aus dem GitHub-Repo von RxJava : Eine Bibliothek zum Erstellen asynchroner und ereignisbasierter Programme unter Verwendung beobachtbarer Sequenzen. Es erweitert das Observer-Muster, um Sequenzen von Daten / Ereignissen zu unterstützen, und fügt Operatoren hinzu, mit denen Sie deklarativ Sequenzen zusammenstellen können, während Sie Bedenken über Dinge wie Low-Level-Threading, Synchronisation, Thread-Sicherheit und gleichzeitige Datenstrukturen abschaffen.

Retrofit ist ein typsicherer HTTP-Client für Android und Java. Damit können Entwickler das gesamte Netzwerk wesentlich einfacher machen. Als Beispiel werden wir JSON herunterladen und in RecyclerView als Liste anzeigen.

Fertig machen:

Fügen Sie der Build.gradle-Datei auf App-Ebene RxJava-, RxAndroid- und Retrofit-Abhängigkeiten hinzu: compile "io.reactivex:rxjava:1.1.6"
compile "io.reactivex:rxandroid:1.2.1"
compile "com.squareup.retrofit2:adapter-rxjava:2.0.2"
compile "com.google.code.gson:gson:2.6.2"
compile "com.squareup.retrofit2:retrofit:2.0.2"
compile "com.squareup.retrofit2:converter-gson:2.0.2"

Definieren Sie ApiClient und ApiInterface, um Daten vom Server auszutauschen

public class ApiClient {

private static Retrofit retrofitInstance = null;
private static final String BASE_URL = "https://api.github.com/";

public static Retrofit getInstance() {
    if (retrofitInstance == null) {
        retrofitInstance = new Retrofit.Builder()
                .baseUrl(BASE_URL)
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .addConverterFactory(GsonConverterFactory.create())
                .build();
    }
    return retrofitInstance;
}

public static <T> T createRetrofitService(final Class<T> clazz, final String endPoint) {
    final Retrofit restAdapter = new Retrofit.Builder()
            .baseUrl(endPoint)
            .build();

    return restAdapter.create(clazz);
}

public static String getBaseUrl() {
    return BASE_URL;
}}

öffentliche Schnittstelle ApiInterface {

@GET("repos/{org}/{repo}/issues")
Observable<List<Issue>> getIssues(@Path("org") String organisation,
                                  @Path("repo") String repositoryName,
                                  @Query("page") int pageNumber);}

Beachten Sie, dass getRepos () ein Observable zurückgibt und nicht nur eine Liste von Problemen.

Definieren Sie die Modelle

Ein Beispiel dafür wird gezeigt. Sie können kostenlose Dienste wie JsonSchema2Pojo oder dieses nutzen.

public class Comment {

@SerializedName("url")
@Expose
private String url;
@SerializedName("html_url")
@Expose
private String htmlUrl;

//Getters and Setters
}

Retrofit-Instanz erstellen

ApiInterface apiService = ApiClient.getInstance().create(ApiInterface.class);

Verwenden Sie dann diese Instanz, um Daten vom Server abzurufen

Observable<List<Issue>> issueObservable = apiService.getIssues(org, repo,                 pageNumber);
    issueObservable.subscribeOn(Schedulers.newThread())
            .observeOn(AndroidSchedulers.mainThread())
            .map(issues -> issues)    //get issues and map to issues list
            .subscribe(new Subscriber<List<Issue>>() {
                @Override
                public void onCompleted() {
                    Log.i(TAG, "onCompleted: COMPLETED!");
                }

                @Override
                public void onError(Throwable e) {
                    Log.e(TAG, "onError: ", e);
                }

                @Override
                public void onNext(List<Issue> issues) {
                    recyclerView.setAdapter(new IssueAdapter(MainActivity.this, issues, apiService));
                }
            });

Jetzt haben Sie Daten erfolgreich mit Retrofit und RxJava von einem Server abgerufen.

Beispiel für verschachtelte Anforderungen: Mehrere Anforderungen, kombinieren Sie die Ergebnisse

Angenommen, wir verfügen über eine API, mit der wir Objekt-Metadaten in einer einzelnen Anforderung ( getAllPets ) getAllPets , und andere Anforderungen, die vollständige Daten einer einzelnen Ressource ( getSinglePet ) enthalten. Wie können wir alle in einer einzigen Kette abfragen?

public class PetsFetcher {


static class PetRepository {
    List<Integer> ids;
}

static class Pet {
    int id;
    String name;
    int weight;
    int height;
}

interface PetApi {

    @GET("pets") Observable<PetRepository> getAllPets();

    @GET("pet/{id}") Observable<Pet> getSinglePet(@Path("id") int id);

}

PetApi petApi;

Disposable petsDisposable;

public void requestAllPets() {

    petApi.getAllPets()
            .doOnSubscribe(new Consumer<Disposable>() {
                @Override public void accept(Disposable disposable) throws Exception {
                    petsDisposable = disposable;
                }
            })
            .flatMap(new Function<PetRepository, ObservableSource<Integer>>() {
                @Override
                public ObservableSource<Integer> apply(PetRepository petRepository) throws Exception {
                    List<Integer> petIds = petRepository.ids;
                    return Observable.fromIterable(petIds);
                }
            })
            .flatMap(new Function<Integer, ObservableSource<Pet>>() {
                @Override public ObservableSource<Pet> apply(Integer id) throws Exception {
                    return petApi.getSinglePet(id);
                }
            })
            .toList()
            .toObservable()
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Consumer<List<Pet>>() {
                @Override public void accept(List<Pet> pets) throws Exception {
                    //use your pets here
                }
            }, new Consumer<Throwable>() {
                @Override public void accept(Throwable throwable) throws Exception {
                    //show user something goes wrong
                }
            });

}

void cancelRequests(){
    if (petsDisposable!=null){
        petsDisposable.dispose();
        petsDisposable = null;
    }
}

}