Comment effectuer des requêtes réseau avec la…

Ajouter la dépendance : Dans build.gradle (app).

// Retrofit
implementation 'com.squareup.retrofit2:retrofit:<latest_version>'
implementation 'com.squareup.retrofit2:converter-gson:<latest_version>' // ou un autre convertisseur

Créer une interface API : Définir des méthodes pour chaque requête réseau.
```
interface ApiService {
    @GET("users/{id}")
    Call<User> getUser(@Path("id") int userId);

    @POST("users")
    Call<User> createUser(@Body User user);
}
```
- @GET, @POST, et autres annotations définissent le type de méthode HTTP.
- "users/{id}" - chemin relatif à la ressource.
- @Path, @Query, @Body - annotations pour les paramètres de la requête.
- Call<T> - type de retour pour les requêtes asynchrones ou synchrones.

Créer une instance de Retrofit : Configurer l'URL de base et ajouter un convertisseur.

Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.example.com/")
    .addConverterFactory(GsonConverterFactory.create()) // Utiliser Gson pour parser JSON
    .build();

ApiService apiService = retrofit.create(ApiService.class);

Effectuer la requête : De manière asynchrone ou synchrone.

Asynchrone (recommandé pour le fil UI) :

Call<User> call = apiService.getUser(123);
call.enqueue(new Callback<User>() {
    @Override
    public void onResponse(Call<User> call, Response<User> response) {
        if (response.isSuccessful()) {
            User user = response.body();
            // Traiter la réponse réussie
        } else {
            // Traiter l'erreur de réponse (par ex. 404, 500)
        }
    }

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

Synchrone (ne pas utiliser dans le fil UI) :

try {
    Response<User> response = apiService.getUser(123).execute();
    if (response.isSuccessful()) {
        User user = response.body();
        // Traiter la réponse réussie
    } else {
        // Traiter l'erreur de réponse
    }
} catch (IOException e) {
    // Traiter l'erreur
}

Traiter la réponse : Dans les méthodes onResponse ou après un execute réussi. Vérifier le statut de la réponse (response.isSuccessful()) et extraire les données (response.body()). Gérer les erreurs dans onFailure ou dans le bloc catch pour la requête synchrone.

Retrofit supporte également l'intégration avec les coroutines (avec retrofit2:retrofit2-kotlin-coroutines-adapter), RxJava (avec retrofit2:adapter-rxjava), et d'autres bibliothèques pour la programmation asynchrone.

Comment effectuer des requêtes réseau avec la bibliothèque Retrofit?