Wat is Retrofit en hoe wordt het gebruikt in…

Retrofit is een type-safe client voor HTTP-verzoeken voor Android en Java. Het vereenvoudigt de interactie met REST API's door annotaties te gebruiken om verzoeken te beschrijven.

Belangrijkste voordelen:

Typeveiligheid: Verzoeken en antwoorden worden weergegeven als Java (of Kotlin) objecten, wat het aantal runtime-fouten vermindert.
Gebruiksgemak: Het declareren van HTTP-methoden met annotaties maakt de code leesbaarder en onderhoudsvriendelijker.
Configureerbaarheid: Het is eenvoudig om interceptors toe te voegen voor logging, authenticatie en andere taken.
Integratie met converters: Ondersteunt verschillende converters voor het parseren van antwoorden (JSON, XML, etc.), zoals Gson, Jackson.

Gebruik:

Dependencies toevoegen:

// build.gradle (app niveau)
dependencies {
    implementation 'com.squareup.retrofit2:retrofit:<latest_version>'
    // Kies een converter voor je data (hier een voorbeeld voor Gson)
    implementation 'com.squareup.retrofit2:converter-gson:<latest_version>'
}

Definieer de API-interface: Creëer een Java/Kotlin interface die alle API Endpoints declareert met annotaties.

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

public interface ApiService {

    @GET("users/{userId}") // GET verzoek naar URL "users/{userId}"
    Call<User> getUser(@Path("userId") int userId); // @Path voor het invullen van de waarde in de URL

    @GET("posts") // GET verzoek naar URL "posts"
    Call<List<Post>> getPosts();
}

// User.java (voorbeeld POJO voor antwoord)
public class User {
    private int id;
    private String name;
    // getters en setters
}

// Post.java (voorbeeld POJO voor antwoord)
public class Post {
    private int id;
    private int userId;
    private String title;
    private String body;
    // getters en setters
}

Maak een Retrofit-instantie:

// 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 van je API
    private static Retrofit retrofit;

    public static Retrofit getRetrofitInstance() {
        if (retrofit == null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL) // Stel de basis URL in
                    .addConverterFactory(GsonConverterFactory.create()) // Voeg converter toe
                    .build();
        }
        return retrofit;
    }

    public static ApiService getApiService() {
        return getRetrofitInstance().create(ApiService.class); // Maak een API service instantie
    }
}

Voer verzoeken uit:

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

// ...

ApiService apiService = RetrofitClient.getApiService();

// Asynchroon verzoek om gebruiker op ID te krijgen
Call<User> userCall = apiService.getUser(1);
userCall.enqueue(new Callback<User>() { // enqueue voor asynchrone uitvoering
    @Override
    public void onResponse(Call<User> call, Response<User> response) {
        if (response.isSuccessful() && response.body() != null) {
            User user = response.body();
            // Verwerk de ontvangen user
        } else {
            // Verwerk fout (bijvoorbeeld response.code(), response.errorbody())
        }
    }

    @Override
    public void onFailure(Call<User> call, Throwable t) {
        // Verwerk netwerkfout of andere uitzondering
        t.printStackTrace();
    }
});

// Asynchroon verzoek om lijst van posts te krijgen
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();
            // Verwerk lijst van posts
        } else {
            // Verwerk fout
        }
    }

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

Retrofit abstraheert de low-level details van HTTP, waardoor je je kunt richten op de logica van de applicatie.

Wat is Retrofit en hoe wordt het gebruikt in Android-ontwikkeling?