REST vs GraphQL trong iOS: Làm Thế Nào Để Tiêu Thụ API Hiệu Quả

REST vs GraphQL trong iOS không phải cuộc thi xem giao thức nào hiện đại hơn. Bạn cần chọn cách mô hình hóa dữ liệu, caching, lỗi và quyền truy cập phù hợp với màn hình, backend và chất lượng mạng mà ứng dụng phải chịu.

Cập nhật 2026

  • Bài viết này dùng ngữ cảnh Swift 6.4 và Xcode 27.2; ví dụ REST ưu tiên URLSession với async/await, không dùng completion handler cũ.
  • REST vẫn có lợi thế thực tế nhờ semantics của HTTP: status code, cache validator, conditional request và upload file đã được chuẩn hóa.
  • GraphQL vẫn mạnh cho màn hình cần dữ liệu liên kết, nhưng schema, code generation, client cache và giới hạn query là trách nhiệm vận hành, không phải phép màu tự động giải quyết mọi request.

REST và GraphQL khác nhau ở mô hình nào?

REST tổ chức API quanh resource. Một URL đại diện cho tài nguyên và method HTTP mô tả thao tác: GET /users/42 đọc user, POST /orders tạo order, PATCH /profiles/42 cập nhật một phần, còn DELETE /sessions/current kết thúc phiên. Client nhận representation, thường là JSON, theo hợp đồng do server định nghĩa.

Điểm quan trọng của REST không chỉ là “nhiều endpoint”. HTTP đã cung cấp ngữ nghĩa có ích: 200 cho thành công, 201 khi tạo resource, 204 khi thành công nhưng không có body, 401 khi thiếu hoặc sai xác thực, 403 khi không đủ quyền, 404 khi không tìm thấy, 409 cho xung đột và 429 khi bị giới hạn tốc độ. Proxy, CDN và URLCache có thể dựa vào Cache-Control, ETag, Last-Modified và request If-None-Match để tránh tải lại dữ liệu.

GraphQL tổ chức API quanh một schema có type, field, argument và quan hệ. Client gửi operation đến một endpoint, thường là /graphql, rồi khai báo đúng các field cần nhận. Query dùng để đọc, mutation để ghi, subscription để nhận sự kiện theo thời gian thực qua cơ chế transport mà server hỗ trợ. Một endpoint không có nghĩa chỉ có một loại nghiệp vụ; schema vẫn là một bề mặt API lớn cần thiết kế và bảo vệ.

Over-fetching, under-fetching và codegen

Với REST, over-fetching xảy ra khi /users/42 trả cả email, địa chỉ và lịch sử hoạt động trong khi màn hình chỉ cần tên và avatar. Under-fetching xảy ra khi một màn hình phải gọi user, posts, comments và reactions bằng nhiều request. Nhiều request không tự động là lỗi, nhưng sẽ làm tăng latency, trạng thái loading và khả năng lỗi giữa chừng.

GraphQL cho phép query lồng nhau để lấy một shape dữ liệu trong một request. Điều đó giảm over-fetching ở phía client, nhưng không loại bỏ chi phí: server phải resolve từng field, kiểm soát độ sâu và tránh N+1 query ở tầng dữ liệu. Query càng linh hoạt thì cache càng khó định danh. Trong REST, URL và method thường là cache key tự nhiên; trong GraphQL, cùng một resource có thể xuất hiện qua nhiều operation hoặc variables khác nhau.

Schema GraphQL cũng là đầu vào tốt cho typed code generation. Từ schema và các file operation, công cụ client có thể sinh ra kiểu Swift theo đúng field bạn yêu cầu. Bạn được kiểm tra nhiều lỗi ở build time thay vì tự viết nhiều struct JSON. Tuy nhiên, codegen cần được chạy trong CI, schema phải được version hóa, và thay đổi breaking phải được phát hiện trước khi app phát hành.

Tiêu thụ REST trong iOS bằng URLSession

Với request đọc đơn giản, URLSession và Codable là đủ. Code dưới đây tách ba nhóm lỗi: lỗi transport khi request không hoàn tất, lỗi HTTP khi server trả status ngoài 2xx, và lỗi decode khi payload không khớp hợp đồng. API thật nên bổ sung logging có redaction và policy retry ở một tầng riêng.

import Foundation

struct User: Codable, Sendable {
    let id: Int
    let name: String
    let avatarURL: URL?

    enum CodingKeys: String, CodingKey {
        case id, name
        case avatarURL = "avatar_url"
    }
}

enum APIError: Error {
    case invalidResponse
    case http(status: Int, body: Data)
    case decoding(DecodingError)
}

func fetchUsers(from url: URL) async throws -> [User] {
    var request = URLRequest(url: url)
    request.httpMethod = "GET"
    request.setValue("application/json", forHTTPHeaderField: "Accept")

    let data: Data
    let response: URLResponse
    do {
        (data, response) = try await URLSession.shared.data(for: request)
    } catch {
        // DNS, timeout, cancellation and connection failures are transport errors.
        throw error
    }

    guard let http = response as? HTTPURLResponse else {
        throw APIError.invalidResponse
    }
    guard (200...299).contains(http.statusCode) else {
        throw APIError.http(status: http.statusCode, body: data)
    }

    do {
        return try JSONDecoder().decode([User].self, from: data)
    } catch let error as DecodingError {
        throw APIError.decoding(error)
    }
}

Trong production, repository nên nhận một URLSession hoặc transport protocol để test bằng session giả. Đừng coi mọi response là thành công chỉ vì có body JSON: status 401 cần refresh hoặc đăng nhập lại, 429 cần tôn trọng Retry-After, còn 409 thường cần hiển thị xung đột thay vì gửi lại mù quáng.

Đọc thêm nền tảng về URLSession trong iOS trước khi xây repository nhiều endpoint. Nếu dự án đã dùng một abstraction như Alamofire, hãy thống nhất policy ở đó; không trộn hai kiểu xử lý lỗi trong cùng feature chỉ vì một request ngắn hơn.

GraphQL trên iOS: schema, operation và client

Một operation GraphQL mô tả rõ shape dữ liệu:

query UserScreen($id: ID!, $cursor: String) {
    user(id: $id) {
        id
        name
        avatarURL
        posts(first: 20, after: $cursor) {
            nodes { id title }
            pageInfo { hasNextPage endCursor }
        }
    }
}

Đoạn trên là tài liệu operation, không phải Swift. Với một client GraphQL có code generation, bạn khai báo operation trong file .graphql, chạy generator từ schema, rồi gọi operation đã sinh. Cú pháp khởi tạo client, cache policy và tên kiểu có thể thay đổi theo thư viện, nên không nên pin một phiên bản Apollo Swift trong bài hướng dẫn tổng quát này. Mẫu khái niệm sau chỉ nhấn mạnh các điểm cần kiểm tra:

// Conceptual Apollo-style API; generated types and method names depend on your client setup.
let operation = UserScreenQuery(id: userID, cursor: cursor)

client.fetch(operation, cachePolicy: .returnCacheDataElseFetch) { result in
    switch result {
    case .success(let response):
        if let user = response.data?.user {
            render(user)
        }
        // Inspect response.errors even when response.data is partially present.
    case .failure(let error):
        showTransportOrParsingError(error)
    }
}

GraphQL response có thể đồng thời chứa data và errors. Vì vậy, đừng chỉ kiểm tra request có thành công ở tầng network rồi render toàn bộ data. Field không nullable bị lỗi có thể khiến cả nhánh cha thành null; field nullable khác vẫn dùng được. UI phải quyết định có hiển thị dữ liệu một phần hay báo lỗi toàn màn hình.

Mutation cần được xem như thao tác ghi có side effect. Payload nên trả về đủ dữ liệu để cập nhật cache, server nên hỗ trợ idempotency key cho thao tác có thể retry, và app không được tự động retry mutation chỉ vì connection rớt. Subscription phù hợp cho chat, trạng thái giao dịch hoặc thông báo cần realtime; nó kéo theo reconnect, authentication khi mở lại socket, backpressure và vòng đời task, không phải lựa chọn mặc định cho mọi màn hình.

Những phần phải thiết kế ở cả hai lựa chọn

Phân loại lỗi

Transport error là timeout, mất mạng, DNS, cancellation hoặc TLS failure; có thể cho phép retry có backoff nếu request an toàn. HTTP error là status ngoài 2xx. Với GraphQL, HTTP 200 vẫn có thể chứa lỗi trong mảng errors, nên cần thêm domain/GraphQL error: quyền bị từ chối, input không hợp lệ, resource đã bị xóa hoặc invariant nghiệp vụ bị vi phạm.

Đưa các lỗi này về một enum nội bộ giúp ViewModel không phải biết response đến từ REST hay GraphQL. Log nên có operation hoặc endpoint, status, request ID, latency và mã lỗi nghiệp vụ; tuyệt đối không ghi token, cookie, email đầy đủ hay query variables nhạy cảm. Observability của GraphQL cần thêm tên operation, độ sâu, complexity và field resolver chậm, thay vì chỉ gom mọi traffic vào một nhãn POST /graphql.

Pagination, cache offline và retry

REST thường dùng page/limit hoặc cursor trong query string; GraphQL thường đưa first/after và pageInfo vào schema. Cursor ổn định hơn offset khi dữ liệu thay đổi, nhưng client phải chống trùng item, lưu cursor theo filter và xử lý cursor hết hạn.

Offline-first nên có local store làm nguồn đọc, kèm timestamp, trạng thái stale và chiến lược merge. REST có thể tận dụng ETag và response cache HTTP; GraphQL thường cần normalized cache hoặc persistence do client quản lý. Đừng cache access token cùng cache dữ liệu, và đừng xem dữ liệu trong cache là bằng chứng người dùng còn được quyền xem.

Retry nên giới hạn số lần, dùng exponential backoff có jitter và chỉ áp dụng cho lỗi tạm thời. GET thường an toàn để retry; POST tạo resource, REST mutation và GraphQL mutation cần idempotency key hoặc xác nhận rõ trạng thái trước khi gửi lại. Cancellation của task khi người dùng rời màn hình cũng quan trọng như retry.

Auth, upload và bảo mật

Gắn access token qua Authorization: Bearer ở transport layer, lưu credential nhạy cảm trong Keychain và làm mới token khi server báo hết hạn. File upload thường tự nhiên hơn với REST bằng multipart/form-data hoặc signed upload URL. GraphQL có thể hỗ trợ multipart convention hoặc trả signed URL, nhưng đó là năng lực của server/client cụ thể, không phải đặc tính bắt buộc của GraphQL.

Với GraphQL, giới hạn query depth, complexity, số node và timeout ở gateway. Tắt introspection trong môi trường production khi mô hình triển khai cho phép, hoặc bảo vệ nó bằng quyền riêng; đừng coi việc ẩn schema là thay thế authorization. Authorization phải kiểm tra ở resolver/service cho từng resource, không chỉ ở endpoint /graphql. REST cũng cần chống IDOR, validate input, TLS và phân quyền theo resource.

Bảng quyết định: REST, GraphQL hay hybrid?

Lựa chọn Khi nào thắng Điểm phải trả
REST CRUD rõ ràng, file upload, webhook, public API, cần HTTP caching/status code và tooling đơn giản. Màn hình aggregate có thể phải gọi nhiều endpoint; schema response ít linh hoạt hơn.
GraphQL Màn hình cần nhiều resource liên quan, nhiều client có nhu cầu shape khác nhau, muốn typed codegen hoặc realtime có kiểm soát. Cache, observability, query cost, partial errors và vận hành schema phức tạp hơn.
Hybrid REST cho upload, download, health/webhook và resource ổn định; GraphQL cho read model hoặc dashboard aggregate. Hai auth/cache/error policy; phải giữ naming, telemetry và tài liệu nhất quán.

Chọn REST nếu backend đã ổn định và bài toán chủ yếu là resource độc lập. Chọn GraphQL khi chi phí ghép dữ liệu ở client lặp lại trên nhiều màn hình và team kiểm soát được schema lẫn gateway. Chọn hybrid khi mỗi giao thức giải quyết một loại traffic tốt hơn; đừng thêm GraphQL chỉ để tránh viết hai request đơn giản.

Pitfall thường gặp

  • Parse partial GraphQL errors như thể response luôn all-or-nothing: hãy giữ data dùng được và đánh dấu phần hỏng.
  • Để resolver tạo N+1 query: dùng batching/data loader ở server và đo query thực tế, không chỉ đo số HTTP request.
  • Cho phép query cực lớn hoặc depth không giới hạn: đặt complexity budget, timeout, pagination bắt buộc và giới hạn list.
  • Bỏ qua HTTP semantics trong REST hoặc GraphQL: status, cache headers, Retry-After và request ID vẫn là tín hiệu vận hành quan trọng.
  • Cache token cùng response, retry mutation POST không có idempotency, hoặc đưa introspection mở ra production.

Nếu cần chuẩn hóa request layer và error mapping, hãy xem thêm bài Sử dụng Alamofire trong iOS. Phần concurrency của repository nên dùng task và cancellation rõ ràng; bài GCD hay async/await giúp bạn đặt quyết định này trong bối cảnh rộng hơn.

Góc nhìn 2027 và checklist triển khai

Trong năm 2027, áp lực chính không nằm ở việc đổi REST thành GraphQL, mà ở typed contract, telemetry và khả năng chịu mạng chập chờn. Các team sẽ tiếp tục dùng schema hoặc OpenAPI để phát hiện breaking change sớm, nhưng protocol chỉ có giá trị khi policy cache, auth và retry được kiểm thử như code.

  • Vẽ data shape của ba màn hình quan trọng và đo số request, payload, latency trước khi chọn giao thức.
  • Viết contract test cho status code, domain error, pagination và response thiếu field.
  • Thiết lập transport layer có auth, cancellation, redacted logging và retry idempotent.
  • Kiểm tra cache offline, refresh token, logout và quyền truy cập khi dữ liệu đã nằm trong local store.
  • Nếu dùng GraphQL, bật codegen trong CI, đặt query depth/complexity limit và theo dõi operation name.

Roadmap tổng thể có thể xem tại lộ trình học lập trình viên iOS. Mục tiêu không phải thuộc hai thuật ngữ, mà là xây một lớp networking có thể giải thích được dữ liệu đến từ đâu, lỗi thuộc tầng nào và request có an toàn để gửi lại hay không.