عملگرهای RxJava (بخش اول)

آذر 19, 1400
3 دقیقه خواندن

اکنون که یک Observable پایه را با یک Observerاجرا کردیم، می توان نگاهی به عملگرهای مختلف در RxJava انداخت. عملگرها اجازه می دهند داده هایی که Observable های جدیدی منتشر یا خلق شده اند، اجرا شود.

عملگر create برای ایجاد Observable ها

عملگر create : این عملگر یک Observable از ابتدا با صدا زدن روش های Observer بصورت برنامه ریزی شده ایجاد می کند.

نمونه زیر یک Observable با استفاده از Observable.create() ایجاد می کند. روش ()create ورودی برای انتقال مقادیر ندارد. بنابراین باید یک لیست از قبل ایجاد کنیم و عملگر را روی لیست داخل ()onNext اجرا کنیم.

final List<String> alphabets = getAlphabetList();

        /*
         * Observable.create() -> We will need to call the
         * respective methods of the emitter such as onNext()
         * & onComplete() or onError()
         *
         * */
        Observable observable = Observable.create(new ObservableOnSubscribe() {
            @Override
            public void subscribe(ObservableEmitter emitter) {

                try {

                    /*
                     * The emitter can be used to emit each list item
                     * to the subscriber.
                     *
                     * */
                    for (String alphabet : alphabets) {
                        emitter.onNext(alphabet);
                    }

                    /*
                     * Once all the items in the list are emitted,
                     * we can call complete stating that no more items
                     * are to be emitted.
                     *
                     * */
                    emitter.onComplete();

                } catch (Exception e) {

                    /*
                     * If an error occurs in the process,
                     * we can call error.
                     *
                     * */
                    emitter.onError(e);
                }
            }
        });


        /*
         * We create an Observer that is subscribed to Observer.
         * The only function of the Observer in this scenario is
         * to print the valeus emitted by the Observer.
         *
         * */
        Observer observer = new Observer() {
            @Override
            public void onSubscribe(Disposable d) {
                System.out.println("onSubscribe");
            }

            @Override
            public void onNext(Object o) {
                System.out.println("onNext: " + o);
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("onError: " + e.getMessage());
            }

            @Override
            public void onComplete() {
                System.out.println("onComplete");
            }
        };

        /*
         * We can call this method to subscribe
         * the observer to the Observable.
         * */
        observable.subscribe(observer);

خروجی این کد چنین می شود:

onSubscribe
onNext: A
onNext: B
onNext: C
onNext: D
onNext: E
onNext: F
onComplete

عملگر Defer:

defer به معنای به تعویق انداختن است. این عملگر تا زمانی که Observer تایید نکند، Observable را ایجاد نمی کند. تنها نقطه ضعف ()defer این است که هربار شما بخواهید Observer جدید بگیرید، یک Observable جدید ایجاد می کند. ()create از همان تابع برای هر Observable یا subscriber استفاده می کرد که باعث می شد تابع ()create کارآمدتر باشد.

نمونه زیر یک Observable با استفاده از ()Observable.defer می سازد. کد زیر یک Observable می سازد که یک مقدار را منتشر می کند.

public class DeferClass {  
  private String value;

  public void setValue(String value) {
    this.value = value;
  }

/*  
 * DeferClass instance = new DeferClass();  
 * Observable<String> value = instance.valueObservable();  
 * instance.setValue("Test Value");  
 * value.subscribe(System.out::println); //null will be printed
 * 
 * Suppose we call the below class and create an Observable,
 * when we call print, it will print null, since value had yet 
 * to be initialized when Observable.just() is called.
 */  
  public Observable<String> valueObservable() {
    return Observable.just(value);
  }
}


public class DeferClass {  
  private String value;

  public void setValue(String value) {
    this.value = value;
  }

/*   
 * Now if we wrap the code inside
 * Observable.defer(), none of the code inside of defer() 
 * is executed until subscription.
 */  
  public Observable<String> valueObservable() {  
    return Observable.defer(() -> Observable.just(value));
  }
}

تا اینجا دو تابع از توابع مورد استفاده در RxJava را بیان کردیم. در ادامه با توابعی آشنا می شویم که مهارت ما را در استفاده از برنامه نویسی ری اکتیو بالا می برند. پس حتما مطلب بعدی ما را نیز پیگیری نمائید.

دیدگاهتان را بنویسید

نشانی ایمیل شما منتشر نخواهد شد.