Hướng dẫn Khai thác API trong Android (Java): Toàn tập về Retrofit và Volley

Giới thiệu: Từ Postman đến Ứng dụng Android

Ở bài viết trước, chúng ta đã học cách dùng Postman để “nói chuyện” với API. Postman giống như một “người khách” giả lập, giúp chúng ta kiểm tra xem “nhà bếp” (Backend) có trả về đúng “món ăn” (dữ liệu) hay không.

Nhưng bây.”giờ, chúng ta cần xây dựng “người khách” thực sự: chính là ứng dụng Android của bạn.

Bạn không thể dùng HttpURLConnection hay AsyncTask (các công cụ có sẵn của Java/Android) vì chúng rất rườm rà, khó quản lý, dễ gây lỗi (như chặn luồng chính – Main Thread) và AsyncTask giờ đây đã lỗi thời.

Chúng ta cần những “sứ giả” chuyên nghiệp hơn. Đó là lý do Retrofit và Volley ra đời.

Tính năngRetrofit (của Square)Volley (của Google)
Mục đích chínhThư viện HTTP Client type-safe cho Android và Java.Thư viện HTTP được thiết kế cho tốc độ, hiệu quả.
Phân tích JSONTự động. Tích hợp sẵn với các bộ chuyển đổi (như Gson, Moshi).Thủ công. Bạn phải tự phân tích JSONObject/JSONArray.
Cách tiếp cậnDùng Interface và Annotation (chú thích) để định nghĩa API.Dùng các đối tượng Request (như StringRequest, JsonObjectRequest).
Độ phổ biếnCực kỳ phổ biến. Gần như là tiêu chuẩn cho các dự án mới.Vẫn được dùng, đặc biệt mạnh về tải ảnh và các request đơn giản.

Lời khuyên: Hầu hết các dự án Java Android hiện đại sẽ ưu tiên dùng Retrofit vì sự sạch sẽ, an toàn (type-safe) và khả năng tự động phân tích JSON. Chúng ta sẽ bắt đầu với Retrofit.


HƯỚNG DẪN SỬ DỤNG

Bước 0: Chuẩn bị

Trước khi code, bạn cần 2 thứ:

(1). Cấp quyền Internet: Ứng dụng của bạn cần được phép truy cập mạng. Mở file AndroidManifest.xml và thêm dòng này (bên ngoài thẻ <application>):

<uses-permission android:name="android.permission.INTERNET" />

(2) Thêm thư viện: Mở file build.gradle (của Module: app) và thêm các thư viện cần thiết vào mục dependencies:

// Retrofit
implementation 'com.squareup.retrofit2:retrofit:2.9.0'

// Gson Converter (Để Retrofit tự động chuyển JSON sang Object)
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'

// Volley (Nếu muốn dùng Volley)
implementation 'com.android.volley:volley:1.2.1'

Chúng ta sẽ dùng API thực hành từ https://jsonplaceholder.typicode.com/ cho các ví dụ này.


Phần 1: Khai thác API với Retrofit

Retrofit hoạt động dựa trên 3 thành phần chính: Model (POJO), Interface (Service), và Retrofit Instance (Builder).

Bước 1: Tạo Model Class (POJO) – “Cái khuôn”

API trả về dữ liệu JSON. Chúng ta cần tạo một lớp Java (gọi là POJO – Plain Old Java Object) có cấu trúc y hệt JSON đó. Retrofit sẽ dùng thư viện Gson để “đổ” dữ liệu JSON vào “khuôn” này.

Giả sử API .../posts/1 trả về JSON:

{
  "userId": 1,
  "id": 1,
  "title": "sunt aut facere...",
  "body": "quia et suscipit..."
}

Chúng ta sẽ tạo class Post.java tương ứng:

// Post.java
public class Post {
    private int userId;
    private int id;
    private String title;
    private String body;

    // Getter (Bắt buộc để Gson có thể truy cập)
    public int getUserId() { return userId; }
    public int getId() { return id; }
    public String getTitle() { return title; }
    public String getBody() { return body; }
}

Bước 2: Tạo Interface Service

Đây là phần quan trọng nhất của Retrofit. Bạn định nghĩa một interface và dùng các Annotation để mô tả các API endpoint.

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

public interface ApiService {

    /** * Phân tích phương thức GET (Lấy danh sách)
     * @GET("posts") - Chỉ định phương thức HTTP là GET và phần đường dẫn (endpoint).
     * Call<List<Post>> - Chỉ định kiểu trả về là một "cuộc gọi" (Call) 
     * mà khi thành công sẽ chứa một List các đối tượng Post.
     */
    @GET("posts")
    Call<List<Post>> getAllPosts();

    /**
     * Phân tích phương thức GET (Lấy một đối tượng)
     * @Path("id") - Đánh dấu tham số 'id' (kiểu int) trong hàm
     * sẽ được thay thế vào phần {id} trong đường dẫn.
     * Ví dụ: getPostById(1) sẽ gọi tới "posts/1".
     */
    @GET("posts/{id}")
    Call<Post> getPostById(@Path("id") int postId);

    /**
     * Phân tích phương thức GET (với Query Param)
     * @Query("userId") - Đánh dấu tham số 'userId' (kiểu int) trong hàm
     * sẽ được thêm vào URL dưới dạng query parameter.
     * Ví dụ: getPostsByUserId(1) sẽ gọi tới "posts?userId=1".
     */
    @GET("posts")
    Call<List<Post>> getPostsByUserId(@Query("userId") int userId);

    /**
     * Phân tích phương thức POST (Tạo mới)
     * @POST("posts") - Chỉ định phương thức HTTP là POST.
     * @Body - Đánh dấu đối tượng 'post' (kiểu Post) trong hàm
     * sẽ được chuyển thành JSON và gửi đi trong Body của request.
     */
    @POST("posts")
    Call<Post> createPost(@Body Post post);
}

Bước 3: Tạo Retrofit Instance

Chúng ta cần tạo một đối tượng Retrofit duy nhất (Singleton Pattern được khuyến khích) để quản lý việc gọi API.

// RetrofitClient.java (Một class riêng để quản lý)
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;

public class RetrofitClient {

    private static Retrofit retrofitInstance = null;
    private static final String BASE_URL = "https://jsonplaceholder.typicode.com/";

    public static Retrofit getRetrofitInstance() {
        if (retrofitInstance == null) {
            retrofitInstance = new Retrofit.Builder()
                    // 1. Chỉ định Base URL (Phải có dấu / ở cuối)
                    .baseUrl(BASE_URL) 
                    
                    // 2. Chỉ định Converter Factory (để biến JSON thành Object)
                    .addConverterFactory(GsonConverterFactory.create()) 
                    
                    // 3. Xây dựng
                    .build();
        }
        return retrofitInstance;
    }
}

Bước 4: Thực hiện cuộc gọi (Call API)

Bây giờ, tại MainActivity.java (hoặc bất cứ đâu), bạn có thể gọi API:

// Trong MainActivity.java

// 1. Tạo service từ Retrofit instance
ApiService apiService = RetrofitClient.getRetrofitInstance().create(ApiService.class);

// 2. Gọi phương thức bạn muốn (ví dụ: lấy post có ID = 1)
Call<Post> call = apiService.getPostById(1);

// 3. Thực thi cuộc gọi BẤT ĐỒNG BỘ (Asynchronously)
// .enqueue() sẽ chạy trên một luồng nền, không làm treo UI
call.enqueue(new Callback<Post>() {
    
    /**
     * Phân tích phương thức onResponse
     * Được gọi khi API trả về phản hồi (kể cả lỗi 404, 500...)
     */
    @Override
    public void onResponse(Call<Post> call, Response<Post> response) {
        if (response.isSuccessful()) {
            // HTTP 200-299 (Thành công)
            Post post = response.body(); // Lấy đối tượng Post đã được Gson tự động parse
            Log.d("Retrofit_Success", "Tiêu đề: " + post.getTitle());
        } else {
            // Lỗi từ server (4xx, 5xx)
            Log.e("Retrofit_Error", "Code: " + response.code());
        }
    }

    /**
     * Phân tích phương thức onFailure
     * Được gọi khi có lỗi MẠNG (mất kết nối, sai domain...)
     */
    @Override
    public void onFailure(Call<Post> call, Throwable t) {
        Log.e("Retrofit_Failure", "Lỗi: " + t.getMessage());
    }
});

PHÂN TÍCH

Annotations & Dynamic Proxy

Đây là phần “tại sao” mà các em cần hiểu. Khi các em viết một interface, các em không viết code thực thi. Vậy Retrofit làm gì?

**** Annotations (Chú thích) là gì?

Hãy nhìn vào một hàm trong interface của Retrofit:

@GET("posts/{id}")
Call<Post> getPostById(@Path("id") int postId);
  • @GET, @Path được gọi là Annotations.
  • Bản thân chúng KHÔNG LÀM GÌ CẢ. Chúng không phải là code. Chúng chỉ là các “nhãn dán” (labels) hay “siêu dữ liệu” (metadata).
  • @GET("posts/{id}") là một cái nhãn dán lên hàm getPostById và nói rằng: “Này, hàm này muốn thực hiện một HTTP GET tới đường dẫn posts/{id}.”
  • @Path("id") là cái nhãn dán lên tham số postId và nói rằng: “Này, hãy lấy giá trị của tham số postId này và nhét nó vào cái lỗ {id} trên đường dẫn.”

Chúng chỉ là các “chỉ dẫn” (instructions) được viết sẵn.

Retrofit “Implement” (Hiện thực hóa) Interface như thế nào?

Đây là lúc “phép thuật” xảy ra, tại dòng code này:

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

Khi các em gọi hàm .create(), Retrofit làm 2 việc chính:

  1. Dùng Reflection (Phản chiếu): Retrofit dùng một công cụ của Java gọi là “Reflection” để “soi” ApiService.interface của các em. Nó đọc tất cả các “nhãn dán” (Annotations) mà các em đã đính vào (Nó thấy hàm getPostById có nhãn @GET và @Path).
  2. Tạo Dynamic Proxy (Proxy động): Dựa trên những gì “soi” được, Retrofit tự động sinh ra một đối tượng ngay trong bộ nhớ (RAM). Đối tượng này giả vờ là một ApiService. Giới kỹ thuật gọi nó là Proxy động.

Cái đối tượng Proxy này đã được “dạy” (từ lúc “soi” ở bước 1) rằng:

“Khi người dùng gọi hàm getPostById(1) trên TÔI (cái Proxy này), TÔI phải:

  1. Nhìn vào các “nhãn dán” của hàm đó.
  2. Thấy nhãn @GET và đường dẫn posts/{id}.
  3. Thấy nhãn @Path("id") trên tham số số 1.
  4. Tự động xây dựng URL: Lấy BASE_URL + posts/ + 1.
  5. Tự động tạo một OkHttp Request (thư viện chạy ngầm bên dưới Retrofit) với phương thức GET và URL vừa tạo.
  6. Gửi request đi.
  7. Khi nhận được JSON về, tự động dùng GsonConverter (đã khai báo) để biến JSON đó thành Post.class.
  8. Trả kết quả về.”

Đó là lý do interface là bắt buộc. Nó chính là bản thiết kế để Retrofit dùng Reflection “soi” và tạo ra Proxy động.


Phần 2: Khai thác API với Volley

Volley hoạt động khác Retrofit. Nó không dùng interface hay tự động parse JSON. Bạn sẽ tạo các đối tượng Request (yêu cầu) và thêm chúng vào một RequestQueue (hàng đợi).

Bước 1: Tạo RequestQueue

Volley cần một “hàng đợi” để quản lý các request. Bạn nên tạo một đối tượng Singleton cho nó.

// Trong MainActivity.java hoặc Application Class
RequestQueue requestQueue = Volley.newRequestQueue(this);

Bước 2: Thực hiện cuộc gọi GET (Lấy JSONObject)

Volley không tự động “đổ” JSON vào POJO. Bạn phải yêu cầu JsonObjectRequest (nếu trả về 1 đối tượng) hoặc JsonArrayRequest (nếu trả về 1 danh sách) và tự phân tích nó.

// Trong MainActivity.java
String url = "https://jsonplaceholder.typicode.com/posts/1";

JsonObjectRequest jsonObjectRequest = new JsonObjectRequest(
        // 1. Phân tích phương thức: Request.Method.GET
        Request.Method.GET,
        
        // 2. URL đầy đủ
        url,
        
        // 3. Request Body (null vì đây là GET)
        null, 
        
        // 4. Phân tích Listener (Khi thành công)
        new Response.Listener<JSONObject>() {
            @Override
            public void onResponse(JSONObject response) {
                try {
                    // Phải tự parse JSON thủ công
                    int id = response.getInt("id");
                    String title = response.getString("title");
                    Log.d("Volley_Success", "ID: " + id + ", Tiêu đề: " + title);
                    
                    // Bạn có thể tự tạo đối tượng Post từ đây
                    // Post post = new Post(id, title, ...);
                    
                } catch (JSONException e) {
                    e.printStackTrace();
                }
            }
        },
        
        // 5. Phân tích ErrorListener (Khi thất bại)
        new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Log.e("Volley_Error", "Lỗi: " + error.getMessage());
            }
        }
);

// 6. Thêm request vào hàng đợi để thực thi
requestQueue.add(jsonObjectRequest);

Bước 3: Thực hiện cuộc gọi POST (Gửi JSONObject)

Để POST dữ liệu, bạn cần tự tạo một JSONObject để gửi đi trong request body.

// Trong MainActivity.java
String url = "https://jsonplaceholder.typicode.com/posts";

// 1. Tạo body JSON để gửi đi
JSONObject postBody = new JSONObject();
try {
    postBody.put("title", "Bài viết mới từ Tiilaz");
    postBody.put("body", "Nội dung bài viết bằng Volley.");
    postBody.put("userId", 10);
} catch (JSONException e) {
    e.printStackTrace();
}

JsonObjectRequest postRequest = new JsonObjectRequest(
        // 1. Phương thức POST
        Request.Method.POST,
        url,
        // 2. Request Body (chính là JSONObject bạn vừa tạo)
        postBody,
        
        // 3. Listener (Thành công)
        new Response.Listener<JSONObject>() {
            @Override
            public void onResponse(JSONObject response) {
                // Server (API giả) sẽ trả về dữ liệu bạn vừa POST
                Log.d("Volley_POST_Success", "Response: " + response.toString());
            }
        }, 
        
        // 4. ErrorListener (Thất bại)
        new Response.ErrorListener() {
            @Override
            public void onErrorResponse(VolleyError error) {
                Log.e("Volley_POST_Error", "Lỗi: " + error.getMessage());
            }
        }
);

// 5. Thêm request vào hàng đợi
requestQueue.add(postRequest);

Chọn Retrofit hay Volley?

Như bạn thấy, cả hai thư viện đều giúp bạn gọi API, nhưng cách tiếp cận rất khác nhau:

  • Retrofit giống như một nhà hàng 5 sao. Bạn chỉ cần định nghĩa “thực đơn” (Interface), “khuôn thức ăn” (Model), Retrofit sẽ lo toàn bộ việc “nấu nướng” (gọi API) và “dọn ra bàn” (parse JSON) cho bạn.
    • Ưu điểm: Code rất sạch sẽ, an toàn (type-safe), tự động parse JSON, là tiêu chuẩn của ngành.
    • Nhược điểm: Cần cài đặt ban đầu (Model, Interface) hơi nhiều bước hơn.
  • Volley giống như một quầy thức ăn nhanh. Nó nhanh, đơn giản cho các yêu cầu “bắn và quên” (fire-and-forget).
    • Ưu điểm: Dễ dùng cho các request đơn giản, quản lý hàng đợi và cache tốt.
    • Nhược điểm: Bạn phải tự phân tích JSON (dễ gõ sai tên key, dễ gây JSONException), code dài dòng và rườm rà hơn khi làm việc với nhiều API phức tạp.

Comments are closed.