Une introduction détaillée à RxJava_03 [opération de création d'observateur] en termes simples

Ce tutoriel est basé sur RxJava1 >Les fonctions suivantes sont toutes des fonctions utilisées pour créer des observables. Nous pouvons créer les fonctions correspondantes selon les besoins.
Créer - la fonction de création d'Observable originale

Différer - un Observable créé après la création d'un abonnement
Vide/Jamais/Lancer - Créez un observable qui n'envoie aucune donnée/pour envoyer des données d'exception
Juste - Créez un observable qui envoie 1 à 9 valeurs
De - Créer un observable qui émet une file d'attente
Intervalle et minuterie - Créer un observable de type minuterie
Plage - Créer un Observable
Répétition qui envoie un type entier spécifique
7. Vous pouvez utiliser l'opérateur Create pour créer un Observable à partir de zéro, passer à cet opérateur une fonction qui accepte un observateur en paramètre, et écrivez cette fonction pour qu'elle se comporte comme un observable – en appelant de manière appropriée les méthodes onNext, onError et onCompleted de l'observateur.
   Un observable fini bien formé doit tenter d'appeler le onCompleted de l'observateur exactement une fois ou son onError exactement une fois, et ne peut appeler aucune autre méthode de l'observateur par la suite.
8. Il est recommandé de vérifier le statut isUnsubscribe de l'observateur dans la fonction passée à la méthode create, afin que votre Observable puisse arrêter d'émettre des données ou d'effectuer des opérations coûteuses lorsqu'il n'y a pas d'observateurs.
   Exemple de code :

Sortie :

2 Différer

L'Observable n'est pas créé tant qu'un observateur ne s'abonne pas, et l'est. Chaque observateur crée un nouvel observable.

L'opérateur Defer attend qu'un observateur s'y abonne, puis il génère un Observable en utilisant la méthode de fabrique Observable. Il fait cela pour chaque observateur, donc bien que chaque abonné pense s'abonner au même observable, en fait chaque abonné obtient sa propre séquence de données distincte.

Le code est le suivant :

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.Vide/Jamais/Lancer

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

Vide

Créer un Observable qui n'émet aucune donnée mais se termine normalement

Jamais

Crée un observable qui n'émet pas de données et se termine par une erreur

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) {
    }
});

Lancer

Crée un observable qui n'émet pas de données et se termine par une erreur

Le comportement Observable généré par ces trois opérateurs est très particulier et restreint. Il est utile pour les tests et parfois utilisé en combinaison avec d'autres observables, ou comme paramètres d'autres opérateurs nécessitant des observables.

RxJava implémente ces opérateurs comme vide, jamais et erreur. L'opérateur d'erreur nécessite un paramètre Throwable, avec lequel votre Observable se terminera. Ces opérateurs ne s'exécutent par défaut sur aucun planificateur spécifique, mais vide et erreur ont un paramètre facultatif appelé Scheduler. Si vous transmettez le paramètre Scheduler, ils enverront des notifications sur ce planificateur.

4.Just

Si l'observateur souhaite envoyer une donnée à l'observateur, alors le code est le suivant :

Si le code ci-dessus veut envoyer data, vous devez d'abord Pour implémenter l'interface Observable.OnSubscribe, nous pouvons utiliser la fonction just à la place. L'exemple de code est le suivant :

Sortie :

Convertissez simplement une seule donnée en un observable qui émet ces données.

Les fonctions similaires sont :

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); 🎜>

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

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

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

• …

• RxJava implémente cet opérateur comme une fonction juste, qui accepte un à neuf paramètres et renvoie un observable qui émet ces données dans l'ordre de la liste des paramètres.

5.From

• Par rapport à la fonction juste qui envoie une à 9 données, la fonction From envoie une file d'attente de données et la longueur de sortie est illimitée.

• L'école a ouvert une classe d'intérêt et plusieurs camarades de classe sont venus en classe au début du trimestre. Voici la définition de la classe camarade de classe :

Une collection est créée ici pour stocker les informations de chaque camarade de classe.

Le prochain commentaire de l'enseignant est que tout le monde devrait appeler. Ici, le statut de connexion de chaque élève est expliqué en caractères d'imprimerie.

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 convertit comme ceci :

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;
   }

Créer un observable qui émet une séquence d'entiers à intervalles fixes .

3. RxJava implémente cet opérateur comme méthode d'intervalle. Il accepte un paramètre représentant l'intervalle de temps et un paramètre représentant l'unité de temps.

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

Sortie :

Le code ci-dessus imprime en continu les données dans le thread enfant selon un certain intervalle de temps. Cette opération est similaire à la tâche Timer, et vous pouvez également la considérer comme remplaçant le timer Timer.

//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());
    }
});

Une fonction similaire est la fonction timer().

7.Range

Créez un observable qui émet une séquence spécifique d'entiers.

//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);
    }
});

L'opérateur Range émet une séquence ordonnée d'entiers dans une plage. Vous pouvez spécifier le début et la longueur de la plage.

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

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）！