Android
Retrofit2 z RxJava

Retrofit2 z RxJava

Najpierw dodaj odpowiednie zależności do pliku 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'
    ....
}

Następnie utwórz model, który chcesz otrzymać:

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

Utwórz interfejs zawierający metody wymiany danych ze zdalnym serwerem:

public interface ApiServerRequests {

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

Następnie utwórz instancję Retrofit :

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

Następnie, w dowolnym miejscu kodu, wywołaj metodę:

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

Zmodernizuj za pomocą RxJava, aby pobierać dane asynchronicznie

Z repozytorium RxJava GitHub , RxJava to implementacja Reactive Extensions Java VM: biblioteka do tworzenia programów asynchronicznych i opartych na zdarzeniach przy użyciu obserwowalnych sekwencji. Rozszerza wzorzec obserwatora, aby obsługiwał sekwencje danych / zdarzeń i dodaje operatorów, które pozwalają deklaracyjnie komponować sekwencje, jednocześnie eliminując obawy dotyczące takich rzeczy, jak wątkowanie niskiego poziomu, synchronizacja, bezpieczeństwo wątków i współbieżne struktury danych.

Retrofit jest bezpiecznym typem klienta HTTP dla Androida i Java, dzięki temu programiści mogą znacznie ułatwić wszystkie operacje sieciowe. Jako przykład zamierzamy pobrać JSON i pokazać go w RecyclerView jako listę.

Pierwsze kroki:

Dodaj zależności RxJava, RxAndroid i Retrofit w pliku build.gradle na poziomie aplikacji: 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"

Zdefiniuj ApiClient i ApiInterface do wymiany danych z serwera

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

interfejs publiczny ApiInterface {

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

Zauważ, że getRepos () zwraca Obserable, a nie tylko listę problemów.

Zdefiniuj modele

Pokazano przykład tego. Możesz korzystać z bezpłatnych usług, takich jak JsonSchema2Pojo lub tego.

public class Comment {

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

//Getters and Setters
}

Utwórz instancję modernizacji

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

Następnie użyj tego wystąpienia, aby pobrać dane z serwera

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

Teraz udało Ci się pobrać dane z serwera za pomocą Retrofit i RxJava.

Przykład zagnieżdżonych żądań: wiele żądań, łącz wyniki

Załóżmy, że mamy interfejs API, który pozwala nam uzyskać metadane obiektu w jednym żądaniu ( getAllPets ) i innym żądaniu, które mają pełne dane pojedynczego zasobu ( getSinglePet ). Jak możemy wysłać zapytanie do nich wszystkich w jednym łańcuchu?

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

}