10 Retrofit¶

dependencies {
    // ...
    implementation 'com.squareup.retrofit2:retrofit:2.X.X'
    implementation 'com.google.code.gson:gson:2.X.X'
    implementation 'com.squareup.retrofit2:converter-gson:2.X.X'
}

<dependencies>
    <dependency>
        <groupId>com.squareup.retrofit2</groupId>
        <artifactId>retrofit</artifactId>
        <version>2.X.X</version>
    </dependency>
    <dependency>
        <groupId>com.google.code.gson</groupId>
        <artifactId>gson</artifactId>
        <version>2.X.X</version>
    </dependency>
    <dependency>
        <groupId>com.squareup.retrofit2</groupId>
        <artifactId>converter-gson</artifactId>
        <version>2.X.X</version>
    </dependency>
</dependencies>

dependencies {
    // ...
    implementation 'com.squareup.okhttp3:okhttp:X.X.X'
}

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
    <version>X.X.X</version>
</dependency>

dependencies {
    // ...
    implementation 'com.squareup.okhttp3:logging-interceptor:X.X.X'
}

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>logging-interceptor</artifactId>
    <version>X.X.X</version>
</dependency>

import es.iessaladillo.pedrojoya.retrofit.data.api.ApiService;
import es.iessaladillo.pedrojoya.retrofit.data.api.response.PostResponse;
import okhttp3.OkHttpClient;
import okhttp3.logging.HttpLoggingInterceptor;
import org.jetbrains.annotations.NotNull;
import retrofit2.Call;
import retrofit2.Callback;
import retrofit2.Response;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

import java.io.IOException;
import java.util.List;
import java.util.Scanner;
import java.util.stream.Collectors;

public class Main {

    private final ApiService apiService = createApiService();
    private final Scanner scanner = new Scanner(System.in);

    Main() {
        int selectedOption = showMenu();
        processOption(selectedOption);
    }

    public static void main(String[] args) {
        new Main();
    }

    private int showMenu() {
        System.out.println("\nMENU");
        System.out.println("1. Show all posts synchronously");
        System.out.println("2. Show all posts with callback");
        System.out.println("3. Show all posts");
        System.out.println("4. Show post");
        System.out.println("5. Show user's posts");
        System.out.println("6. Show posts by user");
        System.out.println("7. Create post");
        System.out.println("8. Update post");
        System.out.println("9. Update post partially");
        System.out.println("10. Delete post");
        System.out.println("11. Show only headers");
        System.out.println("12. Show access options");
        System.out.print("Select an option: ");
        try {
            return scanner.nextInt();
        } catch (Exception e) {
            scanner.nextLine();
            return 0;
        }
    }

    private void processOption(int selectedOption) {
        switch (selectedOption) {
            case 1:
                showPostsSync();
                break;
            case 2:
                showPostsWithCallback();
                break;
            case 3:
                showPosts();
                break;
            case 4:
                showPost(1);
                break;
            case 5:
                showUserPosts(1);
                break;
            case 6:
                showPostsByUser(1);
                break;
            case 7:
                createPost(new PostResponse(1, 0, "Baldomero", "Llégate Ligero"));
                break;
            case 8:
                updatePost(1, new PostResponse(1, 1, "Baldomero", "Llégate Ligero"));
                break;
            case 9:
                patchPost(1, new PostResponse(3, 1, "Baldomero", "Llégate Ligero"));
                break;
            case 10:
                deletePost(1);
                break;
            case 11:
                showPostsHeaders();
                break;
            case 12:
                showPostsAccessOptions();
                break;
        }
    }

    private void showPostsSync() {
        try {
            Response<List<PostResponse>> response = apiService.getPostsCall().execute();
            if (response.isSuccessful() && response.body() != null) {
                showModel(response.body());
            }
        } catch (IOException e) {
            showError(e);
        }
    }

    private void showPostsWithCallback() {
        apiService.getPostsCall().enqueue(new Callback<List<PostResponse>>() {
            @Override
            public void onResponse(Call<List<PostResponse>> call, Response<List<PostResponse>> response) {
                if (response.isSuccessful() && response.body() != null) {
                    showModel(response.body());
                }
            }

            @Override
            public void onFailure(Call<List<PostResponse>> call, Throwable t) {
                System.out.println(t.toString());
            }
        });
    }

    private void showPosts() {
        apiService.getPosts().whenComplete(this::showErrorOrModel);
    }

    private void showPostsAccessOptions() {
        apiService.getPostsAccessOptions()
                .thenApply(response ->
                        String.join(";", response.headers().values("access-control-allow-methods")))
                .whenComplete(this::showErrorOrModel);
    }

    private void showPostsHeaders() {
        apiService.getPostsHeaders()
                .thenApply(response -> response.headers().toMultimap().entrySet().stream()
                        .map(entry -> entry.getKey() + ": " + String.join(";", entry.getValue()))
                        .collect(Collectors.joining("\n"))
                )
                .whenComplete(this::showErrorOrModel);
    }

    private void showPost(int postId) {
        apiService.getPost(1).whenComplete(this::showErrorOrModel);
    }

    private void createPost(PostResponse postResponse) {
        apiService.createPost(postResponse).whenComplete(this::showErrorOrModel);
    }

    private void updatePost(int postId, PostResponse postResponse) {
        apiService.updatePost(postId, postResponse).whenComplete(this::showErrorOrModel);
    }

    private void patchPost(int postId, PostResponse postResponse) {
        apiService.patchPost(postId, postResponse).whenComplete(this::showErrorOrModel);
    }

    private void deletePost(int postId) {
        apiService.deletePost(postId).whenComplete(this::showErrorOrModel).join();
    }

    private void showUserPosts(int userId) {
        apiService.getUserPosts(userId).whenComplete(this::showErrorOrModel).join();
    }

    private void showPostsByUser(int userId) {
        apiService.getPostsByUser(userId).whenComplete(this::showErrorOrModel).join();
    }

    // -------------------------

    @NotNull
    private ApiService createApiService() {
        HttpLoggingInterceptor logInterceptor = new HttpLoggingInterceptor();
        logInterceptor.setLevel(HttpLoggingInterceptor.Level.BASIC);
        OkHttpClient okHttpClient = new OkHttpClient.Builder().addInterceptor(logInterceptor).build();
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("https://jsonplaceholder.typicode.com/")
                .client(okHttpClient)
                .addConverterFactory(GsonConverterFactory.create())
                .build();
        return retrofit.create(ApiService.class);
    }

    @NotNull
    private ApiService createSwapiService() {
        HttpLoggingInterceptor logInterceptor = new HttpLoggingInterceptor();
        logInterceptor.setLevel(HttpLoggingInterceptor.Level.BASIC);
        OkHttpClient okHttpClient = new OkHttpClient.Builder().addInterceptor(logInterceptor).build();
        Retrofit retrofit = new Retrofit.Builder()
                .baseUrl("https://swapi.co/api/")
                .client(okHttpClient)
                .addConverterFactory(GsonConverterFactory.create())
                .build();
        return retrofit.create(ApiService.class);
    }

    private <T> void showErrorOrModel(T model, Throwable throwable) {
        if (throwable != null) {
            showError(throwable);
        } else {
            showModel(model);
        }
    }

    private void showError(Throwable e) {
        System.out.println(e.toString());
    }

    private <T> void showModel(T model) {
        System.out.println(model);
    }

}

import es.iessaladillo.pedrojoya.retrofit.data.api.response.PostResponse;
import retrofit2.Call;
import retrofit2.Response;
import retrofit2.http.*;

import java.util.List;
import java.util.concurrent.CompletableFuture;

public interface ApiService {

    @GET("posts")
    Call<List<PostResponse>> getPostsCall();

    @GET("posts")
    CompletableFuture<List<PostResponse>> getPosts();

    @OPTIONS("posts")
    CompletableFuture<Response<PostResponse>> getPostsAccessOptions();

    @HEAD("posts")
    CompletableFuture<Response<Void>> getPostsHeaders();

    @GET("posts/{postId}")
    public CompletableFuture<PostResponse> getPost(@Path("postId") int postId);

    @POST("posts")
    CompletableFuture<PostResponse> createPost(@Body PostResponse postResponse);

    @PUT("posts/{postId}")
    CompletableFuture<PostResponse> updatePost(@Path("postId") int postId, 
                                            @Body PostResponse postResponse);

    @PATCH("posts/{postId}")
    public CompletableFuture<PostResponse> patchPost(@Path("postId") int postId, 
                                                    @Body PostResponse postResponse);

    @DELETE("posts/{postId}")
    CompletableFuture<Void> deletePost(@Path("postId") int postId);

    @GET("users/{userId}/posts")
    CompletableFuture<List<PostResponse>> getUserPosts(@Path("userId") int userId);

    @GET("posts")
    CompletableFuture<List<PostResponse>> getPostsByUser(@Query("userId") int userId);

}

import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;

public class PostResponse {

    @SerializedName("userId")
    @Expose
    private Integer userId;
    @SerializedName("id")
    @Expose
    private Integer id;
    @SerializedName("title")
    @Expose
    private String title;
    @SerializedName("body")
    @Expose
    private String body;

    public PostResponse(Integer userId, Integer id, String title, String body) {
        this.userId = userId;
        this.id = id;
        this.title = title;
        this.body = body;
    }

    @Override
    public String toString() {
        return "{" +
                "userId=" + userId +
                ", id=" + id +
                ", title='" + title + '\'' +
                '}';
    }
}