RxJava1.0学習ノートのクイックスタート

11172 ワード

概要
RxJavaのGitHubでの自己紹介は、「a library for composing asynchronous and event-based programs using observable sequences for the Java VM」(JavaVM上で観測可能なシーケンスを使用して非同期でイベントベースのプログラムを構成するライブラリ)であり、観察者モードベースのライブラリでもある.
彼を使うにはまず依存を追加しなければならない.

compile 'io.reactivex:rxjava:1.0.14'
compile 'io.reactivex:rxandroid:1.0.1'

クラスの紹介

Observable被観察者

Observerオブザーバー

subscribe()彼らがリンクした橋

Subscriberは、Observerの実装クラスであり、方法を拡張しています.

この関係は図に示すようにコードで表される.

 //   
Observer observer = new Observer() {
    @Override
    public void onCompleted() {
        Log.e("onCompleted: ", "  ");
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(String s) {
        Log.e("onNext: ", s);
    }
};`
//    
Observable observable = Observable.create(new Observable.OnSubscribe() {
    @Override
    public void call(Subscriber super String> subscriber) {
        Log.e("call: ", Thread.currentThread().getName());
        subscriber.onNext(" ");
        subscriber.onNext(" ");
        subscriber.onNext(" ");
        subscriber.onCompleted();
    }
});

ブリッジはリンクを生成します.

observable.subscribe(observer);

このような簡単なRxjavaモデルが作成され、出力結果を見ることができます.

com.example.cosima.rxjavalearn E/onNext::  
com.example.cosima.rxjavalearn E/onNext::  
com.example.cosima.rxjavalearn E/onNext::  
com.example.cosima.rxjavalearn E/onCompleted::

上記のObserverをSubscriberに置き換えることもできます.以下のようにします.

Subscriber subscriber = new Subscriber() {
    @Override
    public void onStart() {
    Log.e("onStart: ", "  ");
    Log.e("onStart: ", Thread.currentThread().getName());
    }

    @Override
    public void onCompleted() {
    Log.e("onCompleted: ", "  ");
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(String s) {
    Log.e("onNext: ", s);
    }
};

SubscriberではObserverよりもOnstartメソッドが多く、subscribeが開始されたばかりで、イベントが送信されない前に呼び出され、データのクリアやリセットなどの準備作業に使用できます.これはオプションの方法で、デフォルトでは実装が空です.
Observableの作成
イベントキューを最も基本的に作成するcreate()メソッドを使用して作成された作成方法について説明しましたが、このメソッドに基づいて、RxJavaはイベントキューを迅速に貫通するためのいくつかの方法を提供しています.

just(T..); 必要なパラメータを順次入力します.

from(T[]); 必要なパラメータを配列に追加して入力します.

観察者を被観察者に関連付けると、subscribe(Observer)およびsubscribe(Subscriber)の他に、subscribe()は不完全な定義のコールバックをサポートする.次のようになります.

Action1 onNextAction = new Action1() {
    // onNext()
    @Override
    public void call(String s) {
        Log.d(tag, s);
    }
};
Action1 onErrorAction = new Action1() {
    // onError()
    @Override
    public void call(Throwable throwable) {
    // Error handling
    }
};
Action0 onCompletedAction = new Action0() {
    // onCompleted()
    @Override
    public void call() {
        Log.d(tag, "completed");
    }
};

observable.subscribe(onNextAction);
observable.subscribe(onNextAction, onErrorAction);
observable.subscribe(onNextAction, onErrorAction, onCompletedAction);

上記のコードはAction 0とAction 1に言及し、彼らはいずれもRxJavaのインタフェースであり、同じように1つの方法Call()しかなく、異なるのは、Action 0のCall()方法ではパラメータも戻り値もなく、OnCompleted()という方法に対応している.Action 1のCall(T param)法にはパラメータが含まれており,それぞれOnNext(T param)とOnError(Throwable error)の2つの方法に対応している.具体的には次のように使用します.

String[] loves = {"I", "will", "always", "love", "you"};
Observable.from(loves).subscribe(new Action1() {
        @Override
        public void call(String s) {
            Log.e("call: ", s);
        }
    });

最初はRxJavaは非同期操作が可能だと言っていましたが、上記はすべて行う同期操作で、以下はRxJavaのもう一つの概念Schedulerについてお話しします
スレッド制御Scheduler
スレッドを指定しない場合、RxJavaはスレッド不変の原則に従い、どのスレッドがsubscribe()を呼び出すか、イベントがどのスレッドで発生するか、このスレッドで消費され、スレッドを切り替える必要がある場合にSchedulerを使用する必要があります.

Schedulers.immediate():現在のスレッドで直接実行され、スレッドを指定しないことに相当します.これはデフォルトのSchedulerです.

Schedulers.新Thread():常に新しいスレッドを有効にし、新しいスレッドで操作を行います.

Schedulers.io():I/O操作(ファイルの読み書き、データベースの読み書き、ネットワーク情報のインタラクションなど)に使用されるScheduler.動作モードとnewThread()の差は多くなく、io()の内部実装は数の上限のないスレッドプールを使用し、空きスレッドを再利用できるため、io()がnewThread()よりも効率的であることが多い.計算作業をio()に置かないでください.不要なスレッドの作成を避けることができます.

Schedulers.computation():使用するSchedulerを計算します.この計算とは、CPU密集型の計算であり、I/Oなどの操作によって性能が制限されない操作、例えばグラフィックの計算である.このSchedulerが使用する固定スレッドプールは,CPUコア数の大きさである.I/O操作をcomputation()に入れないでください.そうしないと、I/O操作の待ち時間がCPUを浪費します.

また、Androidには専用のAndroid Schedulersがあります.mainThread()は、Androidメインスレッドで指定された操作を実行します.

次にsubscribeOn()とobserveOn()の2つの方法を用いてスレッドを制御することができる.

subscribeOn():subscribe()で発生するスレッドを指定します.イベント発生スレッド.

observeOn():Subscriberが実行するスレッドを指定します.イベント消費のスレッド.そしてこのScheduler

  Observable.create(new Observable.OnSubscribe() {
      @Override
      public void call(Subscriber super String> subscriber) {
          subscriber.onNext(" ");
          subscriber.onNext(" ");
          subscriber.onNext(" ");
          subscriber.onCompleted();
      }
  })
          .subscribeOn(Schedulers.io())
          .doOnSubscribe(new Action0() {
              @Override
              public void call() {
                  Log.e("call: ", Thread.currentThread().getName());
                  mProgressBar.setVisibility(View.VISIBLE);
              }
          })

          .observeOn(AndroidSchedulers.mainThread())
          .subscribe(subscriber);

をコードで理解します
subscribeOn(Schedulers.io()は、作成された時間をIOスレッドで発行することを指定し、observeOn(AndroidScheculers.mainThread()は、イベント消費がプライマリスレッドで消費されることを指定します.この方法は、サブスレッドでデータを取得し、プライマリスレッド表示に適用されます.また、上記のコードに、イベントが発生する前にOnStart()の後に実行されるように、SubscriberのOnStart()メソッドと同様のメソッドdoOnSubscribe()を追加したことがわかりますが、このメソッドの前のsubscribeOn()は彼に影響を与えず、彼の後で最も近いsubscribeOn()からのみ影響を与えます.

observeOn()は、指定された後の操作が存在するスレッドに影響を与える複数回実行できます.

subscribeOn()は複数回実行することもでき、イベントの開始から影響を与え、複数ある場合は最初のsubscribeOn()のみが機能する.

次はRxJavaが一番すごいところだと言えます.
へんかん
1. map();
2. flatMap();
まずmap()を見てみましょう

 Observable.from(number)
           .map(new Func1() {
               @Override
               public Integer call(String s) {
                   Integer integer = Integer.valueOf(s);
                   Log.e("call--1--: ", integer + "");
                   return integer;
               }
           })
           .subscribe(new Action1() {
               @Override
               public void call(Integer integer) {
                   Log.e("call--2--: ", integer + "");
               }
           });

ここでまた新しいクラスFunc 1が現れ、彼はAction 1と非常に似ており、RxJavaのインタフェースでもあるが、Action 1とは異なりFunc 1には戻り値がある.Stringタイプのパラメータをmap()でIntegerタイプに変換して返すことがわかります.
次にflatMap()を見てみましょう.ここでは例を挙げて、学生の授業情報を印刷します.学生の授業は必ずしも一つではありません.たくさんあるかもしれません.だから、この時にflatMap()を使います.

Student[] students = ...;
Subscriber subscriber = new Subscriber() {
    @Override
    public void onNext(Course course) {
        Log.d(tag, course.getName());
    }
};
Observable.from(students)
        .flatMap(new Func1>() {
            @Override
            public Observable call(Student student) {
                return Observable.from(student.getCourses());
        }   
})
.subscribe(subscriber);

上のコードから分かるように、flatMapとMapの同じ点は、あるオブジェクトを別のオブジェクトに変換して返すことですが、flatMap()が返すのはObservableオブジェクトであり、このオブジェクトは直接コールバックメソッドに送信されるのではなく、このオブジェクトをアクティブにしてからコールバックメソッドに送信されます.
変換の原理
これらの変換は機能がそれぞれ異なるが,実質的にはイベントシーケンスに対する処理と再送信である.RxJavaの内部では、lift(Operator)という同じベースの変換方法に基づいています.
注:これはlift()のソースコードではなく、ソースコードの性能、互換性、拡張性に関連するコードを除去したコアコードです.ソースコードを見る必要がある場合は、RxJavaのGitHub倉庫でダウンロードできます.

public  Observable lift(Operator extends R, ? super T> operator) {
    return Observable.create(new OnSubscribe() {
        @Override
        public void call(Subscriber subscriber) {
            Subscriber newSubscriber = operator.call(subscriber);
            newSubscriber.onStart();
            onSubscribe.call(newSubscriber);
        }
    });
}

ここで私が理解しているlift()の原理についてお話ししましょう.簡単に言えば、あなたが自分で定義したObservable 1にlift()が含まれている場合、Observableが生成されます.私たちは彼をObservable 2と呼びます.Observable 2にOnSubscribe()があり、lift()を呼び出すと、新しく生成されたOnSubscribeがoperatorを利用します.call(subscriber)は、新しいSubscriber(call()メソッドを生成し、新しいSubscriberと元のSubscriberを関連付ける)を生成し、新しく生成されたSubscriberを介してObservable 1と購読するエージェントメカニズムに似ており、イベントブロックと処理によってイベントシーケンスの変換を実現する.
compose:Observable全体への変換
この場所はObservableをカプセル化し、Observableを実現するようなものです.TransformerインタフェースでCall()を書き直せばいいので、ここではあまり言わない.
RxJavaの使用シーンと使用方法#
Retrofitとの併用
コードを直接付けましょう.
1.まずRetrofitを初期化する

    Retrofit retrofit = new Retrofit.Builder()
            .baseUrl("http://japi.juhe.cn/joke/content/")
            .addConverterFactory(GsonConverterFactory.create())
            .addCallAdapterFactory(RxJavaCallAdapterFactory.create())//  RxJava1.0
            .build();

2.Observableを返す要求を定義する

    @GET("text.from?page=1&pagesize=20&key=f1bdc177567c6fbe53d918041004c0b1")
    Observable  getJokeContent();

3.要求を開始し、データを返す

    JokeService service = retrofit.create(JokeService.class);
        service.getJokeContent()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Action1() {
                    @Override
                    public void call(JokeBean jokeBean) {
                        String content = jokeBean.getResult().getData().get(0).getContent();
                        mTextView.setText(content);
                    }
                });

時間のかかる操作が必要な場合はdoOnNext()メソッドで行い、連続アクセスが必要な場合はflatMap()を使用します.

@GET("/token")
public Observable getToken();

@GET("/user")
public Observable getUser(@Query("token") String token, @Query("userId") String userId);

...

getToken()
.flatMap(new Func1>() {
    @Override
    public Observable onNext(String token) {
        return getUser(token, userId);
    })
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Observer() {
    @Override
    public void onNext(User user) {
        userView.setUser(user);
    }

    @Override
    public void onCompleted() {
    }

    @Override
    public void onError(Throwable error) {
        // Error handling
        ...
    }
});

参考:Android開発者のRxJavaの詳細を教えてください.Android実習&経験交流群をお勧めします:541144061

【Unity Remote 5】実機の画面が動かない

Python > debug > disパッケージ > bytecodeの確認に使う