Was ist Retrofit und wie wird es in der…

Retrofit ist ein type-safe Client für HTTP-Anfragen unter Android und Java. Es vereinfacht die Interaktion mit REST-APIs, indem es Annotations zur Beschreibung der Anfragen verwendet.

Hauptvorteile:

Typensicherheit: Anfragen und Antworten werden als Java- (oder Kotlin-)Objekte dargestellt, was Laufzeitfehler reduziert.
Benutzerfreundlichkeit: Die Deklaration von HTTP-Methoden mit Annotations macht den Code lesbarer und wartbarer.
Konfigurierbarkeit: Es ist einfach, Interceptors für Logging, Authentifizierung und andere Aufgaben hinzuzufügen.
Integration mit Konvertern: Unterstützt verschiedene Konverter zum Parsen von Antworten (JSON, XML usw.) direkt aus der Box (z.B. Gson, Jackson).

Verwendung:

Abhängigkeiten hinzufügen:

// build.gradle (app level)
dependencies {
    implementation 'com.squareup.retrofit2:retrofit:<latest_version>'
    // Wählen Sie einen Konverter für Ihre Daten (hier Beispiel für Gson)
    implementation 'com.squareup.retrofit2:converter-gson:<latest_version>'
}

API-Interface definieren: Es wird eine Java/Kotlin-Schnittstelle erstellt, die alle API-Endpunkte mit Annotations deklariert.

// ApiService.java
import retrofit2.Call;
import retrofit2.http.GET;
import retrofit2.http.Path;
import java.util.List;

public interface ApiService {

    @GET("users/{userId}") // GET-Anfrage an URL "users/{userId}"
    Call<User> getUser(@Path("userId") int userId); // @Path für Einfügen des Wertes in die URL

    @GET("posts") // GET-Anfrage an URL "posts"
    Call<List<Post>> getPosts();
}

// User.java (Beispiel POJO für die Antwort)
public class User {
    private int id;
    private String name;
    // Getter und Setter
}

// Post.java (Beispiel POJO für die Antwort)
public class Post {
    private int id;
    private int userId;
    private String title;
    private String body;
    // Getter und Setter
}

Retrofit-Instanz erstellen:

// RetrofitClient.java
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class RetrofitClient {

    private static final String BASE_URL = "https://api.example.com/"; // Basis-URL Ihrer API
    private static Retrofit retrofit;

    public static Retrofit getRetrofitInstance() {
        if (retrofit == null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL) // Basis-URL setzen
                    .addConverterFactory(GsonConverterFactory.create()) // Konverter hinzufügen
                    .build();
        }
        return retrofit;
    }

    public static ApiService getApiService() {
        return getRetrofitInstance().create(ApiService.class); // API-Service-Instanz erstellen
    }
}

Anfragen ausführen:

// In Activity, Fragment oder ViewModel
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;

// ...

ApiService apiService = RetrofitClient.getApiService();

// Asynchrone Anfrage, um Benutzer nach ID zu erhalten
Call<User> userCall = apiService.getUser(1);
userCall.enqueue(new Callback<User>() { // enqueue für asynchrone Ausführung in einem anderen Thread
    @Override
    public void onResponse(Call<User> call, Response<User> response) {
        if (response.isSuccessful() && response.body() != null) {
            User user = response.body();
            // Verarbeite den erhaltenen User
        } else {
            // Fehlerbehandlung (z.B. response.code(), response.errorbody())
        }
    }

    @Override
    public void onFailure(Call<User> call, Throwable t) {
        // Fehlerbehandlung bei Netzwerkfehlern oder anderen Ausnahmen
        t.printStackTrace();
    }
});

// Asynchrone Anfrage, um die Liste der Posts zu erhalten
Call<List<Post>> postsCall = apiService.getPosts();
postsCall.enqueue(new Callback<List<Post>>() {
    @Override
    public void onResponse(Call<List<Post>> call, Response<List<Post>> response) {
        if (response.isSuccessful() && response.body() != null) {
            List<Post> posts = response.body();
            // Verarbeite die Post-Liste
        } else {
            // Fehlerbehandlung
        }
    }

    @Override
    public void onFailure(Call<List<Post>> call, Throwable t) {
        // Fehlerbehandlung
        t.printStackTrace();
    }
});

Retrofit abstrahiert die Low-Level-Details der HTTP-Arbeit, sodass man sich auf die Anwendungslogik konzentrieren kann.

Was ist Retrofit und wie wird es in der Android-Entwicklung verwendet?