Eine detaillierte Einführung in RxJava_03 [Observer-Erstellungsvorgang] in einfachen Worten

Dieses Tutorial basiert auf RxJava1 >Die folgenden Funktionen sind alle Funktionen, die zum Erstellen von Observables verwendet werden. Wir können bei Bedarf entsprechende Funktionen erstellen.
Erstellen – die ursprüngliche Observable-Erstellungsfunktion

Aufschieben – ein Observable, das nach dem Erstellen eines Abonnements erstellt wurde
Leer/Nie/Auslösen – Erstellen Sie ein Observable, das keine Daten sendet/um Ausnahmedaten zu senden
Einfach – Erstellen Sie ein Observable, das 1-9 Werte sendet
Von – Erstellen Sie ein Observable, das eine Warteschlange ausgibt.
Intervall und Timer – Erstellen Sie ein Timer-ähnliches Observable.
Bereich – Erstellen ein Observable
Wiederholung, die einen bestimmten Ganzzahltyp sendet
7. Sie können den Create-Operator verwenden, um ein Observable von Grund auf zu erstellen. Übergeben Sie diesem Operator eine Funktion, die einen Beobachter als Parameter akzeptiert. und schreiben Sie diese Funktion so, dass sie sich wie ein Observable verhält – indem Sie die Methoden onNext, onError und onCompleted des Beobachters entsprechend aufrufen.
   Ein wohlgeformtes endliches Observable muss versuchen, das onCompleted des Beobachters genau einmal oder seinen onError genau einmal aufzurufen, und darf danach keine anderen Methoden des Beobachters mehr aufrufen.
8. Es wird empfohlen, den isUnsubscribed-Status des Beobachters in der an die Erstellungsmethode übergebenen Funktion zu überprüfen, damit Ihr Observable keine Daten mehr ausgeben oder teure Vorgänge ausführen kann, wenn keine Beobachter vorhanden sind.
   Beispielcode:

Ausgabe:

2. Aufschieben

Das Observable wird erst erstellt, wenn ein Beobachter es abonniert Jeder Beobachter erstellt ein neues Observable.

Der Defer-Operator wartet, bis ein Beobachter ihn abonniert, und generiert dann ein Observable mithilfe der Observable-Factory-Methode. Dies geschieht für jeden Observer. Obwohl also jeder Abonnent denkt, dass er dasselbe Observable abonniert, erhält tatsächlich jeder Abonnent seine eigene, separate Datensequenz.

Der Code lautet wie folgt:

Observable.create(new Observable.OnSubscribe<Integer>() {
    @Override
    public void call(Subscriber<? super Integer> observer) {
        try {
            if (!observer.isUnsubscribed()) {
                for (int i = 1; i < 5; i++) {
                    observer.onNext(i);
                }
                observer.onCompleted();
            }
        } catch (Exception e) {
            observer.onError(e);
        }
    }
 } ).subscribe(new Subscriber<Integer>() {
        @Override
        public void onNext(Integer item) {
            System.out.println("Next: " + item);
        }

        @Override
        public void onError(Throwable error) {
            System.err.println("Error: " + error.getMessage());
        }

        @Override
        public void onCompleted() {
            System.out.println("Sequence complete.");
        }
    });

3.Empty/Never/Throw

Next: 1
Next: 2
Next: 3
Next: 4
Sequence complete.

Empty

Erstellen Sie ein Observable, das keine Daten ausgibt wird aber normal beendet

Nie

Erstellt ein Observable, das keine Daten ausgibt, und endet mit einem Fehler

Observable<String> defer = Observable.defer(new Func0<Observable<String>>() {
    //当observable被创建的时候顺便调用observable内部的call()方法并在方法中发送消息
    //每subscribe()就会在call()中返回一个新的实例对象
    @Override
    public Observable<String> call() {
        Observable<String> observable = Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("Hello Android !");
            }
        });
        return observable;
    }
});
defer.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
    }
});

defer.subscribe(new Action1<String>() {
    @Override
    public void call(String s) {
    }
});

Throw

Erstellt ein Observable, das keine Daten ausgibt und endet mit einem Fehler

Das von diesen drei Operatoren erzeugte beobachtbare Verhalten ist sehr speziell und eingeschränkt. Es ist nützlich zum Testen und wird manchmal in Kombination mit anderen Observablen oder als Parameter anderer Operatoren verwendet, die Observables erfordern.

RxJava implementiert diese Operatoren als leer, nie und Fehler. Der Fehleroperator erfordert einen Throwable-Parameter, mit dem Ihr Observable beendet wird. Diese Operatoren werden standardmäßig nicht auf einem bestimmten Scheduler ausgeführt, aber empty und error verfügen über einen optionalen Parameter namens Scheduler. Wenn Sie den Scheduler-Parameter übergeben, senden sie Benachrichtigungen über diesen Scheduler.

4.Nur

Wenn der Beobachter Daten an den Beobachter senden möchte, lautet der Code wie folgt:

Wenn der obige Code senden möchte Daten müssen Sie zuerst Um die Schnittstelle Observable.OnSubscribe zu implementieren, können wir stattdessen die Funktion just verwenden. Der Beispielcode lautet wie folgt:

Ausgabe:

Konvertieren Sie einfach einzelne Daten in ein Observable, das diese Daten ausgibt.

Ähnliche Funktionen sind:

Observable
    .create(new Observable.OnSubscribe<String>() {
        @Override
        public void call(Subscriber<? super String> subscriber) {
            subscriber.onNext("hello Android");
        }
    })
    .subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            Log.i(TAG, "call: "+s);
        }
    });

just(T t1);

Observable
    .just("hello Android")
    .subscribe(new Action1<String>() {
        @Override
        public void call(String s) {
            Log.i(TAG, "call: "+s);
        }
    });

onNext: hello Android
Sequence complete.

just(T t1,T t2); 🎜>

just(T t1,T t2,T t3);

• just(T t1,T t2,T t3,T t4) ;

• just(T t1,T t2,T t3,T t4,T t5);

• …

• RxJava implementiert diesen Operator als reine Funktion, die ein bis neun Parameter akzeptiert und ein Observable zurückgibt, das diese Daten in der Reihenfolge der Parameterliste ausgibt.

5.From

• Im Vergleich zur Just-Funktion, die eins bis neun Daten sendet, sendet die From-Funktion eine Datenwarteschlange und die Ausgabelänge ist unbegrenzt.

• Die Schule eröffnete eine Interessenklasse und mehrere Klassenkameraden kamen zu Beginn des Semesters in die Klasse. Das Folgende ist die Definition der Klassenkameradenklasse:

Hier wird eine Sammlung erstellt, um die Informationen jedes Klassenkameraden zu speichern.

Der nächste Kommentar des Lehrers ist, dass jeder anrufen sollte. Hier wird der Anmeldestatus jedes Schülers durch Drucken erklärt.

1. public static class Student {
   
       public String name;
       public int age;
   
       public Student(String name, int age) {
           this.name = name;
           this.age = age;
       }
   
       @Override
       public String toString() {
           return "Student{" +
                   "name='" + name + '\'' +
                   ", age=" + age +
                   '}';
       }
   }

RxJava konvertiert wie folgt:

2. 6.Interval&Timer

   private ArrayList initPersons() {
       ArrayList<Student> persons = new ArrayList<>();
       persons.add(new Student("张三", 16));
       persons.add(new Student("李四", 17));
       persons.add(new Student("王二麻子", 18));
       return persons;
   }

Erstellen Sie ein Observable, das in festen Intervallen eine Folge von Ganzzahlen ausgibt .

3. RxJava implementiert diesen Operator als Intervallmethode. Es akzeptiert einen Parameter, der das Zeitintervall darstellt, und einen Parameter, der die Zeiteinheit darstellt.

   ArrayList persons = initPersons();
   for (int i = 0; i < persons.size(); i++) {
       //打印每个同学
       Log.i(TAG,persons.get(i).toString());
   }

Ausgabe:

Der obige Code druckt kontinuierlich Daten im untergeordneten Thread gemäß einem bestimmten Zeitintervall. Dieser Vorgang ähnelt der Timer-Aufgabe und kann auch als Ersatz für den Timer-Timer angesehen werden.

//1.定义被观察者,用来发送一个队列的事件
Observable<Student> observable = Observable.from(persons);

//2.当开始订阅的时候 接收被观察者发送过来的一系列事件
observable.subscribe(new Action1<Student>() {
    @Override
    public void call(Student student) {
        Log.i(TAG, "call: "+student.toString());
    }
});

Eine ähnliche Funktion ist die timer()-Funktion.

7.Range

Erstellen Sie ein Observable, das eine bestimmte Folge von Ganzzahlen ausgibt.

//3000毫米发送一个请求 该请求包含了一个自增长的整数型变量
Observable<Long> observable = Observable.interval(3000,         TimeUnit.MILLISECONDS, Schedulers.io());

observable.subscribe(new Action1<Long>() {
    @Override
    public void call(Long i) {
        // such as printf RxIoScheduler-2call: 685
        Log.i(TAG, Thread.currentThread().getName()+"call: "+i);
    }
});

Der Range-Operator gibt eine geordnete Folge von ganzen Zahlen innerhalb eines Bereichs aus. Sie können den Anfang und die Länge des Bereichs angeben.

比如下面这个班级的所有学生都在一个集合里，现在要打印出来，可以是这样的：

private ArrayList initPersons() {
    ArrayList<Student> persons = new ArrayList<>();
    persons.add(new Student("张三", 16));
    persons.add(new Student("李四", 17));
    persons.add(new Student("王二麻子", 18));
    return persons;
}


final ArrayList students = initPersons();
//这里发射一个起始值0，长度students.size()的索引 用来遍历队列
Observable
        .range(0,students.size())
        .subscribe(new Action1() {
            @Override
            public void call(Integer index) {
                Log.i(TAG, "call: "+students.get(index));
            }
        });

8.Repeat

创建一个发射特定数据重复多次的Observable

Repeat重复地发射数据。某些实现允许你重复的发射某个数据序列，还有一些允许你限制重复的次数。

//设置重复发送3次
Observable<String> observable = Observable.just("Hello Android").repeat(3);

Action1<String> action1 = new Action1<String>() {

    @Override
    public void call(String s) {
        Log.i(TAG, "call: " + s);
    }
};
observable.subscribe(action1);

 以上就是深入浅出RxJava_03[被观察者创建操作]的详细介绍的内容，更多相关内容请关注PHP中文网（www.php.cn）！