[GO] Beobachtermuster in Java

Einführung

Einführung in die Entwurfsmuster von [GoF](https://ja.wikipedia.org/wiki/Gang of for _ (Information Engineering)) ["Einführung in Entwurfsmuster, die in der erweiterten und überarbeiteten Java-Sprache gelernt wurden"]( https://www.amazon.co.jp/ Ergänzende überarbeitete Ausgabe Einführung in in Java gelernte Entwurfsmuster-Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? _ Encoding = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGR Ich werde über zusammenfassen.

Beobachtermuster

Was ist Beobachter?

Es bedeutet "Beobachter" und bedeutet "Beobachter". ** Das Muster, das den Beobachter benachrichtigt, wenn sich der Zustand des zu beobachtenden Objekts ändert **, wird als ** Beobachtermuster ** bezeichnet. Wie später ausführlich beschrieben wird, scheint es manchmal als ** Publish-Subscribe-Muster ** bezeichnet zu werden, da der Beobachter den Beobachter benachrichtigen muss und sich der Beobachter in einer passiven Position befindet. ..

Charakter

Das Observer-Muster wird von den Klassen verwendet, die im folgenden Klassendiagramm angezeigt werden.

Abstrakte Klasse

• Subject Dies ist die zu beobachtende Klasse. Es hat "Beobachter" (mehrere Beobachter), die sich selbst beobachten können, eine Methode, um sie zu registrieren / löschen / benachrichtigen, und eine Methode, um ihren eigenen Status zurückzugeben. Wie bereits erwähnt, sollte beachtet werden, dass ** das Subjekt, das der Beobachter sein sollte, den Beobachter des Beobachters hält **.

• Observer Dies ist die Klasse, die "Subjekt" beobachtet. Selbst wenn Sie Beobachtung sagen, werden Sie wissen, dass sich der Zustand des Beobachtungsziels erst geändert hat, nachdem Sie vom Subjekt benachrichtigt wurden.

Implementierungsklasse

• ConcreteSubject Dies ist die Klasse, die der konkrete Beobachter sein wird. Überschreibt die Methode "getSubjectStatus", die in der übergeordneten Klasse deklariert ist und ihren eigenen Status zurückgibt.

• ConcreteObserveer Dies ist eine Klasse, die der spezifische Beobachter sein wird. Überschreibt die in der übergeordneten Klasse deklarierte update -Methode, um Sie darüber zu informieren, dass sich der beobachtete Status geändert hat.

Konkretes Beispiel

Als konkretes Beispiel werden wir anhand der folgenden Klasse erklären.

Abstrakte Klasse

• ** NumGenerator-Klasse **

NumGenerator.java

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

public abstract class NumGenerator {

	//Enthält eine Liste der Beobachter
	private List<Observer> observers = new ArrayList<>();

	//Beobachter hinzugefügt
	public void addObserver(Observer observer) {
		observers.add(observer);
	}

	//Observer entfernen
	public void deleteObserver(Observer observer) {
		observers.remove(observer);
	}

	//Beobachter benachrichtigen
	public void notifyObservers() {
		for (Observer observer : observers) {
			observer.update(this);
		}
	}

	//Holen Sie sich die Nummer
	public abstract int getNumber();

	//Generieren Sie eine Nummer(Status-Update)
	public abstract void execute();
}

Eine Klasse, die als "Subjekt" des zu beobachtenden Objekts dient. Da es mehrere Beobachter geben kann, haben wir "Beobachter" in der Liste. Es gibt auch eine Methode zum Registrieren / Löschen von Beobachtern und eine Methode zum Benachrichtigen von Registranten. Die Methode "notifyObservers" ruft die Methode "update" für bestimmte Beobachter auf.

• ** Beobachterklasse **

Observer.java

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

Diese Klasse ist nützlich, um NumGenerator zu beobachten. Ich deklariere eine "Update" -Methode, um Benachrichtigungen zu erhalten, überlasse die Implementierung jedoch der ererbenden Klasse.

Implementierungsklasse

• ** RandomNumGenerator-Klasse **

RandomNumGenerator.java

import java.util.Random;

public class RandomNumGenerator extends NumGenerator {
	//Zufallsgenerator
	private Random random = new Random();
	//Aktuelle Nummer
	private int number;

	//Holen Sie sich die Nummer
	@Override
	public int getNumber() {
		return number;
	}

	//Generieren Sie eine Nummer(Status-Update)
	@Override
	public void execute() {
		for (int i = 0; i < 10; i++) {
			//Generieren Sie eine Zufallszahl im Bereich von 0 bis 20 und aktualisieren Sie die aktuelle Zahl
			number = random.nextInt(21);
			System.out.println("Anzahl der Schleifen:" + (i + 1));
			//Benachrichtigen Sie den Beobachter, dass eine Nummer generiert wurde
			notifyObservers();
		}
	}
}

Es ist eine Klasse, die "NumGenerator" erbt und eine bestimmte Beobachtungszielklasse ist. Es hat ein Feld, das eine Zufallszahl und die aktuelle Zahl darstellt, und eine Methode zum Abrufen der Zahl und eine Methode zum Generieren der Zahl. Bei dem Verfahren, das Zahlen erzeugt, wird die Schleife zehnmal gedreht, und in jeder Schleife wird eine Zufallszahl im Bereich von 0 bis 20 erfasst, und der Zustand wird aktualisiert, indem die Zufallszahl auf den aktuellen numerischen Wert gesetzt wird. Außerdem wird jeder Beobachter mit der Methode "notifyObservers" benachrichtigt, dass der Status aktualisiert wurde.

• ** DigitObserver-Klasse **

DigitObserver.java

public class DigitObserver implements Observer {
	@Override
	public void update(NumGenerator generator) {
		//Erfasst die Zufallszahl des Beobachters und zeigt sie an
		System.out.println("DigitObserver:" + generator.getNumber());
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
		}
	}
}

Überschreiben der update -Methode in einer Klasse, die als konkreter Beobachter dient und Observer implementiert. Diese Methode beschreibt die Verarbeitung, die von einem bestimmten Beobachter ausgeführt wird, wenn der Beobachter die Aktualisierung benachrichtigt. Hier wird die Zufallszahl (aktuelle Nummer aktualisiert) des Beobachtungsziels angezeigt.

• ** StringObserver-Klasse **

StringObserver.java

import org.apache.commons.lang3.RandomStringUtils;

public class StringObserver implements Observer {
	@Override
	public void update(NumGenerator generator) {
		System.out.print("StringObserver:");
		//Erfasst eine zufällige alphabetische Zeichenfolge mit der Zufallszahl des Beobachters als Argument und zeigt sie an
		System.out.println(RandomStringUtils.randomAlphabetic(generator.getNumber()));
		System.out.println("----------------------------------------");
		try {
			Thread.sleep(100);
		} catch (InterruptedException e) {
		}
	}
}

Ähnlich wie DigitObserver dient diese Klasse als konkreter Beobachter. Hier wird eine aus einem zufälligen Alphabet bestehende Zeichenkette mit der Zufallszahl (aktuelle Nummer aktualisiert) des Beobachtungsziels als Argument angezeigt.

Ausführungsklasse

-** Hauptklasse **

Main.java

public class Main {
	public static void main(String[] args) {
		//Erzeugung eines spezifischen Beobachtungsziels
		NumGenerator generator = new RandomNumGenerator();
		//Registrieren Sie einen bestimmten Beobachter als ein bestimmtes Beobachtungsziel
		generator.addObserver(new DigitObserver());
		generator.addObserver(new StringObserver());
		//Zahlengenerierung(Status-Update)
		generator.execute();
	}
}

Der Status wird aktualisiert, indem eine Nummer generiert wird, nachdem ein bestimmtes Beobachtungsziel generiert und ein bestimmter Beobachter als Beobachtungsziel registriert wurde.

Ausführungsergebnis

Das Ergebnis der Ausführung der Hauptklasse ist wie folgt. Sie können sehen, dass die zufällige Zeichenfolge für die Anzahl der Ziffern der Zufallszahl und der Zufallszahl zehnmal angezeigt wird.

• Die Anzeigeergebnisse unterscheiden sich, da Zufallszahlen verwendet werden.

Ausführungsergebnis

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

verdienen

Durch Verwendung des Observer-Musters ist es möglich, die Klasse, die den Status enthält, von der Klasse zu trennen, die eine Benachrichtigung über die Änderung des Status erhält, und die Wiederverwendbarkeit (Partitionierung) der Klasse wird verbessert.

Wo zu verwenden

Eine der Anwendungen des Observer-Musters ist die Koordination von Modellen und Ansichten bei der Implementierung von MVC-Modellen. Das Modell besteht aus internen Daten, und der Controller erkennt Änderungen im Status des Modells (beobachtetes Objekt) und benachrichtigt die Ansicht (Beobachter) zur Zusammenarbeit.

Zusammenfassung

Sie haben das Observer-Muster kennengelernt, das Änderungen im Status eines Objekts signalisiert. Der Beispielcode wird unten hochgeladen. Wenn Sie möchten, lesen Sie ihn bitte.

• Beispielcode für Beobachter

Darüber hinaus sind unten weitere Entwurfsmuster zusammengefasst. Bitte beziehen Sie sich auch auf diese.

• [Von Zeit zu Zeit aktualisiert] Zusammenfassung der Entwurfsmuster in Java

Verweise

• [Einführung in Entwurfsmuster, die in der erweiterten und überarbeiteten Java-Sprache gelernt wurden](https://www.amazon.co.jp/ Einführung in Entwurfsmuster, die in der erweiterten und überarbeiteten Java-Sprache gelernt wurden-Yuki-Hiroshi / dp / 4797327030 / ref = pd_lpo_sbs_14_t_0? _Encoding = UTF8 & psc = 1 & refRID = 2ZE4GPYNN55JGDR5QMHP)