Qu'est-ce que Retrofit et comment est-il utilisé dans…

Retrofit est un client type-safe pour les requêtes HTTP sous Android et Java. Il simplifie l'interaction avec les API REST en utilisant des annotations pour décrire les requêtes.

Principaux avantages:

Sécurité de type: Les requêtes et réponses sont représentées sous forme d'objets Java (ou Kotlin), ce qui réduit les erreurs à l'exécution.
Facilité d'utilisation: Déclarer les méthodes HTTP avec des annotations rend le code plus lisible et maintenable.
Configurabilité: Il est facile d'ajouter des interceptors pour la journalisation, l'authentification, etc.
Intégration avec des convertisseurs: Supporte différents convertisseurs pour parser les réponses (JSON, XML, etc.) dès la sortie.

Utilisation:

Ajouter des dépendances:

// build.gradle (niveau app)
dependencies {
    implementation 'com.squareup.retrofit2:retrofit:<latest_version>'
    // Choisissez un convertisseur pour vos données (exemple avec Gson)
    implementation 'com.squareup.retrofit2:converter-gson:<latest_version>'
}

Définir l'interface API: Créez une interface Java/Kotlin déclarant tous les endpoints de l'API avec des annotations.

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

public interface ApiService {

    @GET("users/{userId}") // requête GET à l'URL "users/{userId}"
    Call<User> getUser(@Path("userId") int userId); // @Path pour insérer la valeur dans l'URL

    @GET("posts") // requête GET à l'URL "posts"
    Call<List<Post>> getPosts();
}

// User.java (exemple POJO pour la réponse)
public class User {
    private int id;
    private String name;
    // getters et setters
}

// Post.java (exemple POJO pour la réponse)
public class Post {
    private int id;
    private int userId;
    private String title;
    private String body;
    // getters et setters
}

Créer une instance de Retrofit:

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

public class RetrofitClient {

    private static final String BASE_URL = "https://api.example.com/"; // URL de base de votre API
    private static Retrofit retrofit;

    public static Retrofit getRetrofitInstance() {
        if (retrofit == null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL) // Définir l'URL de base
                    .addConverterFactory(GsonConverterFactory.create()) // Ajouter le convertisseur
                    .build();
        }
        return retrofit;
    }

    public static ApiService getApiService() {
        return getRetrofitInstance().create(ApiService.class); // Créer une instance du service API
    }
}

Exécuter les requêtes:

// Dans Activity, Fragment ou ViewModel
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;

// ...

ApiService apiService = RetrofitClient.getApiService();

// Requête asynchrone pour obtenir un utilisateur par ID
Call<User> userCall = apiService.getUser(1);
userCall.enqueue(new Callback<User>() { // enqueue pour exécution asynchrone dans un autre thread
    @Override
    public void onResponse(Call<User> call, Response<User> response) {
        if (response.isSuccessful() && response.body() != null) {
            User user = response.body();
            // Traiter l'utilisateur reçu
        } else {
            // Traiter l'erreur (par ex. response.code(), response.errorbody())
        }
    }

    @Override
    public void onFailure(Call<User> call, Throwable t) {
        // Traiter l'erreur réseau ou autre exception
        t.printStackTrace();
    }
});

// Requête asynchrone pour obtenir la liste des posts
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();
            // Traiter la liste des posts
        } else {
            // Traiter l'erreur
        }
    }

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

Retrofit abstrait les détails bas niveau du travail avec HTTP, permettant de se concentrer sur la logique de l'application.

Qu'est-ce que Retrofit et comment est-il utilisé dans le développement Android?