Các kiểu Single, Maybe và Completable là những phiên bản chuyên biệt của Observable, được thiết kế để biểu diễn các luồng dữ liệu có tính chất xác định về số lượng sự kiện thành công — cụ thể là tối đa một lần phát hành giá trị.

Đặc điểm hành vi từng loại

• Observable<T>: Có thể phát ra 0, 1 hoặc nhiều giá trị (qua onNext), sau đó kết thúc bằng onComplete hoặc onError. Không cho phép gửi bất kỳ sự kiện nào sau khi kết thúc.
• Single<T>: Chỉ phát ra đúng một giá trị thành công (onSuccess) hoặc một lỗi (onError). Không hỗ trợ trạng thái "hoàn tất mà không có giá trị".
• Maybe<T>: Linh hoạt hơn: có thể trả về một giá trị (onSuccess), không trả gì cả (onComplete), hoặc gặp lỗi (onError).
• Completable: Không mang giá trị nào — chỉ thông báo kết quả thực thi qua onComplete (thành công) hoặc onError (thất bại).

Cả ba kiểu này đều đảm bảo rằng nếu có giá trị được phát ra, thì chỉ duy nhất một lần — điều này giúp kiểm soát luồng rõ ràng hơn so với Observable khi ngữ cảnh yêu cầu tính chắc chắn về số lần phát hành.

Giao diện người quan sát tương ứng

// Người quan sát chuẩn
interface DataObserver<T> {
    fun onSubscribe(disposable: Disposable)
    fun onNext(item: T)
    fun onError(error: Throwable)
    fun onComplete()
}

// Dành riêng cho Single
interface ResultObserver<T> {
    fun onSubscribe(disposable: Disposable)
    fun onSuccess(value: T)
    fun onError(error: Throwable)
}

// Dành riêng cho Maybe
interface OptionalObserver<T> {
    fun onSubscribe(disposable: Disposable)
    fun onSuccess(value: T)
    fun onError(error: Throwable)
    fun onComplete()
}

// Dành riêng cho Completable
interface TaskObserver {
    fun onSubscribe(disposable: Disposable)
    fun onComplete()
    fun onError(error: Throwable)
}

Bảng so sánh khả năng phát ra sự kiện

Tương đương trong lập trình đồng bộ (Kotlin)

Mối quan hệ giữa các kiểu bất đồng bộ và đồng bộ trong Kotlin phản ánh rõ ràng mô hình xử lý giá trị:

Ví dụ minh hoạ trong API mạng

Dưới đây là cách khai báo các endpoint REST sử dụng Retrofit với RxJava/Kotlin:

interface ApiService {
    // Trả về một chuỗi duy nhất — dùng Single
    @GET("status")
    fun fetchStatus(): Single<String>

    // Có thể trả về dữ liệu hoặc không — dùng Maybe
    @GET("user/{id}")
    fun findUser(@Path("id") userId: Long): Maybe<User>

    // Chỉ cần biết thao tác hoàn tất — dùng Completable
    @PUT("user/{id}/activate")
    fun activateAccount(@Path("id") userId: Long): Completable
}

Sự lựa chọn giữa các kiểu này không chỉ là kỹ thuật — mà còn là cách truyền đạt ý định thiết kế: Single khẳng định "luôn có kết quả", Maybe thừa nhận khả năng "không có kết quả", còn Completable nhấn mạnh vào "kết quả hành động chứ không phải dữ liệu".