Czym jest Retrofit i jak jest używany w rozwoju…

Retrofit to type-safe klient do zapytań HTTP na Androida i Java. Ułatwia interakcję z API REST, używając adnotacji do opisywania zapytań.

Główne zalety:

Bezpieczeństwo typów: Zapytania i odpowiedzi są reprezentowane jako obiekty Java (lub Kotlin), co zmniejsza liczbę błędów w czasie działania.
Łatwość użycia: Deklarowanie metod HTTP za pomocą adnotacji sprawia, że kod jest bardziej czytelny i łatwy w utrzymaniu.
Konfigurowalność: Łatwo dodawać interceptory do logowania, uwierzytelniania i innych zadań.
Integracja z konwerterami: Obsługuje różne konwertery do parsowania odpowiedzi (JSON, XML itp.) od razu z pudełka (np. Gson, Jackson).

Użycie:

Dodaj zależności:

// build.gradle (poziom aplikacji)
dependencies {
    implementation 'com.squareup.retrofit2:retrofit:<latest_version>'
    // Wybierz konwerter dla swoich danych (np. Gson)
    implementation 'com.squareup.retrofit2:converter-gson:<latest_version>'
}

Zdefiniuj interfejs API: Tworzy się interfejs Java/Kotlin, który deklaruje wszystkie endpointy API za pomocą adnotacji.

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

public interface ApiService {

    @GET("users/{userId}") // zapytanie GET do URL "users/{userId}"
    Call<User> getUser(@Path("userId") int userId); // @Path do podstawienia wartości w URL

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

// User.java (przykład POJO dla odpowiedzi)
public class User {
    private int id;
    private String name;
    // gettery i settery
}

// Post.java (przykład POJO dla odpowiedzi)
public class Post {
    private int id;
    private int userId;
    private String title;
    private String body;
    // gettery i settery
}

Utwórz instancję 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 bazowy API
    private static Retrofit retrofit;

    public static Retrofit getRetrofitInstance() {
        if (retrofit == null) {
            retrofit = new Retrofit.Builder()
                    .baseUrl(BASE_URL) // Ustaw URL bazowy
                    .addConverterFactory(GsonConverterFactory.create()) // Dodaj konwerter
                    .build();
        }
        return retrofit;
    }

    public static ApiService getApiService() {
        return getRetrofitInstance().create(ApiService.class); // Utwórz instancję serwisu API
    }
}

Wykonuj zapytania:

// W Activity, Fragment lub ViewModel
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;

// ...

ApiService apiService = RetrofitClient.getApiService();

// Asynchroniczne zapytanie o użytkownika po ID
Call<User> userCall = apiService.getUser(1);
userCall.enqueue(new Callback<User>() { // enqueue do asynchronicznego wykonania w innym wątku
    @Override
    public void onResponse(Call<User> call, Response<User> response) {
        if (response.isSuccessful() && response.body() != null) {
            User user = response.body();
            // Przetwarzanie pobranego użytkownika
        } else {
            // Obsługa błędu (np. response.code(), response.errorbody())
        }
    }

    @Override
    public void onFailure(Call<User> call, Throwable t) {
        // Obsługa błędu sieci lub innego wyjątku
        t.printStackTrace();
    }
});

// Asynchroniczne zapytanie o listę postów
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();
            // Przetwarzanie listy postów
        } else {
            // Obsługa błędu
        }
    }

    @Override
    public void onFailure(Call<List<Post>> call, Throwable t) {
        // Obsługa błędu
        t.printStackTrace();
    }
});

Retrofit abstrahuje szczegóły niskiego poziomu pracy z HTTP, pozwalając skupić się na logice aplikacji.

Czym jest Retrofit i jak jest używany w rozwoju Android?