Cos'è Retrofit e come viene utilizzato nello sviluppo…

Retrofit è un client type-safe per le richieste HTTP su Android e Java. Semplifica l'interazione con le API REST usando annotazioni per descrivere le richieste.

Vantaggi principali:

Sicurezza di tipo: Le richieste e le risposte sono rappresentate come oggetti Java (o Kotlin), riducendo gli errori a runtime.
Facilità d'uso: Dichiarare i metodi HTTP con annotazioni rende il codice più leggibile e manutenibile.
Configurabilità: È facile aggiungere interceptors per logging, autenticazione e altri compiti.
Integrazione con convertitori: Supporta diversi convertitori per analizzare le risposte (JSON, XML, ecc.) direttamente dalla scatola (ad esempio Gson, Jackson).

Utilizzo:

Aggiungi le dipendenze:

// build.gradle (livello app)
dependencies {
    implementation 'com.squareup.retrofit2:retrofit:<latest_version>'
    // Scegli un convertitore per i tuoi dati (esempio Gson)
    implementation 'com.squareup.retrofit2:converter-gson:<latest_version>'
}

Definisci l'interfaccia API: Si crea un'interfaccia Java/Kotlin che dichiara tutti gli endpoint API usando annotazioni.

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

public interface ApiService {

    @GET("users/{userId}") // richiesta GET all'URL "users/{userId}"
    Call<User> getUser(@Path("userId") int userId); // @Path per inserire il valore nell'URL

    @GET("posts") // richiesta GET all'URL "posts"
    Call<List<Post>> getPosts();
}

// User.java (esempio POJO per la risposta)
public class User {
    private int id;
    private String name;
    // getters e setters
}

// Post.java (esempio POJO per la risposta)
public class Post {
    private int id;
    private int userId;
    private String title;
    private String body;
    // getters e setters
}

Crea l'istanza di 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 di base della tua API
    private static Retrofit retrofit;

    public static Retrofit getRetrofitInstance() {
        if (retrofit == null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL) // Imposta l'URL di base
                    .addConverterFactory(GsonConverterFactory.create()) // Aggiungi il convertitore
                    .build();
        }
        return retrofit;
    }

    public static ApiService getApiService() {
        return getRetrofitInstance().create(ApiService.class); // Crea l'istanza del servizio API
    }
}

Esegui le richieste:

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

// ...

ApiService apiService = RetrofitClient.getApiService();

// Richiesta asincrona per ottenere l'utente per ID
Call<User> userCall = apiService.getUser(1);
userCall.enqueue(new Callback<User>() { // enqueue per esecuzione asincrona in un altro thread
    @Override
    public void onResponse(Call<User> call, Response<User> response) {
        if (response.isSuccessful() && response.body() != null) {
            User user = response.body();
            // Processa l'utente ottenuto
        } else {
            // Gestione errore (ad esempio, response.code(), response.errorbody())
        }
    }

    @Override
    public void onFailure(Call<User> call, Throwable t) {
        // Gestione errore di rete o altra eccezione
        t.printStackTrace();
    }
});

// Richiesta asincrona per ottenere la lista dei post
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();
            // Processa la lista dei post
        } else {
            // Gestione errore
        }
    }

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

Retrofit astrarre i dettagli di basso livello del lavoro con HTTP, permettendo di concentrarsi sulla logica dell'applicazione.

Cos'è Retrofit e come viene utilizzato nello sviluppo Android?