1. Vấn đề và Giải pháp
- Vấn đề: Ứng dụng của chúng ta cần hiển thị dữ liệu (tin tức, sản phẩm, thời tiết…) từ một máy chủ (server). Dùng các công cụ Android/Java cũ (như
AsyncTask,HttpURLConnection) rất phức tạp, khó quản lý luồng, và phải tự xử lý JSON. - Giải pháp: Chúng ta dùng Retrofit. Đây là thư viện “tiêu chuẩn vàng” (industry-standard) của Square. Nó giúp chúng ta biến một API phức tạp thành một hàm (method) Java đơn giản.
2. Cài đặt ban đầu (Setup)
Trước khi bắt đầu, “phòng lab” của chúng ta cần 2 thứ:
(1). Cấp quyền Internet: Mở AndroidManifest.xml, thêm vào trên thẻ <application>:
<uses-permission android:name="android.permission.INTERNET" />
(2). thêm thư viện: Mở build.gradle (Module: app), thêm 2 dòng sau vào dependencies:
// 1. Thư viện Retrofit chính
implementation 'com.squareup.retrofit2:retrofit:2.9.0'
// 2. Thư viện "dịch" (Converter) JSON sang Java
implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
Nhấn Sync Now. (Chúng ta sẽ dùng API thực hành từ https://jsonplaceholder.typicode.com/)
3. Hướng dẫn 4 Bước để gọi API
Để gọi một API bằng Retrofit, chúng ta luôn luôn tuân theo 4 bước. Thầy sẽ gọi đây là “Bản đồ 4 bước”:
- Bước 1: Model (POJO) – “Cái khuôn” để hứng JSON.
- Bước 2: Interface – “Bản hợp đồng” mô tả API.
- Bước 3: Client – “Nhà máy” Retrofit.
- Bước 4: Call – “Gọi” và thực thi.
4. Bước 1: Tạo Model (POJO) – “Cái khuôn”
- Mục đích: API trả về dữ liệu dạng JSON. Chúng ta cần một lớp Java (gọi là POJO) có cấu trúc y hệt để “hứng” dữ liệu đó. Thư viện
Gson(chúng ta đã thêm) sẽ tự động “đổ” JSON vào “khuôn” này. - Ví dụ: API
.../posts/1trả về JSON:
{
"userId": 1,
"id": 1,
"title": "sunt aut facere...",
"body": "quia et suscipit..."
}
Thực hành: Tạo class Post.java.
// Post.java
import com.google.gson.annotations.SerializedName;
public class Post {
// Dùng @SerializedName để "ánh xạ" (map)
// nếu tên biến Java (vd: postTitle) khác tên key JSON (vd: "title")
// Nếu tên giống hệt, ta không cần annotation này.
@SerializedName("userId")
private int userId;
@SerializedName("id")
private int id;
private String title;
private String body;
// Cần có Getter để Gson/Retrofit truy cập và gán dữ liệu
public int getUserId() { return userId; }
public int getId() { return id; }
public String getTitle() { return title; }
public String getBody() { return body; }
}
5. Bước 2: Tạo Interface – “Bản hợp đồng” API
- Mục đích: Đây là trái tim của Retrofit. Chúng ta sẽ định nghĩa tất cả các API chúng ta cần gọi trong một
interface. - Tại sao là
interface? Vì đây là một “bản hợp đồng” (contract). Chúng ta chỉ mô tả những gì chúng ta muốn, chứ không thực thi. Retrofit sẽ tự động “đọc” bản hợp đồng này và tự “viết code” thực thi ngầm cho chúng ta. - Giải thích Annotations (Chú thích):
- Annotations (
@GET,@POST,@Path…) là các “chỉ dẫn” (instructions). Chúng ta dùng chúng để “chú thích” lên các hàm tronginterfaceđể Retrofit biết phải làm gì.
- Annotations (
- Thực hành: Tạo
interface ApiService.java.
// 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 {
// --- NHÓM 1: LẤY DỮ LIỆU (GET) ---
/**
* @GET: Chỉ dẫn đây là phương thức HTTP GET.
* ("posts/{id}"): Đường dẫn. {id} là một "biến" (placeholder)
*
* @Path("id"): Chỉ dẫn: "Hãy lấy giá trị của tham số 'postId'
* và thay nó vào biến {id} trên đường dẫn."
*
* Call<Post>: Kiểu trả về. "Một lời gọi" mà khi thành công
* sẽ trả về 1 đối tượng "Post" (từ Bước 1).
*/
@GET("posts/{id}")
Call<Post> getPostById(@Path("id") int postId);
/**
* Lấy một danh sách
*/
@GET("posts")
Call<List<Post>> getAllPosts();
/**
* @Query("userId"): Chỉ dẫn: "Hãy thêm tham số này vào
* cuối URL dưới dạng ?userId=... (dùng để lọc/filter)"
* VD: Gọi hàm này với userId=1 -> Retrofit sẽ gọi URL: ".../posts?userId=1"
*/
@GET("posts")
Call<List<Post>> getPostsOfUser(@Query("userId") int userId);
// --- NHÓM 2: GỬI DỮ LIỆU (POST) ---
/**
* @POST: Chỉ dẫn đây là phương thức HTTP POST.
*
* @Body: Chỉ dẫn: "Hãy lấy toàn bộ đối tượng 'newPost'
* (Gson sẽ biến nó thành JSON) và đặt nó vào 'thân' (body)
* của request để gửi đi."
*/
@POST("posts")
Call<Post> createPost(@Body Post newPost);
}
6. Bước 3: Tạo “Nhà máy” (Retrofit Client)
- Mục đích: Tạo một đối tượng Retrofit trung tâm. Đây là “nhà máy” sẽ “sản xuất” ra các “dịch vụ” (service) dựa trên “bản hợp đồng” (interface) ở Bước 2. Chúng ta chỉ cần tạo 1 “nhà máy” và dùng chung (Singleton Pattern).
- Thực hành: Tạo class
RetrofitClient.java.
// RetrofitClient.java
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
public class RetrofitClient {
private static Retrofit retrofitInstance = null;
// 1. Đây là địa chỉ GỐC của API
private static final String BASE_URL = "https://jsonplaceholder.typicode.com/";
public static Retrofit getRetrofitInstance() {
if (retrofitInstance == null) {
// Khởi tạo Retrofit
retrofitInstance = new Retrofit.Builder()
// 2. Chỉ định địa chỉ GỐC
.baseUrl(BASE_URL)
// 3. Chỉ định "công cụ dịch" (Converter)
// Chúng ta nói Retrofit: "Hãy dùng GSON để
// dịch JSON sang POJO (Bước 1)"
.addConverterFactory(GsonConverterFactory.create())
// 4. Xây dựng "Nhà máy"
.build();
}
return retrofitInstance;
}
}
7. Bước 4. Thực thi (Making the Call)
Code ở đây…
8. TÓM TẮT
Chúng ta đã hoàn thành 4 bước để gọi API bằng Retrofit:
- Model (POJO): Tạo “khuôn” Java (ví dụ:
Post.java) để hứng JSON. - Interface: Tạo “bản hợp đồng” (
ApiService.java) và dùng Annotations (@GET,@Path…) để mô tả API. - Client: Tạo “nhà máy” (
RetrofitClient.java) để cấu hìnhbaseUrlvàConverter. - Call: Dùng
retrofit.create()để lấy dịch vụ vàcall.enqueue()để thực thi bất đồng bộ.
MỞ RỘNG 1: Retrofit lấy về một danh sách (một mảng) dữ liệu
Trong thực tế, chúng ta thường xuyên cần lấy về một danh sách (một mảng) dữ liệu, chứ không chỉ một đối tượng đơn lẻ.
Ví dụ: Lấy tất cả bài viết, tất cả sản phẩm, tất cả bình luận.
Sửa Bước 4: Thực thi (Making the Call)
- Thay đổi nhỏ: Kiểu dữ liệu trong Callback.
- Vì chúng ta yêu cầu một
List<Post>, nênCallbackcũng phải làCallback<List<Post>>.
Hãy xem cách gọi trong MainActivity.java:
// Trong MainActivity.java
// 1. Lấy "Nhà máy" và "Dịch vụ" (Không đổi)
Retrofit retrofit = RetrofitClient.getRetrofitInstance();
ApiService apiService = retrofit.create(ApiService.class);
// 3. "Gọi món" (Gọi hàm mới)
// Kiểu dữ liệu của 'call' bây giờ là Call<List<Post>>
Call<List<Post>> call = apiService.getAllPosts();
// 4. Thực thi (Callback cũng phải là List<Post>)
call.enqueue(new Callback<List<Post>>() {
/**
* onResponse bây giờ trả về một Response<List<Post>>
*/
@Override
public void onResponse(Call<List<Post>> call, Response<List<Post>> response) {
if (response.isSuccessful()) {
// "Món ăn" của chúng ta bâyNDAY LÀ MỘT DANH SÁCH!
List<Post> posts = response.body();
if (posts != null) {
Log.d("Retrofit_List_Success", "Đã lấy được: " + posts.size() + " bài viết.");
// Chúng ta có thể duyệt qua danh sách này
for (Post post : posts) {
Log.d("Retrofit_List_Item", "Tiêu đề: " + post.getTitle());
}
// TODO: Ở bài học sau, đây chính là danh sách
// (posts) mà chúng ta sẽ đưa cho RecyclerView Adapter
// để hiển thị lên giao diện.
}
} else {
Log.e("Retrofit_List_Error", "Code: " + response.code());
}
}
@Override
public void onFailure(Call<List<Post>> call, Throwable t) {
Log.e("Retrofit_List_Failure", "Lỗi: " + t.getMessage());
}
});
MỞ RỘNG 2: Bảo mật API – Gửi “Secret Key” (Token)
Mời xem bài tiếp theo
