Modèle d'observateur en Java

introduction

Présentation des modèles de conception de [GoF](https://ja.wikipedia.org/wiki/Gang of for _ (Information Engineering)) ["Introduction aux modèles de conception appris dans le langage Java augmenté et révisé"]( https://www.amazon.co.jp/ Édition augmentée et révisée Introduction aux modèles de conception appris en langage Java-Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? _ Encoding = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGDR5QMHP) Je vais résumer sur.

Modèle d'observateur

Qu'est-ce que l'observateur

Cela signifie «observateur» et «observateur». ** Le modèle qui avertit l'observateur lorsque l'état de l'objet à observer change ** est appelé le ** modèle d'observateur **. Comme cela sera décrit en détail plus loin, il semble qu'il soit parfois appelé ** modèle Publish-Subscribe ** car l'observateur doit notifier l'observateur et l'observateur est dans une position passive. ..

Personnage

Le modèle Observer est utilisé par les classes qui apparaissent dans le diagramme de classes ci-dessous.

Classe abstraite

• Subject C'est la classe à observer. Il a des «observateurs» (plusieurs observateurs) pour s'observer, une méthode pour les enregistrer / supprimer / notifier, et une méthode pour retourner son propre statut. Comme indiqué précédemment, il convient de noter que ** le sujet, qui devrait être l'observateur, tient l'observateur de l'observateur **.

• Observer C'est la classe qui observe le «sujet». Même si vous dites observation, vous saurez que l'état de la cible d'observation n'a changé qu'après avoir été notifié par le sujet.

Classe d'implémentation

• ConcreteSubject C'est la classe qui sera l'observateur concret. Remplace la méthode getSubjectStatus, qui est déclarée dans la classe parente et renvoie son propre état.

• ConcreteObserveer C'est une classe qui sera l'observateur spécifique. Remplace la méthode ʻupdate` déclarée dans la classe parente pour vous avertir que l'état observé a changé.

Exemple concret

À titre d'exemple concret, nous expliquerons en nous basant sur la classe suivante.

Classe abstraite

• ** Classe NumGenerator **

NumGenerator.java

import java.util.ArrayList;
import java.util.List;

public abstract class NumGenerator {

	//Contient une liste d'observateurs
	private List<Observer> observers = new ArrayList<>();

	//Observateur ajouté
	public void addObserver(Observer observer) {
		observers.add(observer);
	}

	//Supprimer l'observateur
	public void deleteObserver(Observer observer) {
		observers.remove(observer);
	}

	//Notifier l'observateur
	public void notifyObservers() {
		for (Observer observer : observers) {
			observer.update(this);
		}
	}

	//Obtenez le numéro
	public abstract int getNumber();

	//Générer un nombre(Mise à jour du statut)
	public abstract void execute();
}

Une classe qui sert de "Sujet" de l'objet à observer. Puisqu'il peut y avoir plusieurs observateurs, nous avons ʻObserverdans List. Il comporte également une méthode pour enregistrer / supprimer des observateurs et une méthode pour notifier les déclarants. La méthodenotifyObservers appelle la méthode ʻupdate pour des observateurs spécifiques.

• ** Classe d'observateur **

Observer.java

public interface Observer {
	public abstract void update(NumGenerator generator);
}

Cette classe est utile pour observer NumGenerator. Nous déclarons une méthode ʻupdate` pour recevoir des notifications, mais laissons l'implémentation à la classe héritière.

Classe d'implémentation

• ** Classe RandomNumGenerator **

RandomNumGenerator.java

import java.util.Random;

public class RandomNumGenerator extends NumGenerator {
	//Générateur aléatoire
	private Random random = new Random();
	//Numéro actuel
	private int number;

	//Obtenez le numéro
	@Override
	public int getNumber() {
		return number;
	}

	//Générer un nombre(Mise à jour du statut)
	@Override
	public void execute() {
		for (int i = 0; i < 10; i++) {
			//Générez un nombre aléatoire compris entre 0 et 20 et mettez à jour le nombre actuel
			number = random.nextInt(21);
			System.out.println("Nombre de boucles:" + (i + 1));
			//Notifier l'observateur qu'un nombre a été généré
			notifyObservers();
		}
	}
}

C'est une classe qui hérite de «NumGenerator» et est une classe cible d'observation spécifique. Il a un champ qui représente un nombre aléatoire et le nombre actuel, et a une méthode pour obtenir le nombre et une méthode pour générer le nombre. Dans la méthode qui génère des nombres, la boucle est tournée 10 fois, et dans chaque boucle, un nombre aléatoire est acquis dans la plage de 0 à 20, et l'état est mis à jour en définissant le nombre aléatoire sur la valeur actuelle. Il notifie également à chaque observateur avec la méthode notifyObservers que le statut a été mis à jour.

• ** Classe DigitObserver **

DigitObserver.java

public class DigitObserver implements Observer {
	@Override
	public void update(NumGenerator generator) {
		//Acquiert et affiche le nombre aléatoire de l'observateur
		System.out.println("DigitObserver:" + generator.getNumber());
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
		}
	}
}

Remplacer la méthode ʻupdate dans une classe qui sert d'observateur concret qui implémente ʻObserver. Cette méthode décrit le traitement effectué par un observateur spécifique lorsque l'observateur notifie la mise à jour. Ici, le nombre aléatoire (numéro actuel mis à jour) de la cible d'observation est affiché.

• ** Classe StringObserver **

StringObserver.java

import org.apache.commons.lang3.RandomStringUtils;

public class StringObserver implements Observer {
	@Override
	public void update(NumGenerator generator) {
		System.out.print("StringObserver:");
		//Acquiert et affiche une chaîne de caractères alphabétiques aléatoires avec le nombre aléatoire de l'observateur comme argument
		System.out.println(RandomStringUtils.randomAlphabetic(generator.getNumber()));
		System.out.println("----------------------------------------");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
		}
	}
}

Semblable à DigitObserver, cette classe sert d'observateur concret. Ici, une chaîne de caractères composée d'un alphabet aléatoire est affichée avec le nombre aléatoire (numéro actuel mis à jour) de la cible d'observation comme argument.

Classe d'exécution

• ** Classe principale **

Main.java

public class Main {
	public static void main(String[] args) {
		//Génération d'une cible d'observation spécifique
		NumGenerator generator = new RandomNumGenerator();
		//Enregistrer un observateur spécifique comme cible d'observation spécifique
		generator.addObserver(new DigitObserver());
		generator.addObserver(new StringObserver());
		//Génération de nombres(Mise à jour du statut)
		generator.execute();
	}
}

Le statut est mis à jour en générant un nombre après la génération d'une cible d'observation spécifique et l'enregistrement d'un observateur spécifique en tant que cible d'observation.

Résultat d'exécution

Le résultat de l'exécution de la classe «Main» est le suivant. Vous pouvez voir que la chaîne de caractères aléatoires pour le nombre de chiffres du nombre aléatoire et le nombre aléatoire est affichée 10 fois.

• Les résultats d'affichage seront différents car des nombres aléatoires sont utilisés.

Résultat d'exécution

Nombre de boucles:1
DigitObserver:14
StringObserver:VNXxKnJCmkbOSG
----------------------------------------
Nombre de boucles:2
DigitObserver:15
StringObserver:FUBpVQotKbSwmMX
----------------------------------------
Nombre de boucles:3
DigitObserver:6
StringObserver:onRlXn
----------------------------------------
Nombre de boucles:4
DigitObserver:18
StringObserver:AehtMZiGkzYgapTgok
----------------------------------------
Nombre de boucles:5
DigitObserver:8
StringObserver:XuRUWXnb
----------------------------------------
Nombre de boucles:6
DigitObserver:11
StringObserver:JHYAeuMfMDO
----------------------------------------
Nombre de boucles:7
DigitObserver:12
StringObserver:sopRShHkheIO
----------------------------------------
Nombre de boucles:8
DigitObserver:11
StringObserver:BLATKGBDccR
----------------------------------------
Nombre de boucles:9
DigitObserver:18
StringObserver:kmSHMbZZftRyGkpaqa
----------------------------------------
Nombre de boucles:10
DigitObserver:15
StringObserver:muYkfeGLfwYqykD
----------------------------------------

mérite

En utilisant le modèle Observer, il est possible de séparer la classe qui contient l'état de la classe qui reçoit la notification du changement d'état, et la réutilisabilité (partitionnement) de la classe est améliorée.

Où utiliser

L'une des utilisations du modèle Observer est la coordination des modèles et des vues dans la mise en œuvre des modèles MVC. Le modèle est des données internes, et le contrôleur détecte les changements dans l'état du modèle (objet observé) et avise la vue (observateur) de coopérer.

Résumé

Vous avez découvert le modèle Observer qui signale les changements d'état d'un objet. L'exemple de code est téléchargé ci-dessous, veuillez donc vous y référer si vous le souhaitez.

• Exemple de code d'observateur

En outre, d'autres modèles de conception sont résumés ci-dessous, veuillez donc vous y référer également.

• [Mis à jour de temps en temps] Résumé des modèles de conception en Java

Les références

• [Introduction aux modèles de conception appris dans le langage Java augmenté et révisé](https://www.amazon.co.jp/ Introduction aux modèles de conception appris dans le langage Java augmenté et révisé-Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? _Encoding = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGDR5QMHP)