Ở bài học trước, chúng ta đã học cách dùng Retrofit để GET (lấy) và POST (tạo) dữ liệu. Tuy nhiên, chúng ta đã làm việc với một API “giả” là jsonplaceholder, nơi mà ai cũng có thể GET, POST bài viết.
Trong thực tế, điều này là không thể. Các ứng dụng như Shopee, Facebook… không thể cho phép bất kỳ ai cũng có quyền GET, đặc biệt là POST (tạo sản phẩm) hay DELETE (xóa bình luận).
Hầu hết các API quan trọng đều được bảo vệ. Chúng đòi hỏi chúng ta phải “chứng minh” mình là ai. Hôm nay, chúng ta sẽ học cách gửi “chìa khóa bí mật” (Secret Key), hay nói đúng hơn là Token Xác thực (Authentication Token), kèm theo các request của mình.
1. “Secret Key” được gửi ở đâu?
Chúng ta đặt “khóa” này ở đâu?
Chúng ta KHÔNG đặt nó vào bên trong “thân” (Body) của request (tức là không trộn nó vào đối tượng Post.java của chúng ta).
Thay vào đó, “khóa” được gửi trong một phần riêng biệt gọi là HTTP Header (Tiêu đề HTTP).
Cách phổ biến nhất hiện nay là gửi một Header có tên là Authorization (Ủy quyền). Giá trị của nó thường bắt đầu bằng Bearer, theo sau là một chuỗi Token rất dài mà máy chủ cấp cho chúng ta sau khi đăng nhập.
Ví dụ một HTTP Header:
GET /api/posts/1 HTTP/1.1
Host: tiilaz.com
Accept: application/json
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIx...
Nhiệm vụ của chúng ta là: Làm thế nào để “gắn” cái Header Authorization này vào request trong Retrofit?
Có 2 cách: Cách thủ công (dễ hiểu) và cách tự động (chuyên nghiệp).
2. Cách 1: Dùng @Header (Thêm thủ công)
Đây là cách đơn giản nhất. Chúng ta sẽ “dán nhãn” (Annotation) @Header vào tham số của phương thức trong ApiService.
2.1 Cập nhật ApiService.java
// ApiService.java
import retrofit2.Call;
import retrofit2.http.Body;
import retrofit2.http.Header; // <-- Thêm import này
import retrofit2.http.POST;
public interface ApiService {
/**
* @Header("Authorization") String token:
* Đây là "chỉ dẫn" mới.
* Nó báo Retrofit: "Hãy lấy giá trị của biến 'token' (là một String)
* và đặt nó vào một Header có tên là 'Authorization'"
*/
@POST("posts")
Call<Post> createPost(
@Header("Authorization") String token,
@Body Post newPost
);
// Tương tự, nếu API yêu cầu một khóa tên là "x-api-key":
@POST("posts")
Call<Post> createPostWithApiKey(
@Header("x-api-key") String apiKey,
@Body Post newPost
);
}
2.2 Cập nhật MainActivity.java
Khi gọi, chúng ta phải truyền chuỗi token này vào:
// Trong MainActivity.java
// Giả sử em đã có token sau khi người dùng đăng nhập
String myToken = "Bearer eyJhbGciOiJIUzI1Ni...";
Post myPost = new Post(...); // Tạo đối tượng Post như bình thường
// 3. "Gọi món" - Bây giờ phải truyền 2 tham số
Call<Post> call = apiService.createPost(myToken, myPost);
// 4. Thực thi (giống hệt)
call.enqueue(new Callback<Post>() { ... });
Ưu điểm: Dễ hiểu, rõ ràng, nhìn vào là biết ngay hàm này cần token.
Nhược điểm: Rất phiền phức và lặp lại code (repetitive). Nếu ứng dụng của em có 50 API cần bảo vệ, em sẽ phải thêm tham số String token vào cả 50 phương thức trong ApiService. Giao diện (Interface) của em sẽ bị “bẩn”.
3. Cách 2: Dùng OkHttp Interceptor
Đây là cách mà 99% các lập trình viên chuyên nghiệp sử dụng.
- Tư duy: Chúng ta sẽ tạo ra một “Trạm kiểm soát” (Interceptor). MỌI request đi ra từ ứng dụng của chúng ta (kể cả
GEThayPOST) đều bắt buộc phải đi qua trạm này. Tại đây, chúng ta sẽ tự động “đóng dấu” (thêm HeaderAuthorization) vào request trước khi nó được gửi đi. - Lưu ý: Retrofit chạy ngầm trên một thư viện tên là
OkHttp. “Trạm kiểm soát” Interceptor này là một tính năng củaOkHttp.
Chúng ta sẽ nâng cấp “Nhà bếp” (RetrofitClient) của mình.
3.1 Cập nhật RetrofitClient.java
File này sẽ phức tạp hơn một chút, nhưng chúng ta chỉ làm một lần duy nhất.
// RetrofitClient.java
// Thêm các import của OkHttp
import okhttp3.Interceptor;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
import java.io.IOException;
public class RetrofitClient {
private static Retrofit retrofitInstance = null;
private static final String BASE_URL = "https://jsonplaceholder.typicode.com/";
// Giả sử em đã lưu Token sau khi đăng nhập
// (Trong app thật, em sẽ đọc từ SharedPreferences)
private static final String AUTH_TOKEN = "Bearer eyJhbGciOiJIUzI1Ni...";
public static Retrofit getRetrofitInstance() {
if (retrofitInstance == null) {
// --- BƯỚC NÂNG CẤP BẮT ĐẦU TỪ ĐÂY ---
// 1. Tạo một OkHttp Client Builder
OkHttpClient.Builder httpClient = new OkHttpClient.Builder();
// 2. Tạo một Interceptor (Trạm kiểm soát)
httpClient.addInterceptor(new Interceptor() {
@Override
public Response intercept(Chain chain) throws IOException {
// Lấy request gốc (chưa có Header)
Request original = chain.request();
// Xây dựng request mới
Request.Builder requestBuilder = original.newBuilder()
// ĐÓNG DẤU: Tự động thêm Header Authorization
.header("Authorization", AUTH_TOKEN)
.header("Accept", "application/json") // Có thể thêm các header chung khác
.method(original.method(), original.body());
Request request = requestBuilder.build();
// Gửi request mới (đã có Header) đi
return chain.proceed(request);
}
});
// 3. Build OkHttp Client
OkHttpClient client = httpClient.build();
// --- KẾT THÚC NÂNG CẤP ---
// 4. Khởi tạo Retrofit
retrofitInstance = new Retrofit.Builder()
.baseUrl(BASE_URL)
.addConverterFactory(GsonConverterFactory.create())
// 5. GẮN OkHttp Client đã nâng cấp vào Retrofit
// Từ giờ, Retrofit sẽ dùng "nhà bếp" đã có "trạm kiểm soát"
.client(client)
.build();
}
return retrofitInstance;
}
}
3.2 “Dọn dẹp” ApiService.java
Vì “Trạm kiểm soát” đã tự động thêm Header, “Thực đơn” (Interface) của chúng ta trở nên SẠCH SẼ y như lúc đầu.
// ApiService.java
public interface ApiService {
// Sạch sẽ, không cần tham số "token"
@POST("posts")
Call<Post> createPost(@Body Post newPost);
// Hàm GET cũng tự động được thêm Header (nếu cần)
@GET("posts/{id}")
Call<Post> getPostById(@Path("id") int postId);
}
3.3 MainActivity.java trở nên đơn giản
Cách gọi POST của em bây giờ cũng SẠCH SẼ y như cũ.
// Trong MainActivity.java
Post myPost = new Post(...); // Tạo đối tượng Post
// 3. "Gọi món" - Không cần truyền token nữa
Call<Post> call = apiService.createPost(myPost);
// 4. Thực thi (giống hệt)
call.enqueue(new Callback<Post>() { ... });
Tổng kết
Chúng ta đã học 2 cách để gửi “Secret Key” khi POST dữ liệu:
- Cách 1:
@Header: Nhanh, dễ, nhưng làm “bẩn” code nếu dùng nhiều. Phù hợp khi em chỉ có 1-2 API cần Header đặc biệt. - Cách 2:
OkHttp Interceptor: Cài đặt ban đầu phức tạp hơn (ởRetrofitClient), nhưng là cách làm chuẩn mực và sạch sẽ nhất. Nó giúp tách biệt logic:ApiServicechỉ lo “gọi món gì”, cònInterceptorlo “giấy tờ/xác thực”.
Lời khuyên: Hãy luôn sử dụng Cách 2 (Interceptor) cho việc xác thực (Authentication). Nó giúp code của các em chuyên nghiệp, dễ bảo trì và mở rộng hơn rất nhiều.
