Android
Retrofit2 met RxJava

Retrofit2 met RxJava

Voeg eerst relevante afhankelijkheden toe aan het bestand build.gradle.

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'
    ....
}

Maak vervolgens het model dat u wilt ontvangen:

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

Maak een interface met methoden die worden gebruikt om gegevens met een externe server uit te wisselen:

public interface ApiServerRequests {

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

Maak vervolgens een Retrofit instantie:

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

Roep vervolgens, overal in de code, de methode aan:

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 met RxJava om gegevens asynchroon op te halen

Uit de GitHub-repo van RxJava is RxJava een Java VM-implementatie van Reactive Extensions: een bibliotheek voor het samenstellen van asynchrone en op gebeurtenissen gebaseerde programma's met behulp van waarneembare sequenties. Het breidt het waarnemerspatroon uit om reeksen gegevens / gebeurtenissen te ondersteunen en voegt operatoren toe waarmee u reeksen samen declaratief kunt samenstellen, terwijl zorgen over zaken als low-level threading, synchronisatie, thread-safety en gelijktijdige datastructuren worden weggenomen.

Retrofit is een typeveilige HTTP-client voor Android en Java, waarmee ontwikkelaars alle netwerkdingen veel eenvoudiger kunnen maken. Als voorbeeld gaan we wat JSON downloaden en als een lijst in RecyclerView weergeven.

Ermee beginnen:

Voeg afhankelijkheden RxJava, RxAndroid en Retrofit toe in het build.gradle-bestand op app-niveau: 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"

Definieer ApiClient en ApiInterface om gegevens van de server uit te wisselen

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

openbare interface ApiInterface {

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

Merk op dat getRepos () een Observable retourneert en niet alleen een lijst met problemen.

Definieer de modellen

Een voorbeeld hiervan wordt getoond. U kunt gratis services zoals JsonSchema2Pojo of dit gebruiken.

public class Comment {

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

//Getters and Setters
}

Retrofit-instantie maken

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

Gebruik vervolgens dit exemplaar om gegevens van de server op te halen

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

Nu hebt u met succes gegevens van een server opgehaald met Retrofit en RxJava.

Voorbeeld van geneste aanvragen: meerdere aanvragen, resultaten combineren

Stel dat we een API hebben waarmee we getAllPets in één verzoek ( getAllPets ) kunnen krijgen, en een ander verzoek met volledige gegevens van één bron ( getSinglePet ). Hoe kunnen we ze allemaal in één keten opvragen?

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

}