[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.
Abstrakte Klasse
- Handler
Diese Klasse dient als Vorlage für die Klasse, die Anforderungen verarbeitet. Das Feld hat ein Ziel "nxet", um zum nächsten Objekt zu gelangen, und die Methode hat eine "Anfrage", um zum nächsten Objekt zu gelangen. Die Funktion ist, dass ** das zu drehende Ziel auch diese Handler-Klasse erbt **. Auf diese Weise wird es möglich, die Ketten nacheinander zu verbinden.
Implementierungsklasse
-
ConcreteHandler Eine Implementierungsklasse für die Handler-Klasse. Führt eine bestimmte Verarbeitung für die Anforderung durch.
-
Client Eine Klasse, die eine Anforderung an die ConcreteHandler-Klasse ausgibt. Es gibt nichts besonders Schwieriges.
Konkretes Beispiel
Als konkretes Beispiel werden wir anhand der folgenden Klasse erklären.
Andere Klassen
- ** Fehlerklasse **
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
- ** Verantwortliche 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
- ** Mitarbeiterklasse **
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;
}
}
}
- ** Hauptklasse **
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;
}
}
}
- ** Managerklasse **
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;
}
}
}
- ** Präsidentenklasse **
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
- [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)
Recommended Posts