Erste Schritte mit Retrofit 2 HTTP-Client
German (Deutsch) translation by Federicco Ancie (you can also view the original English article)
Was ist Nachrüstung?
Retrofit ist ein typsicherer HTTP-Client für Android und Java. Retrofit macht es einfach, sich mit einem REST-Webservice zu verbinden, indem die API in Java-Schnittstellen übersetzt wird. In diesem Tutorial zeige ich Ihnen, wie Sie eine der beliebtesten und am häufigsten empfohlenen HTTP-Bibliotheken für Android verwenden.
Diese leistungsstarke Bibliothek macht es einfach, JSON- oder XML-Daten zu konsumieren, die dann in Plain Old Java Objects (POJOs) geparst werden. GET
-, POST
-, PUT
-, PATCH
- und DELETE
-Anforderungen können alle ausgeführt werden.
Wie die meisten Open-Source-Software wurde Retrofit auf einigen anderen leistungsstarken Bibliotheken und Tools aufgebaut. Hinter den Kulissen verwendet Retrofit OkHttp (vom gleichen Entwickler), um Netzwerkanfragen zu bearbeiten. Außerdem verfügt Retrofit über keinen integrierten JSON-Konverter zum Parsen von JSON- in Java-Objekte. Stattdessen wird die Unterstützung für die folgenden JSON-Konverterbibliotheken bereitgestellt, um dies zu handhaben:
- Gson:
com.squareup.retrofit:converter-gson
- Jackson:
com.squareup.retrofit:converter-jackson
- Moshi:
com.squareup.retrofit:converter-moshi
- Protobuf:
com.squareup.retrofit2:converter-protobuf
- Wire:
com.squareup.retrofit2:converter-wire
Und für XML unterstützt Retrofit:
- Einfaches Framework:
com.squareup.retrofit2:converter-simpleframework
Warum also Retrofit verwenden?
Die Entwicklung einer eigenen typsicheren HTTP-Bibliothek für die Schnittstelle zu einer REST-API kann eine echte Herausforderung sein: Sie müssen viele Funktionen wie Herstellen von Verbindungen, Caching, Wiederholen fehlgeschlagener Anforderungen, Threading, Antwortparsing, Fehlerbehandlung und mehr bewältigen. Retrofit hingegen ist sehr gut geplant, dokumentiert und getestet – eine kampferprobte Bibliothek, die Ihnen viel kostbare Zeit und Kopfschmerzen erspart.
In diesem Tutorial erkläre ich, wie man Retrofit 2 verwendet, um Netzwerkanfragen zu bearbeiten, indem ich eine einfache App erstelle, um aktuelle Antworten von der Stack Exchange API abzufragen. Wir führen GET
-Anfragen durch, indem wir einen Endpunkt angeben – /answers
, angehängt an die Basis-URL https://api.stackexchange.com/2.2/ –, dann die Ergebnisse abrufen und in einer Recycler-Ansicht anzeigen. Ich zeige Ihnen auch, wie Sie dies mit RxJava tun, um den Status- und Datenfluss einfach zu verwalten.
1. Erstellen Sie ein Android Studio-Projekt
Starten Sie Android Studio und erstellen Sie ein neues Projekt mit einer leeren Aktivität namens MainActivity
.



2. Abhängigkeiten erklären
Deklarieren Sie nach dem Erstellen eines neuen Projekts die folgenden Abhängigkeiten in Ihrer build.gradle
. Zu den Abhängigkeiten gehören eine Recycler-Ansicht, die Retrofit-Bibliothek sowie die Gson-Bibliothek von Google zur Konvertierung von JSON in POJO (Plain Old Java Objects) sowie die Gson-Integration von Retrofit.
// Retrofit compile 'com.squareup.retrofit2:retrofit:2.1.0' // JSON Parsing compile 'com.google.code.gson:gson:2.6.1' compile 'com.squareup.retrofit2:converter-gson:2.1.0' // recyclerview compile 'com.android.support:recyclerview-v7:25.0.1'
Vergessen Sie nicht, das Projekt zu synchronisieren, um diese Bibliotheken herunterzuladen.
3. Internetberechtigung hinzufügen
Um Netzwerkvorgänge durchzuführen, müssen wir die INTERNET
-Berechtigung in das Anwendungsmanifest aufnehmen: AndroidManifest.xml.
<?xml version="1.0" encoding="utf-8"?> <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="com.chikeandroid.retrofittutorial"> <uses-permission android:name="android.permission.INTERNET" /> <application android:allowBackup="true" android:icon="@mipmap/ic_launcher" android:label="@string/app_name" android:supportsRtl="true" android:theme="@style/AppTheme"> <activity android:name=".MainActivity"> <intent-filter> <action android:name="android.intent.action.MAIN"/> <category android:name="android.intent.category.LAUNCHER"/> </intent-filter> </activity> </application> </manifest>
4. Modelle automatisch generieren
Wir werden unsere Modelle automatisch aus unseren JSON-Antwortdaten erstellen, indem wir ein sehr nützliches Tool nutzen: jsonschema2pojo.
Holen Sie sich die JSON-Beispieldaten
Kopieren Sie https://api.stackexchange.com/2.2/answers?order=desc&sort=activity&site=stackoverflow und fügen Sie sie in die Adressleiste Ihres Browsers ein (oder Sie können Postman verwenden, wenn Sie mit diesem Tool vertraut sind). Drücken Sie dann die Eingabetaste – dies führt eine GET-Anfrage auf dem angegebenen Endpunkt aus. Als Antwort sehen Sie ein Array von JSON-Objekten. Der Screenshot unten ist die JSON-Antwort mit Postman.



{ "items": [ { "owner": { "reputation": 1, "user_id": 6540831, "user_type": "registered", "profile_image": "https://www.gravatar.com/avatar/6a468ce8a8ff42c17923a6009ab77723?s=128&d=identicon&r=PG&f=1", "display_name": "bobolafrite", "link": "http://stackoverflow.com/users/6540831/bobolafrite" }, "is_accepted": false, "score": 0, "last_activity_date": 1480862271, "creation_date": 1480862271, "answer_id": 40959732, "question_id": 35931342 }, { "owner": { "reputation": 629, "user_id": 3054722, "user_type": "registered", "profile_image": "https://www.gravatar.com/avatar/0cf65651ae9a3ba2858ef0d0a7dbf900?s=128&d=identicon&r=PG&f=1", "display_name": "jeremy-denis", "link": "http://stackoverflow.com/users/3054722/jeremy-denis" }, "is_accepted": false, "score": 0, "last_activity_date": 1480862260, "creation_date": 1480862260, "answer_id": 40959731, "question_id": 40959661 }, ... ], "has_more": true, "backoff": 10, "quota_max": 300, "quota_remaining": 241 }
Kopieren Sie diese JSON-Antwort entweder von Ihrem Browser oder Postman.
Ordnen Sie die JSON-Daten Java zu
Rufen Sie nun jsonschema2pojo auf und fügen Sie die JSON-Antwort in das Eingabefeld ein.
Wählen Sie einen Quelltyp von JSON, einen Anmerkungsstil von Gson und deaktivieren Sie das Kontrollkästchen Zusätzliche Eigenschaften zulassen.



Klicken Sie dann auf die Schaltfläche Vorschau, um die Java-Objekte zu generieren.



Sie fragen sich vielleicht, was die Annotationen @SerializedName
und @Expose
in diesem generierten Code bewirken. Keine Sorge, ich erkläre alles!
Die Annotation @SerializedName
wird benötigt, damit Gson die JSON-Schlüssel unseren Feldern zuordnet. In Übereinstimmung mit der camelCase-Namenskonvention von Java für Klassenmembereigenschaften wird davon abgeraten, Unterstriche zum Trennen von Wörtern in einer Variablen zu verwenden. @SerializedName
hilft bei der Übersetzung zwischen den beiden.
@SerializedName("quota_remaining") @Expose private Integer quotaRemaining;
Im obigen Beispiel teilen wir Gson mit, dass unser JSON-Schlüssel quota_remaining
dem Java-Feld quotaRemaining
zugeordnet werden soll. Wenn diese beiden Werte gleich wären, d. h. wenn unser JSON-Schlüssel quotaRemaining
genau wie das Java-Feld wäre, dann wäre die Annotation @SerializedName
für das Feld nicht erforderlich, da Gson sie automatisch zuordnen würde.
Die Annotation @Expose
gibt an, dass dieser Member für die JSON-Serialisierung oder -Deserialisierung verfügbar gemacht werden soll.
Datenmodelle in Android Studio importieren
Kehren wir nun zu Android Studio zurück. Erstellen Sie ein neues Unterpaket innerhalb des Hauptpakets und nennen Sie es data. Erstellen Sie innerhalb des neu erstellten Datenpakets ein weiteres Paket und nennen Sie es model. Erstellen Sie im Modellpaket eine neue Java-Klasse und nennen Sie sie Owner
. Kopieren Sie nun die von jsonschema2pojo generierte Owner
-Klasse und fügen Sie sie in die von Ihnen erstellte Owner
-Klasse ein.
import com.google.gson.annotations.Expose; import com.google.gson.annotations.SerializedName; public class Owner { @SerializedName("reputation") @Expose private Integer reputation; @SerializedName("user_id") @Expose private Integer userId; @SerializedName("user_type") @Expose private String userType; @SerializedName("profile_image") @Expose private String profileImage; @SerializedName("display_name") @Expose private String displayName; @SerializedName("link") @Expose private String link; @SerializedName("accept_rate") @Expose private Integer acceptRate; public Integer getReputation() { return reputation; } public void setReputation(Integer reputation) { this.reputation = reputation; } public Integer getUserId() { return userId; } public void setUserId(Integer userId) { this.userId = userId; } public String getUserType() { return userType; } public void setUserType(String userType) { this.userType = userType; } public String getProfileImage() { return profileImage; } public void setProfileImage(String profileImage) { this.profileImage = profileImage; } public String getDisplayName() { return displayName; } public void setDisplayName(String displayName) { this.displayName = displayName; } public String getLink() { return link; } public void setLink(String link) { this.link = link; } public Integer getAcceptRate() { return acceptRate; } public void setAcceptRate(Integer acceptRate) { this.acceptRate = acceptRate; } }
Machen Sie dasselbe für eine neue Item
-Klasse, die aus jsonschema2pojo kopiert wurde.
import com.google.gson.annotations.Expose; import com.google.gson.annotations.SerializedName; public class Item { @SerializedName("owner") @Expose private Owner owner; @SerializedName("is_accepted") @Expose private Boolean isAccepted; @SerializedName("score") @Expose private Integer score; @SerializedName("last_activity_date") @Expose private Integer lastActivityDate; @SerializedName("creation_date") @Expose private Integer creationDate; @SerializedName("answer_id") @Expose private Integer answerId; @SerializedName("question_id") @Expose private Integer questionId; @SerializedName("last_edit_date") @Expose private Integer lastEditDate; public Owner getOwner() { return owner; } public void setOwner(Owner owner) { this.owner = owner; } public Boolean getIsAccepted() { return isAccepted; } public void setIsAccepted(Boolean isAccepted) { this.isAccepted = isAccepted; } public Integer getScore() { return score; } public void setScore(Integer score) { this.score = score; } public Integer getLastActivityDate() { return lastActivityDate; } public void setLastActivityDate(Integer lastActivityDate) { this.lastActivityDate = lastActivityDate; } public Integer getCreationDate() { return creationDate; } public void setCreationDate(Integer creationDate) { this.creationDate = creationDate; } public Integer getAnswerId() { return answerId; } public void setAnswerId(Integer answerId) { this.answerId = answerId; } public Integer getQuestionId() { return questionId; } public void setQuestionId(Integer questionId) { this.questionId = questionId; } public Integer getLastEditDate() { return lastEditDate; } public void setLastEditDate(Integer lastEditDate) { this.lastEditDate = lastEditDate; } }
Erstellen Sie schließlich eine Klasse namens SOAnswersResponse
für die zurückgegebenen StackOverflow-Antworten. Den Code für diese Klasse finden Sie in jsonschema2pojo als Example
. Stellen Sie sicher, dass Sie den Klassennamen überall auf SOAnswersResponse
aktualisieren.
import com.google.gson.annotations.Expose; import com.google.gson.annotations.SerializedName; import java.util.List; public class SOAnswersResponse { @SerializedName("items") @Expose private List<Item> items = null; @SerializedName("has_more") @Expose private Boolean hasMore; @SerializedName("backoff") @Expose private Integer backoff; @SerializedName("quota_max") @Expose private Integer quotaMax; @SerializedName("quota_remaining") @Expose private Integer quotaRemaining; public List<Item> getItems() { return items; } public void setItems(List<Item> items) { this.items = items; } public Boolean getHasMore() { return hasMore; } public void setHasMore(Boolean hasMore) { this.hasMore = hasMore; } public Integer getBackoff() { return backoff; } public void setBackoff(Integer backoff) { this.backoff = backoff; } public Integer getQuotaMax() { return quotaMax; } public void setQuotaMax(Integer quotaMax) { this.quotaMax = quotaMax; } public Integer getQuotaRemaining() { return quotaRemaining; } public void setQuotaRemaining(Integer quotaRemaining) { this.quotaRemaining = quotaRemaining; } }
5. Erstellen der Retrofit-Instanz
Um mit Retrofit Netzwerkanforderungen an eine REST-API zu senden, müssen wir eine Instanz mit der Retrofit.Builder
-Klasse erstellen und sie mit einer Basis-URL konfigurieren.
Erstellen Sie ein neues Unterpaketpaket innerhalb des data
-Pakets und nennen Sie es remote
. Erstellen Sie nun in remote
eine Java-Klasse und nennen Sie sie RetrofitClient
. Diese Klasse erstellt ein Singleton von Retrofit. Retrofit benötigt eine Basis-URL, um seine Instanz zu erstellen, daher übergeben wir beim Aufrufen von RetrofitClient.getClient(String baseUrl)
eine URL. Diese URL wird dann verwendet, um die Instanz in Zeile 13 zu erstellen. Außerdem geben wir in Zeile 14 den von uns benötigten JSON-Konverter (Gson) an.
import retrofit2.Retrofit; import retrofit2.converter.gson.GsonConverterFactory; public class RetrofitClient { private static Retrofit retrofit = null; public static Retrofit getClient(String baseUrl) { if (retrofit==null) { retrofit = new Retrofit.Builder() .baseUrl(baseUrl) .addConverterFactory(GsonConverterFactory.create()) .build(); } return retrofit; } }
6. Erstellen der API-Schnittstelle
Erstellen Sie innerhalb des Remote-Pakets eine Schnittstelle und nennen Sie sie SOService
. Diese Schnittstelle enthält Methoden, die wir verwenden werden, um HTTP-Anforderungen wie GET
, POST
, PUT
, PATCH
und DELETE
auszuführen. Für dieses Tutorial werden wir eine GET
-Anfrage ausführen.
import com.chikeandroid.retrofittutorial.data.model.SOAnswersResponse; import java.util.List; import retrofit2.Call; import retrofit2.http.GET; public interface SOService { @GET("/answers?order=desc&sort=activity&site=stackoverflow") Call<List<SOAnswersResponse>> getAnswers(); @GET("/answers?order=desc&sort=activity&site=stackoverflow") Call<List<SOAnswersResponse>> getAnswers(@Query("tagged") String tags); }
Die Annotation @GET
definiert explizit die GET
-Anforderung, die ausgeführt wird, sobald die Methode aufgerufen wird. Jede Methode in dieser Schnittstelle muss eine HTTP-Annotation haben, die die Anforderungsmethode und die relative URL bereitstellt. Es stehen fünf integrierte Anmerkungen zur Verfügung: @GET
, @POST,
@PUT
, @DELETE
und @HEAD
.
In der zweiten Methodendefinition haben wir einen Abfrageparameter hinzugefügt, damit wir die Daten vom Server filtern können. Retrofit hat die Annotation @Query("key")
, die verwendet wird, anstatt sie im Endpunkt fest zu codieren. Der Schlüsselwert stellt den Parameternamen in der URL dar. Es wird der URL von Retrofit hinzugefügt. Wenn wir beispielsweise den Wert "android"
als Argument an die Methode getAnswers(String tags)
übergeben, lautet die vollständige URL:
https://api.stackexchange.com/2.2/answers?order=desc&sort=activity&site=stackoverflow&tagged=android
Parameter der Schnittstellenmethoden können folgende Annotationen haben:
@Path | Variablensubstitution für den API-Endpunkt |
@Query | gibt den Abfrageschlüsselnamen mit dem Wert des annotierten Parameters an |
@Body | Nutzlast für den POST-Aufruf |
@Header | spezifiziert den Header mit dem Wert des annotierten Parameters |
7. Erstellen der API-Utilities
Jetzt erstellen Sie eine Dienstprogrammklasse. Wir nennen es ApiUtils
. Diese Klasse hat die Basis-URL als statische Variable und stellt unserer Anwendung über die statische Methode getSOService()
auch die SOService
-Schnittstelle zur Verfügung.
public class ApiUtils { public static final String BASE_URL = "https://api.stackexchange.com/2.2"; public static SOService getSOService() { return RetrofitClient.getClient(BASE_URL).create(SOService.class); } }
8. Anzeige auf einem RecyclerView
Da die Ergebnisse in einer Recycler-Ansicht angezeigt werden, benötigen wir einen Adapter. Der folgende Codeausschnitt zeigt die AnswersAdapter
-Klasse.
public class AnswersAdapter extends RecyclerView.Adapter<AnswersAdapter.ViewHolder> { private List<Item> mItems; private Context mContext; private PostItemListener mItemListener; public class ViewHolder extends RecyclerView.ViewHolder implements View.OnClickListener{ public TextView titleTv; PostItemListener mItemListener; public ViewHolder(View itemView, PostItemListener postItemListener) { super(itemView); titleTv = (TextView) itemView.findViewById(android.R.id.text1); this.mItemListener = postItemListener; itemView.setOnClickListener(this); } @Override public void onClick(View view) { Item item = getItem(getAdapterPosition()); this.mItemListener.onPostClick(item.getAnswerId()); notifyDataSetChanged(); } } public AnswersAdapter(Context context, List<Item> posts, PostItemListener itemListener) { mItems = posts; mContext = context; mItemListener = itemListener; } @Override public AnswersAdapter.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) { Context context = parent.getContext(); LayoutInflater inflater = LayoutInflater.from(context); View postView = inflater.inflate(android.R.layout.simple_list_item_1, parent, false); ViewHolder viewHolder = new ViewHolder(postView, this.mItemListener); return viewHolder; } @Override public void onBindViewHolder(AnswersAdapter.ViewHolder holder, int position) { Item item = mItems.get(position); TextView textView = holder.titleTv; textView.setText(item.getOwner().getDisplayName()); } @Override public int getItemCount() { return mItems.size(); } public void updateAnswers(List<Item> items) { mItems = items; notifyDataSetChanged(); } private Item getItem(int adapterPosition) { return mItems.get(adapterPosition); } public interface PostItemListener { void onPostClick(long id); } }
9. Ausführen der Anfrage
Innerhalb der Methode onCreate()
der MainActivity
initialisieren wir eine Instanz der SOService
-Schnittstelle (Zeile 9), die Recycler-Ansicht und auch den Adapter. Schließlich rufen wir die Methode loadAnswers()
auf.
private AnswersAdapter mAdapter; private RecyclerView mRecyclerView; private SOService mService; @Override protected void onCreate (Bundle savedInstanceState) { super.onCreate( savedInstanceState ); setContentView(R.layout.activity_main ); mService = ApiUtils.getSOService(); mRecyclerView = (RecyclerView) findViewById(R.id.rv_answers); mAdapter = new AnswersAdapter(this, new ArrayList<Item>(0), new AnswersAdapter.PostItemListener() { @Override public void onPostClick(long id) { Toast.makeText(MainActivity.this, "Post id is" + id, Toast.LENGTH_SHORT).show(); } }); RecyclerView.LayoutManager layoutManager = new LinearLayoutManager(this); mRecyclerView.setLayoutManager(layoutManager); mRecyclerView.setAdapter(mAdapter); mRecyclerView.setHasFixedSize(true); RecyclerView.ItemDecoration itemDecoration = new DividerItemDecoration(this, DividerItemDecoration.VERTICAL_LIST); mRecyclerView.addItemDecoration(itemDecoration); loadAnswers(); }
Die Methode loadAnswers()
stellt eine Netzwerkanfrage, indem sie enqueue()
aufruft. Wenn die Antwort zurückkommt, hilft uns Retrofit, die JSON-Antwort auf eine Liste von Java-Objekten zu analysieren. (Dies wird durch die Verwendung von GsonConverter
ermöglicht.)
public void loadAnswers() { mService.getAnswers().enqueue(new Callback<SOAnswersResponse>() { @Override public void onResponse(Call<SOAnswersResponse> call, Response<SOAnswersResponse> response) { if(response.isSuccessful()) { mAdapter.updateAnswers(response.body().getItems()); Log.d("MainActivity", "posts loaded from API"); }else { int statusCode = response.code(); // handle request errors depending on status code } } @Override public void onFailure(Call<SOAnswersResponse> call, Throwable t) { showErrorMessage(); Log.d("MainActivity", "error loading from API"); } }); }
10. enqueue()
verstehen
enqueue()
sendet die Anfrage asynchron und benachrichtigt Ihre App mit einem Rückruf, wenn eine Antwort zurückkommt. Da diese Anforderung asynchron ist, verarbeitet Retrofit sie in einem Hintergrundthread, damit der Haupt-UI-Thread nicht blockiert oder gestört wird.
Um enqueue()
zu verwenden, müssen Sie zwei Callback-Methoden implementieren:
onResponse()
onFailure()
Als Antwort auf eine bestimmte Anforderung wird nur eine dieser Methoden aufgerufen.
-
onResponse()
: wird für eine empfangene HTTP-Antwort aufgerufen. Diese Methode wird für eine Antwort aufgerufen, die auch dann korrekt verarbeitet werden kann, wenn der Server eine Fehlermeldung zurückgibt. Wenn Sie also einen Statuscode von 404 oder 500 erhalten, wird diese Methode trotzdem aufgerufen. Um den Statuscode zu erhalten, damit Sie darauf basierende Situationen handhaben können, können Sie die Methoderesponse.code()
verwenden. Sie können auch die MethodeisSuccessful()
verwenden, um herauszufinden, ob der Statuscode im Bereich von 200 bis 300 liegt und den Erfolg anzeigt. -
onFailure()
: wird aufgerufen, wenn eine Netzwerkausnahme bei der Kommunikation mit dem Server aufgetreten ist oder wenn eine unerwartete Ausnahme bei der Verarbeitung der Anfrage oder der Verarbeitung der Antwort aufgetreten ist.
Um eine synchrone Anfrage auszuführen, können Sie die Methode execute()
verwenden. Beachten Sie, dass synchrone Methoden im Haupt-/UI-Thread jede Benutzeraktion blockieren. Führen Sie also keine synchronen Methoden im Haupt-/UI-Thread von Android aus! Führen Sie sie stattdessen in einem Hintergrundthread aus.
11. Testen der App
Sie können die App jetzt ausführen.
12. RxJava-Integration
Wenn Sie ein Fan von RxJava sind, können Sie Retrofit mit RxJava problemlos implementieren. In Retrofit 1 war es standardmäßig integriert, aber in Retrofit 2 müssen Sie einige zusätzliche Abhängigkeiten einbeziehen. Retrofit wird mit einem Standardadapter zum Call
von Anrufinstanzen geliefert. Sie können also den Ausführungsmechanismus von Retrofit so ändern, dass er RxJava enthält, indem Sie den RxJava CallAdapter
einbinden.
Schritt 1
Fügen Sie die Abhängigkeiten hinzu.
compile 'io.reactivex:rxjava:1.1.6' compile 'io.reactivex:rxandroid:1.2.1' compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0'
Schritt 2
Fügen Sie beim Erstellen einer Retrofit-Instanz den neuen CallAdapter RxJavaCallAdapterFactory.create()
hinzu.
public static Retrofit getClient(String baseUrl) { if (retrofit==null) { retrofit = new Retrofit.Builder() .baseUrl(baseUrl) .addCallAdapterFactory(RxJavaCallAdapterFactory.create()) .addConverterFactory(GsonConverterFactory.create()) .build(); } return retrofit; }
Schritt 3
Beim Stellen der Anfragen antwortet unser anonymer Abonnent auf den Stream des Observables, der Ereignisse ausgibt, in unserem Fall SOAnswersResponse
. Die onNext
-Methode wird dann aufgerufen, wenn unser Abonnent ein ausgegebenes Ereignis empfängt, das dann an unseren Adapter übergeben wird.
@Override public void loadAnswers() { mService.getAnswers().subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers.mainThread()) .subscribe(new Subscriber<SOAnswersResponse>() { @Override public void onCompleted() { } @Override public void onError(Throwable e) { } @Override public void onNext(SOAnswersResponse soAnswersResponse) { mAdapter.updateAnswers(soAnswersResponse.getItems()); } }); }
Sehen Sie sich Erste Schritte mit ReactiveX auf Android von Ashraff Hathibelagal an, um mehr über RxJava und RxAndroid zu erfahren.
Abschluss
In diesem Tutorial haben Sie Retrofit kennengelernt: warum und wie Sie es verwenden sollten. Ich habe auch erklärt, wie man die RxJava-Integration mit Retrofit hinzufügt. In meinem nächsten Beitrag zeige ich Ihnen, wie Sie POST
, PUT
und DELETE
ausführen, wie Sie Form-Urlencoded
Daten senden und wie Sie Anfragen abbrechen.
Weitere Informationen zu Retrofit finden Sie in der offiziellen Dokumentation. Sehen Sie sich in der Zwischenzeit einige unserer anderen Kurse und Tutorials zur Android-App-Entwicklung an.