¿Qué es Retrofit y cómo se utiliza en el desarrollo…

Retrofit es un cliente type-safe para solicitudes HTTP en Android y Java. Simplifica la interacción con APIs REST usando anotaciones para describir las solicitudes.

Ventajas principales:

Seguridad de tipos: Las solicitudes y respuestas se representan como objetos Java (o Kotlin), lo que reduce errores en tiempo de ejecución.
Facilidad de uso: Declarar métodos HTTP con anotaciones hace que el código sea más legible y mantenible.
Configurabilidad: Es fácil agregar interceptores para logging, autenticación y otras tareas.
Integración con convertidores: Soporta diferentes convertidores para parsear respuestas (JSON, XML, etc.) desde la caja (por ejemplo, Gson, Jackson).

Uso:

Agregar dependencias:

// build.gradle (nivel app)
dependencies {
    implementation 'com.squareup.retrofit2:retrofit:<latest_version>'
    // Elige un convertidor para tus datos (aquí un ejemplo para Gson)
    implementation 'com.squareup.retrofit2:converter-gson:<latest_version>'
}

Definir la interfaz API: Se crea una interfaz Java/Kotlin que declara todos los endpoints de la API usando anotaciones.

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

public interface ApiService {

    @GET("users/{userId}") // solicitud GET a la URL "users/{userId}"
    Call<User> getUser(@Path("userId") int userId); // @Path para insertar el valor en la URL

    @GET("posts") // solicitud GET a la URL "posts"
    Call<List<Post>> getPosts();
}

// User.java (ejemplo POJO para la respuesta)
public class User {
    private int id;
    private String name;
    // getters y setters
}

// Post.java (ejemplo POJO para la respuesta)
public class Post {
    private int id;
    private int userId;
    private String title;
    private String body;
    // getters y setters
}

Crear instancia 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 base de tu API
    private static Retrofit retrofit;

    public static Retrofit getRetrofitInstance() {
        if (retrofit == null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL) // Establecer URL base
                    .addConverterFactory(GsonConverterFactory.create()) // Agregar convertidor
                    .build();
        }
        return retrofit;
    }

    public static ApiService getApiService() {
        return getRetrofitInstance().create(ApiService.class); // Crear instancia del servicio API
    }
}

Ejecutar solicitudes:

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

// ...

ApiService apiService = RetrofitClient.getApiService();

// Solicitud asíncrona para obtener usuario por ID
Call<User> userCall = apiService.getUser(1);
userCall.enqueue(new Callback<User>() { // enqueue para ejecución asíncrona en otro hilo
    @Override
    public void onResponse(Call<User> call, Response<User> response) {
        if (response.isSuccessful() && response.body() != null) {
            User user = response.body();
            // Procesar usuario obtenido
        } else {
            // Procesar error (por ejemplo, response.code(), response.errorbody())
        }
    }

    @Override
    public void onFailure(Call<User> call, Throwable t) {
        // Procesar error de red u otra excepción
        t.printStackTrace();
    }
});

// Solicitud asíncrona para obtener lista de 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();
            // Procesar lista de posts
        } else {
            // Procesar error
        }
    }

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

Retrofit abstrae los detalles de bajo nivel del trabajo con HTTP, permitiendo centrarse en la lógica de la aplicación.

¿Qué es Retrofit y cómo se utiliza en el desarrollo de Android?