[GO] Muster der Verantwortungskette in Java

Einführung

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

Muster der Verantwortungskette

Was ist eine Verantwortungskette?

Ins Japanische übersetzt bedeutet es "Verantwortungskette". ** Ein Muster, das mehrere Objekte wie eine Kette verbindet und durch jedes Objekt geht, um das Zielobjekt zu bestimmen **, wird als ** Muster der Verantwortungskette ** bezeichnet. Als Bild wird beim Versuch, Arbeitsdokumente einzureichen, das Einreichungsziel in Herr A in der Personalabteilung → Herr B in der Buchhaltungsabteilung → Herr C in der Abteilung für allgemeine Angelegenheiten geändert. Ich denke es ist leicht zu verstehen. Durch Anwenden dieses Musters ist es möglich, die Verbindung zwischen der "anfordernden Seite" und der "ausführenden Seite" zu schwächen, so dass jede in Teile zerlegt werden kann. Im Gegenteil, wenn dieses Muster nicht verwendet wird, muss der "Verarbeitungsanforderer" über zentralisierte Informationen verfügen, dass diese Verarbeitung von diesem Objekt angefordert werden muss, und wenn dies erfolgt, geht die Unabhängigkeit als Teil verloren, sodass sie wiederhergestellt wird. Es wird schwierig zu bedienen sein.

Charakter

Das Muster der Verantwortungskette wird von den Klassen verwendet, die im folgenden Klassendiagramm angezeigt werden. image.png

Abstrakte Klasse

Implementierungsklasse

Konkretes Beispiel

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

Andere Klassen

Trouble.java


public class Trouble {

	private int number; //Störungsnummer
	private String content; //Fehlerinhalt
	private int level; //Schwierigkeitsgrad

	public Trouble(int number, String content, int level) { //Konstruktorprobleme erzeugen
		this.number = number;
		this.content = content;
		this.level = level;
	}

	public int getLevel() {
		return level;
	}

	public void setLevel(int revel) {
		this.level = revel;
	}

	public String getContent() {
		return content;
	}

	public void setContent(String content) {
		this.content = content;
	}

	public int getNumber() {
		return number;
	}

	public String toString() { //Zeichenketten-Darstellung von Problemen
		return "[#" + number + " " + content + "(" + level + ")" + "]";
	}

}

Die Klasse "Trouble" ist eine Klasse, die die aufgetretenen Probleme darstellt. Es gibt eine Fehlernummer, einen Fehlerinhalt und eine Fehlerstufe im Feld. Es gibt nichts besonders Schwieriges.

Abstrakte Klasse

Responsible.java


public abstract class Responsible {

	private String name; //Der Name dieser Fehlerbehebung
	private Responsible next; //Die Spitze der Wanne

	public Responsible(String name) { //Generieren Sie einen Konstruktor-Problemlöser
		this.name = name;
	}

	public String getName() {
		return this.name;
	}

	public Responsible setNext(Responsible next) { //Stellen Sie die Spitze der Wanne ein
		this.next = next;
		return next;
	}

	public void support(Trouble trouble) { //Verfahren zur Fehlerbehebung
		if (resolve(trouble)) {//Wenn das Problem behoben werden kann
			done(trouble);
		} else if (next != null) {//Wenn das Problem nicht gelöst werden konnte, aber das Ziel der nächsten Runde festgelegt ist
			next.support(trouble);
		} else {//Wenn das Problem nicht gelöst werden kann und das Ziel der nächsten Runde nicht festgelegt ist
			fail(trouble);
		}
	}

	protected abstract boolean resolve(Trouble trouble); //Lösungsmethode

	protected void done(Trouble trouble) { //Lösung
		System.out.println(trouble + "Ist" + getName() + "Wurde gelöst.");
	}

	protected void fail(Trouble trouble) { //ungelöst
		System.out.println("【Warnung】" + trouble + "Konnte von niemandem gelöst werden.");
	}

}

Die Klasse "Verantwortlich" ist eine Klasse zum Erstellen einer Kette, die Probleme löst. Die Punkte sind die folgenden vier Punkte.

** 1. ** Haben Sie ein Ziel im Feld "Nächster" für die nächste Runde. ** 2. ** Verwenden Sie die Methode "setNext", um das Ziel festzulegen und zurückzugeben. ** 3. ** Die "Support" -Methode definiert das Verfahren zur Fehlerbehebung. ** 4. ** Die Auflösungsmethode wird als abstrakte Methode definiert und in einer Unterklasse implementiert.

Ich werde die Punkte 1, 2 und 3 ergänzen. In Bezug auf Punkt 1 ist das nächste zu setzende Ziel die Unterklasse (Implementierungsklasse) der Klasse "Verantwortlich", also Unterklasse A von "Verantwortlich" → Unterklasse B von "Verantwortlich" → Unterklasse C von "Verantwortlich" ... Sie können eine solche Verantwortungskette erstellen. Als nächstes legen Sie in Bezug auf Punkt 2 das Ziel fest, das mit der Methode "setNext" umgedreht werden soll. Da das zu diesem Zeitpunkt festgelegte Ziel zurückgegeben wird, können Methoden wie hoge.setNext (foo) .setNext (bar) .... ausgeführt werden. In Bezug auf Punkt 3 schließlich hat die "Support" -Methode ein Problem, das als Argument gelöst werden muss, die abstrakte Methode "Resolution" wird aufgerufen, und wenn der Rückgabewert wahr (gelöst) ist, wird das Problem durch die "done" -Methode gelöst. Zeigt, was Sie getan haben. Wenn der Rückgabewert falsch (ungelöst) ist und das nächste Bindungsziel festgelegt ist, rufen Sie die "Support" -Methode des nächsten Bindungsziels auf, um die Lösung des Problems dem nächsten Bindungsziel anzuvertrauen. Ich werde. Wenn der Rückgabewert jedoch falsch (ungelöst) ist und das nächste Durchquerungsziel nicht festgelegt ist, bedeutet dies, dass es das Ende der Kette ist und keines der Objekte verarbeitet werden konnte `Zeigt an, dass das Problem mit der Methode nicht behoben werden konnte.

Implementierungsklasse

Employee.java


public class Employee extends Responsible {

	private int limitLevel = 1; //Es kann gelöst werden, wenn es unter diesem Niveau liegt

	public Employee(String name) { //Konstrukteur
		super(name);
	}

	@Override
	protected boolean resolve(Trouble trouble) { //Lösungsmethode
		if (trouble.getLevel() <= limitLevel) {
			return true;
		} else {
			return false;
		}
	}

}

Chief.java


public class Chief extends Responsible {

	private int limitLevel = 5; //Es kann gelöst werden, wenn es unter diesem Niveau liegt

	public Chief(String name) { //Konstrukteur
		super(name);
	}

	@Override
	protected boolean resolve(Trouble trouble) { //Lösungsmethode
		if (trouble.getLevel() <= limitLevel) {
			return true;
		} else {
			return false;
		}
	}

}

Manager.java


public class Manager extends Responsible {

	private int limitLevel = 10; //Es kann gelöst werden, wenn es unter diesem Niveau liegt

	public Manager(String name) { //Konstrukteur
		super(name);
	}

	@Override
	protected boolean resolve(Trouble trouble) { //Lösungsmethode
		if (trouble.getLevel() <= limitLevel) {
			return true;
		} else {
			return false;
		}
	}

}

President.java


public class President extends Responsible {

	private int limitLevel = 20; //Es kann gelöst werden, wenn es unter diesem Niveau liegt

	public President(String name) { //Konstrukteur
		super(name);
	}

	@Override
	protected boolean resolve(Trouble trouble) { //Lösungsmethode
		if (trouble.getLevel() <= limitLevel) {
			return true;
		} else {
			return false;
		}
	}

}

Die Klassen "Mitarbeiter", "Chef", "Manager" und "Präsident" sind Implementierungsklassen der Klasse "Verantwortlich". Jedes hat eine Obergrenze der Problemstufe, die für sich selbst gelöst werden kann, und die "Auflösungs" -Methode der abstrakten Methode wird überschrieben, damit Probleme innerhalb des Bereichs, der diese Obergrenze nicht überschreitet, gelöst werden können.

Ausführungsklasse

-** Hauptklasse **

Main.java


public class Main {
	
	public static void main(String[] args) {

		//Erstellen einer Fehlerbehebung
		Responsible employee = new Employee("Ein Mitarbeiter");
		Responsible chief = new Chief("Manager der Sektion B.");
		Responsible manager = new Manager("Regisseur C.");
		Responsible president = new President("Präsident D.");

		//Kettenbildung
		employee.setNext(chief).setNext(manager).setNext(president);

		//Es treten verschiedene Probleme auf
		employee.support(new Trouble(1, "Umgang mit Kundenbeschwerden", 1));
		employee.support(new Trouble(2, "Unterstützung für Geschäftsreisen nach Übersee", 10));
		employee.support(new Trouble(3, "Weltfrieden", 100));
		employee.support(new Trouble(4, "Schätzen Sie die Unterstützung bei der Erstellung", 5));
		employee.support(new Trouble(5, "Formulierung von Managementrichtlinien", 20));

	}
	
}

Erstellen Sie zunächst eine Fehlerbehebung. Als nächstes wird die Kette durch Aufrufen der Methode "setNext" für jedes Objekt gebildet. Erstellen Sie abschließend das Problem, das Sie lösen möchten, und übergeben Sie es als Argument an die "support" -Methode des "employee" -Objekts.

Ausführungsergebnis

Das Ergebnis der Ausführung von "Main.java" ist wie folgt. Sie können sehen, dass wir uns innerhalb der Schwierigkeitsstufe jedes Objekts befinden. Darüber hinaus gibt es eine Ausgabe, die das Problem, mit dem niemand umgehen konnte, nicht lösen konnte.

Ausführungsergebnis


[#1 Antwort auf Kundenbeschwerde(1)]Wurde von einem Mitarbeiter gelöst.
[#2 Unterstützung für Geschäftsreisen nach Übersee(10)]Wurde von Direktor C. gelöst.
【Warnung】[#3 Weltfrieden(100)]Konnte von niemandem gelöst werden.
[#4 Unterstützung für Schätzungen(5)]Wurde von Abschnitt B gelöst.
[#5 Formulierung der Verwaltungsrichtlinie(20)]Wurde von Präsident D. beschlossen.

verdienen

Die Vorteile des Chain of Responsibility-Musters sind wie folgt. ** 1. ** Durch Schwächen der Verbindung zwischen der anfordernden Seite und der Verarbeitungsseite wird die Unabhängigkeit der Verarbeitung (Partifizierung) verbessert. ** 2. ** Da die Verarbeitungsklasse nur die Verarbeitung im Rahmen ihrer eigenen Verantwortung implementiert, kann sie kurz beschrieben werden.

Fehler

Im Gegenteil, die Nachteile des Musters der Verantwortungskette sind wie folgt. ** 1. ** Die Verarbeitung ist langsam, da die Kette von Grund auf neu verfolgt werden muss. → Wenn die Beziehung zwischen Anforderung und Verarbeitung festgelegt ist und die Verarbeitungsgeschwindigkeit wichtig ist, sollte dieses Muster nicht angewendet werden.

Zusammenfassung

Sie haben das Muster der Verantwortungskette kennengelernt, das bestimmt, welche Objekte verarbeitet werden sollen, indem die Verantwortung umgedreht wird. Der Beispielcode wird unten hochgeladen. Wenn Sie möchten, lesen Sie ihn bitte.

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

Verweise

Recommended Posts

Muster der Verantwortungskette in Java
Lernen Sie das Entwurfsmuster "Chain of Responsibility" in Python
Fassadenmuster in Java
Singleton-Muster in Java
Fliegengewichtsmuster in Java
Iteratormuster in Java
Prototypmuster in Java
Proxy-Muster in Java
[Viererbande] Designmuster lernen - Kette der Verantwortung
Muster der Vorlagenmethode in Java
Lernen der Mustererkennung im Video Teil 1 Bereich der Mustererkennung
Singleton-Muster in Python
Linux-Berechtigungen für Java
Ich habe über Designmuster (persönliches Memo) Teil 6 (Muster der Verantwortungskette, Fassadenmuster, Vermittlermuster) studiert.
Verwenden Sie DataFrame in Java
Überprüfen Sie, ob in Java BigQuery-Tabellen vorhanden sind
Zusammenfassung der Prototypmuster der Einführung in Entwurfsmuster, die in Java gelernt wurden
Lassen Sie uns das Ausführungsergebnis des Programms mit C ++, Java, Python messen.
Das Ergebnis des maschinellen Lernens von Java-Ingenieuren mit Python www
Beispielquelle für das von Java, PHP, Python realisierte Observer-Muster
Singleton-Musterzusammenfassung der Einführung in Entwurfsmuster, die in Java gelernt wurden
Teilweise bei Problemen
Liste der Knoten in Diagrammen
Objektäquivalenzbeurteilung in Python
Implementierung der schnellen Sortierung in Python
So implementieren Sie Java-Code im Hintergrund von Red Hat (Linux ONE)
Kapitel 4 Zusammenfassung der Einführung in Entwurfsmuster, die in Java gelernt wurden
Zusammenfassung von Kapitel 3 der Einführung in Entwurfsmuster, die in Java gelernt wurden