Android
Retrofit2 con RxJava

Retrofit2 con RxJava

Innanzitutto, aggiungi dipendenze rilevanti nel file 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'
    ....
}

Quindi crea il modello che desideri ricevere:

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

Creare un'interfaccia contenente i metodi utilizzati per lo scambio di dati con il server remoto:

public interface ApiServerRequests {

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

Quindi creare un'istanza di 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;
}

Quindi, ovunque dal codice, chiama il metodo:

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 con RxJava per recuperare i dati in modo asincrono

Dal repository GitHub di RxJava, RxJava è un'implementazione Java VM di Reactive Extensions: una libreria per la composizione di programmi asincroni e basati su eventi utilizzando sequenze osservabili. Estende il pattern dell'osservatore per supportare sequenze di dati / eventi e aggiunge operatori che consentono di comporre sequenze insieme in modo dichiarativo mentre estrapolano le preoccupazioni su argomenti come threading di basso livello, sincronizzazione, sicurezza dei thread e strutture di dati concorrenti.

Retrofit è un client HTTP sicuro per tipo per Android e Java, utilizzando questo, gli sviluppatori possono rendere tutte le cose della rete molto più facili. Ad esempio, stiamo per scaricare alcuni JSON e mostrarli in RecyclerView come elenco.

Iniziare:

Aggiungi le dipendenze RxJava, RxAndroid e Retrofit nel tuo file build.gradle a livello di app: 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"

Definisci ApiClient e ApiInterface per scambiare dati dal server

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

interfaccia pubblica ApiInterface {

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

Nota che getRepos () restituisce un Osservabile e non solo un elenco di problemi.

Definire i modelli

Un esempio per questo è mostrato. Puoi utilizzare servizi gratuiti come JsonSchema2Pojo o questo.

public class Comment {

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

//Getters and Setters
}

Crea istanza di Retrofit

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

Quindi, utilizzare questa istanza per recuperare i dati dal server

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

Ora, hai recuperato con successo i dati da un server usando Retrofit e RxJava.

Esempio di richieste nidificate: più richieste, combinazione di risultati

Supponiamo di avere un'API che ci consente di ottenere i metadati dell'oggetto in una singola richiesta ( getAllPets ) e altre richieste che hanno dati completi di una singola risorsa ( getSinglePet ). Come possiamo interrogarli tutti in una singola catena?

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

}