Erste Schritte mit Retrofit 2 HTTP-Client

German (Deutsch) translation by Federicco Ancie (you can also view the original English article)

Final product image — What You'll Be Creating

Was ist Nachrüstung?

Retrofit ist ein typsicherer HTTP-Client für Android und Java. Retrofit macht es einfach, sich mit einem REST-Webservice zu verbinden, indem die API in Java-Schnittstellen übersetzt wird. In diesem Tutorial zeige ich Ihnen, wie Sie eine der beliebtesten und am häufigsten empfohlenen HTTP-Bibliotheken fü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 können alle ausgefü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 verfügt Retrofit über keinen integrierten JSON-Konverter zum Parsen von JSON- in Java-Objekte. Stattdessen wird die Unterstützung fü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 für XML unterstützt Retrofit:

Einfaches Framework: com.squareup.retrofit2:converter-simpleframework

Warum also Retrofit verwenden?

Die Entwicklung einer eigenen typsicheren HTTP-Bibliothek für die Schnittstelle zu einer REST-API kann eine echte Herausforderung sein: Sie müssen viele Funktionen wie Herstellen von Verbindungen, Caching, Wiederholen fehlgeschlagener Anforderungen, Threading, Antwortparsing, Fehlerbehandlung und mehr bewältigen. Retrofit hingegen ist sehr gut geplant, dokumentiert und getestet – eine kampferprobte Bibliothek, die Ihnen viel kostbare Zeit und Kopfschmerzen erspart.

In diesem Tutorial erklä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 führen GET-Anfragen durch, indem wir einen Endpunkt angeben – /answers, angehä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 Aktivität namens MainActivity.

2. Abhängigkeiten erklären

Deklarieren Sie nach dem Erstellen eines neuen Projekts die folgenden Abhängigkeiten in Ihrer build.gradle. Zu den Abhängigkeiten gehö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 hinzufügen

Um Netzwerkvorgänge durchzuführen, mü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 nü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 fügen Sie sie in die Adressleiste Ihres Browsers ein (oder Sie können Postman verwenden, wenn Sie mit diesem Tool vertraut sind). Drücken Sie dann die Eingabetaste – dies fü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 fügen Sie die JSON-Antwort in das Eingabefeld ein.

Wählen Sie einen Quelltyp von JSON, einen Anmerkungsstil von Gson und deaktivieren Sie das Kontrollkästchen Zusätzliche Eigenschaften zulassen.

Klicken Sie dann auf die Schaltflä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 erkläre alles!

Die Annotation @SerializedName wird benötigt, damit Gson die JSON-Schlüssel unseren Feldern zuordnet. In Übereinstimmung mit der camelCase-Namenskonvention von Java für Klassenmembereigenschaften wird davon abgeraten, Unterstriche zum Trennen von Wörtern in einer Variablen zu verwenden. @SerializedName hilft bei der Übersetzung zwischen den beiden.

1	@SerializedName("quota_remaining")
2	@Expose
3	private Integer quotaRemaining;

Im obigen Beispiel teilen wir Gson mit, dass unser JSON-Schlüssel quota_remaining dem Java-Feld quotaRemaining zugeordnet werden soll. Wenn diese beiden Werte gleich wären, d. h. wenn unser JSON-Schlüssel quotaRemaining genau wie das Java-Feld wäre, dann wäre die Annotation @SerializedName für das Feld nicht erforderlich, da Gson sie automatisch zuordnen würde.

Die Annotation @Expose gibt an, dass dieser Member für die JSON-Serialisierung oder -Deserialisierung verfügbar gemacht werden soll.

Datenmodelle in Android Studio importieren

Kehren wir nun zu Android Studio zurü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 fü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 fü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 für die zurückgegebenen StackOverflow-Antworten. Den Code für diese Klasse finden Sie in jsonschema2pojo als Example. Stellen Sie sicher, dass Sie den Klassennamen ü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, mü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 benötigt eine Basis-URL, um seine Instanz zu erstellen, daher ü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 benö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 enthält Methoden, die wir verwenden werden, um HTTP-Anforderungen wie GET, POST, PUT, PATCH und DELETE auszuführen. Für dieses Tutorial werden wir eine GET-Anfrage ausfü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 ausgefü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 fünf integrierte Anmerkungen zur Verfügung: @GET, @POST, @PUT, @DELETE und @HEAD.

In der zweiten Methodendefinition haben wir einen Abfrageparameter hinzugefügt, damit wir die Daten vom Server filtern können. Retrofit hat die Annotation @Query("key"), die verwendet wird, anstatt sie im Endpunkt fest zu codieren. Der Schlüsselwert stellt den Parameternamen in der URL dar. Es wird der URL von Retrofit hinzugefügt. Wenn wir beispielsweise den Wert "android" als Argument an die Methode getAnswers(String tags) übergeben, lautet die vollständige URL:

1	https://api.stackexchange.com/2.2/answers?order=desc&sort=activity&site=stackoverflow&tagged=android

Parameter der Schnittstellenmethoden können folgende Annotationen haben:

`@Path`	Variablensubstitution für den API-Endpunkt
`@Query`	gibt den Abfrageschlüsselnamen mit dem Wert des annotierten Parameters an
`@Body`	Nutzlast fü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 über die statische Methode getSOService() auch die SOService-Schnittstelle zur Verfü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, benö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. Ausfü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 zurückkommt, hilft uns Retrofit, die JSON-Antwort auf eine Liste von Java-Objekten zu analysieren. (Dies wird durch die Verwendung von GsonConverter ermö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 Rückruf, wenn eine Antwort zurückkommt. Da diese Anforderung asynchron ist, verarbeitet Retrofit sie in einem Hintergrundthread, damit der Haupt-UI-Thread nicht blockiert oder gestört wird.

Um enqueue() zu verwenden, müssen Sie zwei Callback-Methoden implementieren:

onResponse()
onFailure()

Als Antwort auf eine bestimmte Anforderung wird nur eine dieser Methoden aufgerufen.

onResponse(): wird für eine empfangene HTTP-Antwort aufgerufen. Diese Methode wird für eine Antwort aufgerufen, die auch dann korrekt verarbeitet werden kann, wenn der Server eine Fehlermeldung zurü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 können, können Sie die Methode response.code() verwenden. Sie können auch die Methode isSuccessful() 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 auszuführen, können Sie die Methode execute() verwenden. Beachten Sie, dass synchrone Methoden im Haupt-/UI-Thread jede Benutzeraktion blockieren. Führen Sie also keine synchronen Methoden im Haupt-/UI-Thread von Android aus! Führen Sie sie stattdessen in einem Hintergrundthread aus.

11. Testen der App

Sie können die App jetzt ausführen.

12. RxJava-Integration

Wenn Sie ein Fan von RxJava sind, können Sie Retrofit mit RxJava problemlos implementieren. In Retrofit 1 war es standardmäßig integriert, aber in Retrofit 2 müssen Sie einige zusätzliche Abhängigkeiten einbeziehen. Retrofit wird mit einem Standardadapter zum Call von Anrufinstanzen geliefert. Sie können also den Ausführungsmechanismus von Retrofit so ändern, dass er RxJava enthält, indem Sie den RxJava CallAdapter einbinden.

Schritt 1

Fügen Sie die Abhängigkeiten hinzu.

1	compile 'io.reactivex:rxjava:1.1.6'
2	compile 'io.reactivex:rxandroid:1.2.1'
3	compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0'

Schritt 2

Fü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 empfängt, das dann an unseren Adapter ü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 über RxJava und RxAndroid zu erfahren.

Android

Erste Schritte mit ReactiveX auf Android

Ashraff Hathibelagal

Abschluss

In diesem Tutorial haben Sie Retrofit kennengelernt: warum und wie Sie es verwenden sollten. Ich habe auch erklärt, wie man die RxJava-Integration mit Retrofit hinzufügt. In meinem nächsten Beitrag zeige ich Ihnen, wie Sie POST, PUT und DELETE ausfü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.

Kommunikation innerhalb einer Android-App mit EventBus
Greenrobot EventBus ist eine beliebte Open-Source-Bibliothek, die das Publish/Subscribe-Modell für die Kommunikation zwischen Komponenten des Android-Systems verwendet. Im...

Chike Mgbemena
25.11.2016

Android
Praktische Parallelität auf Android mit HaMeR
In diesem Tutorial untersuchen wir das HaMeR-Framework (Handler, Message and Runnable), eines der leistungsstärksten Parallelitätsmodelle für Android. Mit einer...

Tin Megali
19.09.2016

Android SDK
Android von Grund auf neu: REST-APIs verwenden
In diesem Tutorial zeige ich Ihnen, wie Sie die im Android SDK verfügbaren Klassen und Methoden verwenden, um eine Verbindung zu Remote-Webservern herzustellen und mit...

Ashraff Hathibelagal
05.09.2016

Android SDK
Erste Schritte mit einer Android-App-Vorlage in 60 Sekunden Second
CodeCanyon verfügt über Hunderte von Android-App-Vorlagen, die Sie verwenden können, um Ihre Entwicklung zu starten. In diesem Video erfahren Sie, wie Sie ein...

Ashraff Hathibelagal
07.10.2016

Android SDK