Android
Retrofit2 z RxJava
Szukaj…
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;
}
}
}