Rxjava, Rxandroid Cơ Bản

RxJava, RxAndroid cơ bạn dạng.

Bạn đang xem: Rxjava, rxandroid cơ bản

I. Reactive Programming là gì?

Reactive Programing mà lại một phương thức lập trình sẵn tập trung vào các luồng dữ liệu không đồng bộ với quan tiếp giáp sự đổi khác của các luồng dữ liệu không đồng hóa đó, Lúc gồm sự biến hóa sẽ có được hành động giải pháp xử lý tương xứng. Vì đó là luồng dữ liệu không đồng hóa yêu cầu các module code đồng thời chạy xe trên những thread khác biệt tự đó tinh giảm thời hạn tiến hành mà ko làm bloông chồng main thread.

II. RxJava

RxJava cơ bạn dạng là một trong tlỗi viện cung ứng các sự kiện không đồng hóa được cải cách và phát triển theo Obhệ thống Pattern. Quý Khách hoàn toàn có thể chế tạo ra luồng dữ liệu không đồng nhất bên trên ngẫu nhiên thread nào, đổi khác dữ liệu cùng thực hiện tài liệu bởi Obhệ thống. Thỏng viện RxJava cung ứng nhiều một số loại Operator tuyệt vời như bản đồ, combine, merge , filter và nhiều sản phẩm công nghệ không giống hoàn toàn có thể được áp dụng mang lại luồng dữ liệu.

III. RxAndroid

RxAndroid được quan trọng đặc biệt áp dụng đến căn cơ Android được cải tiến và phát triển dựa trên RxJava. Đặc biệt Schedulers được bổ sung cập nhật cho RxAndroid nhằm mục đích cung cấp cho nhiều luồng trong vận dụng Android. Schedulers sẽ giúp đỡ các bạn phân chia luồng chạy mang đến từng module code làm thế nào để cho phù hợp. Một vài ba luồng chạy thông dụng được sử dụng qua Schedulers.

AndroidSchedulers.mainThread () Cung cung cấp quyền truy vấn vào Android Main Thread / UI Thread.Schedulers.newThread () Thread new sẽ tiến hành tạo nên mọi khi một nhiệm vụ được chế tác.

IV. Những nguyên tố quan trọng vào RxJava:

Về cơ phiên bản RxJava gồm nhì nguyên tố chính: Observable cùng Observer. Thêm vào kia, bao gồm trang bị khác ví như Schedulers, Operators và Subscription là các nguyên tố vào vai trò nlỗi đa luồng, thao tác làm việc dữ liệu, và liên kết. Chúng ta đã cùng có tác dụng quen với từng thành phần: Observable: Là luồng tài liệu thực hiện một vài quá trình cùng phạt ra dữ liệu.Observer : Là yếu tắc đi kèm theo không thể không có của Observable. Nó dấn tài liệu được vạc ra vị Observable. Subcription: Là mọt links giữa Observable và ObVPS. cũng có thể có nhiều Obhệ thống đăng ký một Observable độc nhất. Operator: Hỗ trợ đến câu hỏi sửa thay đổi tài liệu được vạc ra vì chưng Observable trước lúc obhệ thống thừa nhận chúng. Schedulers: Scheduler đưa ra quyết định thread cơ mà Observable đã phát ra dữ liệu với trên thread làm sao Observer đã dìm tài liệu.

1. Cách tạo Observable

Chúng ta gồm 5 các loại Observable kèm theo là 5 một số loại Obhệ thống tương ứng. Mỗi loại Observable được sử dụng trong số trường thích hợp khác biệt phụ thuộc vào con số cùng nhiều loại phần tử được Observable phạt ra.

*
Đầu tiên bọn họ đang điểm sang 1 vài ba cách thức thông dụng nhằm tạo nên Observable:

just:Available: Flowable, Observable, Maybe, Single Tạo một Observable phạt ra một thành quả cụ thể.defer:Available: Flowable, Observable, Maybe, Single, Completable ko tạo thành Observable cho đến Khi có ObVPS đăng ký, và tạo ra một Observable bắt đầu mọi khi có Obhệ thống new ĐK.from:Available: Flowable, Observable Chuyển thay đổi những đối tượng người sử dụng và đẳng cấp tài liệu khác thành Observablesinterval:Available: Flowable, Observable. Định kỳ tạo nên một số trong những vô hạn (Long), tăng thêm.

Xem thêm: Đông Từ Theo Sau V Erb + Ing Hay To + Verb ? Các Đt Theo Sau

fromCallable:Available: Flowable, Observable, Maybe, Single, Completable Lúc có obVPS ĐK, Callable đang cho được call với quý giá trả về của chính nó (hoặc ném nhẹm nước ngoài lệ) được gửi kế tiếp Obhệ thống.

2. Cách sinh sản Observer

Đối cùng với mỗi một số loại ObVPS khác nhau bọn họ gồm biện pháp chế tác cùng thực thi không giống nhau nhưng phần đông hơi đơn giản và dễ dàng. Đây là ví dụ điển hình nổi bật độc nhất vô nhị nhằm tạo nên Observer:

private Obhệ thống getAnimalsObserver() return new Observer()
Override public void onComplete() Log.d(TAG, "All items are emitted!"); ; onSubscribe(): Phương thơm thức sẽ được Hotline khi một ObVPS ĐK vào Observable. onNext(): Pmùi hương thức này sẽ tiến hành Điện thoại tư vấn khi Observable bước đầu phân phát ra dữ liệu. onError(): Trong ngôi trường thích hợp bao gồm lỗi, phương thức onError() sẽ tiến hành Hotline.onComplete(): Khi một Observable kết thúc bài toán vạc ra dữ liệu, onComplete() sẽ được Điện thoại tư vấn.

3. Tạo Obhệ thống theo dõi Observable

Đây là những cách thức cơ bản để khiến cho ObVPS đăng ký theo dõi Observable.

animalsObservable .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(animalsObserver);subscribeOn(Schedulers.io ()): Báo mang đến Observable chạy trọng trách bên trên một chuỗi nền.observOn(AndroidSchedulers.mainThread ()): Yêu cầu Obhệ thống thừa nhận tài liệu trên luồng chính để bạn cũng có thể thực hiện những hành động liên quan mang đến đồ họa.

4. Disposable

Disposable được áp dụng nhằm diệt sự liên kết của Subhệ thống với Subsevable Khi không hề cần thiết Việc này cực kỳ có lợi nhằm tách Việc nhỉ bộ lưu trữ. Lúc Observer kết nối được với Observable vào onSubcribe() ta sẽ cảm nhận Disposable. Để diệt sự liên kết trong onDestroy() của Activity các bạn nên được gọi hàm dispose() của Disposable.

5. Operator

RxJava hỗ trợ tập vừa lòng bự những operator hỗ trợ mang lại bài toán thao tác làm việc cùng với tài liệu vậy bắt buộc operators được phân chia dựa trên một số loại công việc chúng làm cho. Ví dụ nlỗi team chế tạo Observable: create, just, fromArray,... Nhóm thanh lọc dữ liệu: filter, skip, last, take, ... Nhóm sản xuất Observable từ dữ iệu của Observable không giống như: buffer, maps, flatmaps,...Lưu ý Lúc sử dụng các Operator thì kết quả của Operator trước đang truyền cho Operator sau.Bạn hoàn toàn có thể tham khảo thêm tại đây

V. Ví dụ:

Sau đây là ví dụ cụ thể cho từng một số loại Observable được nói phía trên:Trong các ví dụ bản thân sử dung Custom object Note:

public class lưu ý int id; String note; // getters an setters

1. Observable và Observer:

Được sử dụng những tuyệt nhất trong số tất cả. Observable có thể phát ra không hoặc nhiều thành phần.

public class ObserverActivity extends AppCompatActivity private static final String TAG = ObserverActivity.class.getSimpleName(); private Disposable disposable; /** * Simple Observable emitting multiple Notes * - * Observable : Obhệ thống */
Override protected void onCreate(Bundle savedInstanceState) super.onCreate(savedInstanceState); setContentView(R.layout.activity_observer); Observable notesObservable = getNotesObservable(); ObVPS notesObserver = getNotesObserver(); notesObservable.observeOn(Schedulers.io()) .subscribeOn(AndroidSchedulers.mainThread()) .subscribeWith(notesObserver); private Obhệ thống getNotesObserver() return new Observer()
Override public void onComplete() Log.d(TAG, "onComplete"); ; private Observable getNotesObservable() final List notes = prepareNotes(); return Observable.create(new ObservableOnSubscribe()
Override public void subscribe(ObservableEmitter emitter) throws Exception for (lưu ý note : notes) if (!emitter.isDisposed()) emitter.onNext(note); // all notes are emitted if (!emitter.isDisposed()) emitter.onComplete(); ); private List prepareNotes() List notes = new ArrayList(); notes.add(new Note(1, "Buy tooth paste!")); notes.add(new Note(2, "call brother!")); notes.add(new Note(3, "Watch Narcos tonight!")); notes.add(new Note(4, "Pay power bill!")); return notes;
Override protected void onDestroy() super.onDestroy(); disposable.dispose(); Output:

onSubscribeonNext: Buy tooth paste!onNext: hotline brother!onNext: Watch Narcos tonight!onNext: Pay power bill!onComplete

2. Single & SingleObsever

Single luôn luôn vạc ra chỉ một giá trị hoặc một lỗi. Observable rất có thể thực hiện được quá trình này nhưng mà Single luôn luôn bảo vệ rằng luôn luôn luôn có 1 phần tử được trả về. Chính vị chỉ có 1 phần tử phải SingleObserver không có onNext() nhưng mà chỉ tất cả onSuccess() để dìm tài liệu trả về.

public class SingleObserverActivity extends AppCompatActivity private static final String TAG = SingleObserverActivity.class.getSimpleName(); private Disposable disposable; /** * Single Observable emitting single cảnh báo * Single Observable is more useful in making network calls * where you expect a single response object to be emitted * - * Single : SingleObhệ thống */ // TODO - liên kết khổng lồ Retrofit tutorial
Override protected void onCreate(Bundle savedInstanceState) super.onCreate(savedInstanceState); setContentView(R.layout.activity_single_observer); Single noteObservable = getNoteObservable(); SingleObserver singleObVPS = getSingleObserver(); noteObservable .observeOn(Schedulers.io()) .subscribeOn(AndroidSchedulers.mainThread()) .subscribe(singleObserver); private SingleObserver getSingleObserver() return new SingleObserver()
Override public void onError(Throwable e) Log.d(TAG, "onError: " + e.getMessage()); ; private Single getNoteObservable() return Single.create(new SingleOnSubscribe()
Override public void subscribe(SingleEmitter emitter) throws Exception cảnh báo note = new Note(1, "Buy milk!"); emitter.onSuccess(note); );
Override protected void onDestroy() super.onDestroy(); disposable.dispose(); Output

onSubscribeonSuccess: Buy milk!

3. Maybe và MaybeObserver

Maybe có thể hoặc ko phạt ra một quý hiếm. Maybe được thực hiện khi chúng ta đã ý muốn chờ một trong những phần tử được vạc ra tùy thuộc vào từng ngôi trường đúng theo xẩy ra. Như Lúc chúng ta query note by Id trong database nó có thể có hoặc cũng hoàn toàn có thể ko.

public class MaybeObserverActivity extends AppCompatActivity private static final String TAG = MaybeObserverActivity.class.getSimpleName(); private Disposable disposable; /** * Consider an example getting a note from db using ID * There is possibility of not finding the note by ID in the db * In this situation, MayBe can be used * - * Maybe : MaybeObhệ thống */
Override protected void onCreate(Bundle savedInstanceState) super.onCreate(savedInstanceState); setContentView(R.layout.activity_maybe_observer); Maybe noteObservable = getNoteObservable(); MaybeObhệ thống noteObVPS = getNoteObserver(); noteObservable.subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(noteObserver); private MaybeObhệ thống getNoteObserver() return new MaybeObserver()
Override public void onComplete() Log.e(TAG, "onComplete"); ; /** * Emits optional data (0 or 1 emission) * But for now it emits 1 lưu ý always */ private Maybe getNoteObservable() return Maybe.create(new MaybeOnSubscribe()
Override public void subscribe(MaybeEmitter emitter) throws Exception Note note = new Note(1, "Call brother!"); if (!emitter.isDisposed()) emitter.onSuccess(note); );
Override protected void onDestroy() super.onDestroy(); disposable.dispose();

4.Completable và CompletableObserver

Completable không phân phát ra ngẫu nhiên dữ liệu nào cầm vào đó nó thông báo trạng thái của tác vụ thành công xuất sắc xuất xắc thất bại. Được áp dụng lúc bạn có nhu cầu triển khai một số trong những trọng trách và không muốn chờ ngẫu nhiên giá trị như thế nào trả về. Một ngôi trường vừa lòng Completable thường xuyên được áp dụng là cập nhật một vài dữ liệu trên sever bằng phương pháp tiến hành tận hưởng PUT.

public class CompletableObserverActivity extends AppCompatActivity { private static final String TAG = CompletableObserverActivity.class.getSimpleName(); private Disposable disposable; /** * Completable won"t emit any chiến thắng, instead it returns * Success or failure state * Consider an example of making a PUT request to lớn hệ thống khổng lồ update * something where you are not expecting any response but the * success status * - * Completable : CompletableObVPS */ // TODO - links khổng lồ Retrofit tutorial
Override protected void onCreate(Bundle savedInstanceState) super.onCreate(savedInstanceState); setContentView(R.layout.activity_completable_observer); Note note = new Note(1, "trang chủ work!"); Completable completableObservable = updateNote(note); CompletableObhệ thống completableObserver = completableObserver(); completableObservable .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(completableObserver); /** * Assume this making PUT request to VPS to lớn update the chú ý */ private Completable updateNote(Note note) return Completable.create(new CompletableOnSubscribe()
Override public void subscribe(CompletableEmitter emitter) throws Exception if (!emitter.isDisposed()) Thread.sleep(1000); emitter.onComplete(); ); private CompletableObserver completableObserver() { return new CompletableObserver()
Override protected void onDestroy() super.onDestroy(); disposable.dispose(); Output

onSubscribeonComplete: chú ý updated successfully!

5. Flowable và Observer

Được thực hiện lúc một Observable tạo ra số lượng bự các sự khiếu nại / tài liệu cơ mà ObVPS rất có thể xử lý. Flowable hoàn toàn có thể được thực hiện Lúc mối cung cấp tạo thành 10k+ sự khiếu nại với Onserver quan trọng tiêu thú toàn bộ.Flowable áp dụng phương pháp Backpressure để xử lý tài liệu rời lỗi MissingBackpressureException với OutOfMemoryError.

public class FlowableObserverActivity extends AppCompatActivity private static final String TAG = FlowableObserverActivity.class.getSimpleName(); private Disposable disposable; /** * Simple example of Flowable just to show the syntax * the use of Flowable is best explained when used with BackPressure * Read the below liên kết lớn know the best use cases lớn use Flowable operator * https://github.com/ReactiveX/RxJava/wiki/What%27s-different-in-2.0#when-to-use-flowable * - * Flowable : SingleObserver */
Override protected void onCreate(Bundle savedInstanceState) super.onCreate(savedInstanceState); setContentView(R.layout.activity_flowable_observer); Flowable flowableObservable = getFlowableObservable(); SingleObVPS obhệ thống = getFlowableObserver(); flowableObservable .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .reduce(0, new BiFunction()
Override public Integer apply(Integer result, Integer number) //Log.e(TAG, "Result: " + result + ", new number: " + number); return result + number; ) .subscribe(observer); private SingleObhệ thống getFlowableObserver() return new SingleObserver()
Override public void onError(Throwable e) Log.e(TAG, "onError: " + e.getMessage()); ; private Flowable getFlowableObservable() return Flowable.range(1, 100);
Override protected void onDestroy() super.onDestroy(); disposable.dispose(); Output