Bạn đang xem: Rxjava là gì
I. Reactive sầu Programming là gì?
Reactive Programing cơ mà một phương pháp lập trình tập trung vào các luồng tài liệu không nhất quán cùng quan lại ngay cạnh sự biến hóa của các luồng tài liệu ko đồng bộ kia, Khi tất cả sự biến đổi sẽ có được hành vi xử trí cân xứng. Vì đây là luồng dữ liệu ko đồng điệu phải các module code cùng lúc điều khiển xe trên các thread không giống nhau tự kia tinh giảm thời hạn xúc tiến mà lại ko làm bloông xã main thread.
II. RxJava
RxJava cơ bạn dạng là một trong thỏng viện cung cấp những sự khiếu nại ko đồng điệu được trở nên tân tiến theo Obhệ thống Pattern. Quý khách hàng hoàn toàn có thể chế tạo luồng dữ liệu không đồng hóa trên bất kỳ thread như thế nào, biến hóa dữ liệu và thực hiện dữ liệu bởi Obhệ thống. Thư viện RxJava hỗ trợ những loại Operator tuyệt vời nhỏng map, combine, merge , filter cùng nhiều trang bị khác rất có thể được vận dụng mang lại luồng dữ liệu.
III. RxAndroid
RxAndroid được đặc trưng áp dụng mang đến nền tảng Android được cách tân và phát triển dựa trên RxJava. Đặc biệt Schedulers được bổ sung cập nhật mang đến RxAndroid nhằm cung cấp cho đa luồng trong vận dụng Android. Schedulers sẽ giúp các bạn phân chia luồng chạy đến từng module code làm sao cho cân xứng. Một vài luồng chạy thịnh hành được áp dụng qua Schedulers.
AndroidSchedulers.mainThread () Cung cấp quyền truy vấn vào Android Main Thread / UI Thread.Schedulers.newThread () Thread mới sẽ tiến hành tạo nên mỗi lúc một trọng trách được chế tác.IV. Những yếu tố đặc biệt vào RxJava:
Về cơ bản RxJava bao gồm nhì yếu tắc chính: Observable cùng ObVPS. Thêm vào đó, có những thiết bị khác ví như Schedulers, Operators và Subscription là những thành phần nhập vai trò như đa luồng, thao tác dữ liệu, với liên kết. Chúng ta đã thuộc làm cho quen cùng với từng thành phần: Observable: Là luồng dữ liệu triển khai một vài các bước và phát ra tài liệu.Observer : Là thành phần kèm theo luôn luôn phải có của Observable. Nó nhận dữ liệu được phát ra vị Observable. Subcription: Là mọt link giữa Observable và ObVPS. cũng có thể có tương đối nhiều ObVPS đăng ký một Observable nhất. Operator: Hỗ trợ mang đến Việc sửa đổi tài liệu được phân phát ra bởi Observable trước khi obhệ thống dìm bọn chúng. Schedulers: Scheduler quyết định thread cơ mà Observable đang vạc ra dữ liệu cùng trên thread làm sao Observer sẽ nhấn dữ liệu.
1. Cách tạo ra Observable
Chúng ta gồm 5 nhiều loại Observable kèm theo là 5 một số loại ObVPS khớp ứng. Mỗi các loại Observable được thực hiện trong những ngôi trường phù hợp khác nhau dựa vào số lượng với các loại bộ phận được Observable phát ra.
2. Cách chế tạo Observer
Đối với từng các loại ObVPS không giống nhau bọn họ tất cả bí quyết chế tạo với tiến hành không giống nhau tuy nhiên mọi hơi dễ dàng. Đây là ví dụ nổi bật nhất để tạo ra Observer:
private Observer 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 lúc một Observer đăng ký vào Observable. onNext(): Phương thức này sẽ tiến hành hotline lúc Observable ban đầu phát ra tài liệu. onError(): Trong trường đúng theo gồm lỗi, phương thức onError() sẽ được điện thoại tư vấn.onComplete(): khi một Observable xong xuôi việc phân phát ra dữ liệu, onComplete() sẽ được gọi.
3. Tạo Observer quan sát và theo dõi Observable
Đây là các cách làm cơ bản nhằm khiến cho Observer đăng ký theo dõi và quan sát 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 Observer nhấn tài liệu bên trên luồng chủ yếu nhằm bạn cũng có thể tiến hành các hành động tương quan mang đến hình ảnh.
4. Disposable
Disposable được áp dụng để diệt sự liên kết của SubVPS với Subsevable Khi không hề quan trọng vấn đề này khôn xiết hữu dụng nhằm tránh việc nhỉ bộ nhớ. Khi Obhệ thống liên kết được với Observable vào onSubcribe() ta đang cảm nhận Disposable. Để diệt sự kết nối vào onDestroy() của Activity chúng ta nên gọi hàm dispose() của Disposable.
5. Operator
RxJava cung ứng tập thích hợp lớn các operator cung cấp mang đến câu hỏi thao tác với dữ liệu vậy buộc phải operators được phân loại dựa trên loại các bước bọn chúng làm. Ví dụ như team sinh sản Observable: create, just, fromArray,... Nhóm lọc dữ liệu: filter, skip, last, take, ... Nhóm tạo nên Observable từ bỏ dữ iệu của Observable không giống như: buffer, maps, flatbản đồ,...Lưu ý lúc áp dụng nhiều Operator thì công dụng của Operator trước vẫn truyền mang đến Operator sau.quý khách hàng rất có thể tìm hiểu thêm tại đây
V. Ví dụ:
Sau đó là ví dụ ví dụ đến từng các loại Observable được kể phía trên:Trong những ví dụ mình sử dung Custom object Note:
public class chú ý int id; String note; // getters an setters
1. Observable và Observer:
Được sử dụng các tốt nhất trong số tất cả. Observable hoàn toàn có thể vạc ra ko hoặc những phần tử.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 Observer 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, "Điện thoại tư vấn 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: Call brother!onNext: Watch Narcos tonight!onNext: Pay power bill!onComplete
2. Single và SingleObsever
Single luôn luôn phát ra chỉ một quý hiếm hoặc một lỗi. Observable rất có thể tiến hành được quá trình này nhưng mà Single luôn luôn luôn bảo đảm an toàn rằng luôn luôn luôn luôn có 1 phần tử được trả về. Chính vày chỉ gồm 1 phần tử bắt buộc SingleObVPS không tồn tại onNext() nhưng chỉ gồm onSuccess() nhằm dấn 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 Note * Single Observable is more useful in making network calls * where you expect a single response object to lớn be emitted * - * Single : SingleObVPS */ // TODO - link khổng lồ Retrofit tutorial
Override protected void onCreate(Bundle savedInstanceState) super.onCreate(savedInstanceState); setContentView(R.layout.activity_single_observer); Single noteObservable = getNoteObservable(); SingleObhệ thống singleObVPS = getSingleObserver(); noteObservable .observeOn(Schedulers.io()) .subscribeOn(AndroidSchedulers.mainThread()) .subscribe(singleObserver); private SingleObVPS 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 rất có thể hoặc không vạc ra một cực hiếm. Maybe được thực hiện khi chúng ta sẽ ước ao ngóng 1 phần tử được vạc ra tùy theo từng trường vừa lòng xẩy ra. Nhỏng khi chúng ta query note by Id trong database nó có thể tất cả hoặc cũng 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 : MaybeObserver */
Override protected void onCreate(Bundle savedInstanceState) super.onCreate(savedInstanceState); setContentView(R.layout.activity_maybe_observer); Maybe noteObservable = getNoteObservable(); MaybeObhệ thống noteObserver = getNoteObserver(); noteObservable.subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(noteObserver); private MaybeObVPS 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 chú ý note = new Note(1, "call brother!"); if (!emitter.isDisposed()) emitter.onSuccess(note); );
Override protected void onDestroy() super.onDestroy(); disposable.dispose();
4.Completable & CompletableObserver
Completable ko vạc ra bất kỳ tài liệu như thế nào cố gắng vào kia nó thông báo trạng thái của tác vụ thành công xuất sắc tuyệt không thắng cuộc. Được thực hiện Khi bạn muốn triển khai một số trong những trách nhiệm với ko mong mỏi đợi ngẫu nhiên quý giá làm sao trả về. Một ngôi trường hòa hợp Completable thường được sử dụng là cập nhật một số tài liệu bên trên máy chủ bằng phương pháp thực hiện yên cầu PUT.public class CompletableObserverActivity extends AppCompatActivity { private static final String TAG = CompletableObserverActivity.class.getSimpleName(); private Disposable disposable; /** * Completable won"t emit any thành quả, instead it returns * Success or failure state * Consider an example of making a PUT request to lớn VPS lớn update * something where you are not expecting any response but the * success status * - * Completable : CompletableObVPS */ // TODO - link lớn Retrofit tutorial
Override protected void onCreate(Bundle savedInstanceState) super.onCreate(savedInstanceState); setContentView(R.layout.activity_completable_observer); lưu ý note = new Note(1, "trang chủ work!"); Completable completableObservable = updateNote(note); CompletableObVPS completableObVPS = completableObserver(); completableObservable .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(completableObserver); /** * Assume this making PUT request to server khổng lồ update the Note */ private Completable updateNote(lưu ý note) return Completable.create(new CompletableOnSubscribe()
Override public void subscribe(CompletableEmitter emitter) throws Exception if (!emitter.isDisposed()) Thread.sleep(1000); emitter.onComplete(); ); private CompletableObVPS completableObserver() { return new CompletableObserver()
Override protected void onDestroy() super.onDestroy(); disposable.dispose(); Output
onSubscribeonComplete: chú ý updated successfully!
5. Flowable & Observer
Được áp dụng lúc một Observable tạo nên con số phệ các sự khiếu nại / dữ liệu mà lại Observer hoàn toàn có thể cách xử trí. Flowable hoàn toàn có thể được áp dụng khi mối cung cấp tạo thành 10k+ sự kiện với OnVPS bắt buộc tiêu trúc toàn bộ.Flowable sử dụng phương pháp Backpressure để giải pháp xử lý dữ liệu rời lỗi MissingBackpressureException cùng OutOfMemoryError.public class FlowableObserverActivity extends AppCompatActivity private static final String TAG = FlowableObserverActivity.class.getSimpleName(); private Disposable disposable; /** * Simple example of Flowable just lớn show the syntax * the use of Flowable is best explained when used with BackPressure * Read the below link lớn know the best use cases to use Flowable operator * https://github.com/ReactiveX/RxJava/wiki/What%27s-different-in-2.0#when-to-use-flowable * - * Flowable : SingleObhệ thống */
Override protected void onCreate(Bundle savedInstanceState) super.onCreate(savedInstanceState); setContentView(R.layout.activity_flowable_observer); Flowable flowableObservable = getFlowableObservable(); SingleObserver 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