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 de chaîne de responsabilité

Qu'est-ce que la chaîne de responsabilité?

Traduit en japonais, cela signifie «chaîne de responsabilité». ** Un modèle qui relie plusieurs objets comme une chaîne et parcourt chaque objet afin de déterminer l'objet cible ** est appelé le ** modèle de chaîne de responsabilité **. À titre d'image, lors d'une tentative de soumission de documents de travail, la destination de soumission est changée en M. A dans le service du personnel → M. B dans le service comptable → M. C dans le service des affaires générales ** Je pense que c'est facile à comprendre. En appliquant ce motif, il est possible d'affaiblir la connexion entre le "côté demandeur" et le "côté d'exécution", de sorte que chacun peut être transformé en parties. Au contraire, si ce modèle n'est pas utilisé, le "demandeur de traitement" doit disposer d'informations centralisées que ce traitement doit être demandé à cet objet, et si cela est fait, l'indépendance en tant que partie sera perdue. Ce sera difficile à utiliser.

Personnage

Le modèle Chaîne de responsabilité est utilisé par les classes qui apparaissent dans le diagramme de classes ci-dessous.

Classe abstraite

Handler
Cette classe sert de modèle pour la classe qui traite les demandes. Le champ a une destination nxet pour passer à l'objet suivant, et la méthode a une demande pour passer à l'objet suivant. La caractéristique est que ** la destination à inverser hérite également de cette classe Handler **. En faisant cela, il devient possible de connecter les chaînes les unes après les autres.

Classe d'implémentation

ConcreteHandler Une classe d'implémentation pour la classe Handler. Effectue un traitement spécifique sur la demande.
Client Une classe qui émet une requête à la classe ConcreteHandler. Il n'y a rien de particulièrement difficile.

Exemple concret

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

Autres classes

** Classe de problèmes **

`Trouble.java`


public class Trouble {

	private int number; //Numéro de problème
	private String content; //Contenu de problème
	private int level; //Niveau de problème

	public Trouble(int number, String content, int level) { //Générer des problèmes de constructeur
		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() { //Représentation sous forme de chaîne de caractères du problème
		return "[#" + number + " " + content + "(" + level + ")" + "]";
	}

}

La classe «Trouble» est une classe qui représente le problème survenu. Il a un numéro de problème, un contenu de problème et un niveau de problème sur le terrain. Il n'y a rien de particulièrement difficile.

Classe abstraite

** Classe responsable **

`Responsible.java`


public abstract class Responsible {

	private String name; //Le nom de cet outil de dépannage
	private Responsible next; //La pointe de la baignoire

	public Responsible(String name) { //Générer un solveur de problèmes de constructeur
		this.name = name;
	}

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

	public Responsible setNext(Responsible next) { //Réglez la pointe de la baignoire
		this.next = next;
		return next;
	}

	public void support(Trouble trouble) { //Procédure de résolution des problèmes
		if (resolve(trouble)) {//Si le problème peut être résolu
			done(trouble);
		} else if (next != null) {//Lorsque le problème n'a pas pu être résolu mais que la destination du prochain virage est définie
			next.support(trouble);
		} else {//Lorsque le problème ne peut pas être résolu et que la destination du prochain virage n'est pas définie
			fail(trouble);
		}
	}

	protected abstract boolean resolve(Trouble trouble); //Méthode de solution

	protected void done(Trouble trouble) { //Solution
		System.out.println(trouble + "Est" + getName() + "A été résolu.");
	}

	protected void fail(Trouble trouble) { //non résolu
		System.out.println("【avertissement】" + trouble + "Ne pouvait être résolu par personne.");
	}

}

La classe Responsible est une classe pour créer une chaîne qui résout des problèmes. Les points sont les quatre points suivants.

** 1. ** Avoir une destination dans le champ «suivant» pour le prochain virage. ** 2. ** Utilisez la méthode setNext pour définir et renvoyer la destination. ** 3. ** La méthode support définit la procédure de dépannage. ** 4. ** La méthode resolution est définie comme une méthode abstraite et implémentée dans une sous-classe.

Je compléterai les points 1, 2 et 3. En ce qui concerne le point 1, la prochaine destination à définir est la sous-classe (classe d'implémentation) de la classe «Responsable», donc sous-classe A de «Responsable» → sous-classe B de «Responsable» → sous-classe C de «Responsable» ... Vous pouvez créer une chaîne de responsabilités comme celle-ci. Ensuite, concernant le point 2, définissez la destination pour faire demi-tour avec la méthode setNext. Puisque la destination définie à ce moment est retournée, il est possible d'exécuter des méthodes telles que hoge.setNext (foo) .setNext (bar) ..... Enfin, concernant le point 3, la méthode support a un problème à résoudre en argument, la méthode abstraiteresolution est appelée, et si la valeur de retour est vraie (résolue), le problème est résolu par la méthode done. Montre ce que vous avez fait. Si la valeur de retour est false (non résolue) et que la prochaine destination de liage est définie, appelez la méthode support de la prochaine destination de liage pour confier la solution du problème à la prochaine destination de liage. Je vais. Cependant, si la valeur de retour est false (non résolue) et que la prochaine destination de traversée n'est pas définie, cela signifie qu'il s'agit de la fin de la chaîne et qu'aucun des objets n'a pu être traité, donc fail Affiche que le problème n'a pas pu être résolu par la méthode.

Classe d'implémentation

** Classe d'employé **

`Employee.java`


public class Employee extends Responsible {

	private int limitLevel = 1; //Il peut être résolu s'il est en dessous de ce niveau

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

	@Override
	protected boolean resolve(Trouble trouble) { //Méthode de solution
		if (trouble.getLevel() <= limitLevel) {
			return true;
		} else {
			return false;
		}
	}

}

** Classe de chef **

`Chief.java`


public class Chief extends Responsible {

	private int limitLevel = 5; //Il peut être résolu s'il est en dessous de ce niveau

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

	@Override
	protected boolean resolve(Trouble trouble) { //Méthode de solution
		if (trouble.getLevel() <= limitLevel) {
			return true;
		} else {
			return false;
		}
	}

}

** Classe de manager **

`Manager.java`


public class Manager extends Responsible {

	private int limitLevel = 10; //Il peut être résolu s'il est en dessous de ce niveau

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

	@Override
	protected boolean resolve(Trouble trouble) { //Méthode de solution
		if (trouble.getLevel() <= limitLevel) {
			return true;
		} else {
			return false;
		}
	}

}

** Classe président **

`President.java`


public class President extends Responsible {

	private int limitLevel = 20; //Il peut être résolu s'il est en dessous de ce niveau

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

	@Override
	protected boolean resolve(Trouble trouble) { //Méthode de solution
		if (trouble.getLevel() <= limitLevel) {
			return true;
		} else {
			return false;
		}
	}

}

La classe ʻEmployee, la classe Chief, la classe Manageret la classePresident sont des classes d'implémentation de la classe Responsible. Chacun a une limite supérieure du niveau de problème qui peut être résolu par lui-même, et la méthode résoudre 'de la méthode abstraite est remplacée afin que les problèmes dans la plage qui ne dépasse pas cette limite supérieure puissent être résolus.

Classe d'exécution

** Classe principale **

`Main.java`


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

		//Créer un outil de dépannage
		Responsible employee = new Employee("Un employé");
		Responsible chief = new Chief("Gestionnaire de section B");
		Responsible manager = new Manager("Directeur C");
		Responsible president = new President("Président D");

		//Formation de la chaîne
		employee.setNext(chief).setNext(manager).setNext(president);

		//Divers problèmes surviennent
		employee.support(new Trouble(1, "Traitement des plaintes des clients", 1));
		employee.support(new Trouble(2, "Soutien aux voyages d'affaires à l'étranger", 10));
		employee.support(new Trouble(3, "paix mondiale", 100));
		employee.support(new Trouble(4, "Estimer l'aide à la création", 5));
		employee.support(new Trouble(5, "Formulation de la politique de gestion", 20));

	}
	
}

Commencez par créer un outil de dépannage. Ensuite, la chaîne est formée en appelant la méthode setNext pour chaque objet. Enfin, créez le problème que vous voulez résoudre et passez-le comme argument à la méthode support de l'objet ʻemployee`.

Résultat d'exécution

Le résultat de l'exécution de Main.java est le suivant. Vous pouvez voir que nous nous occupons du niveau de problème de chaque objet. De plus, il y a une sortie que le problème que personne ne pouvait gérer n'a pas pu être résolu.

`Résultat d'exécution`


[#1 Réponse à la plainte du client(1)]A été résolu par un employé.
[#2 Aide aux voyages d'affaires à l'étranger(10)]A été résolu par le directeur C.
【avertissement】[#3 Paix mondiale(100)]Ne pouvait être résolu par personne.
[#4 Aide à la réalisation d'estimations(5)]A été résolu par la section B.
[#5 Formulation de la politique de gestion(20)]A été résolu par le président D.

mérite

Les avantages du modèle de chaîne de responsabilité sont les suivants. ** 1. ** En affaiblissant la connexion entre le côté demandeur et le côté traitement, l'indépendance du traitement (partification) est améliorée. ** 2. ** Puisque la classe de traitement n'implémente que le traitement sous sa propre responsabilité, il peut être décrit de manière concise.

Démérite

Au contraire, les inconvénients du modèle de chaîne de responsabilité sont les suivants. ** 1. ** Le traitement est lent car la chaîne doit être tracée à partir de zéro. → Si la relation entre la demande et le traitement est fixe et que la vitesse de traitement est importante, ce modèle ne doit pas être appliqué.

Résumé

Vous avez découvert le modèle de chaîne de responsabilité, qui détermine les objets à traiter en retournant la responsabilité. L'exemple de code est téléchargé ci-dessous, veuillez donc vous y référer si vous le souhaitez.

Exemple de code de chaîne de responsabilité

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)

Modèle de chaîne de responsabilité en Java

introduction

Modèle de chaîne de responsabilité

Qu'est-ce que la chaîne de responsabilité?

Personnage

Classe abstraite

Classe d'implémentation

Exemple concret

Autres classes

Trouble.java

Classe abstraite

Responsible.java

Classe d'implémentation

Employee.java

Chief.java

Manager.java

President.java

Classe d'exécution

Main.java

Résultat d'exécution

Résultat d'exécution

mérite

Démérite

Résumé

Les références

`Trouble.java`

`Responsible.java`

`Employee.java`

`Chief.java`

`Manager.java`

`President.java`

`Main.java`

`Résultat d'exécution`