Modèle de chaîne de responsabilité 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 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. image.png

Classe abstraite

Classe d'implémentation

Exemple concret

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

Autres classes

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

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

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;
		}
	}

}

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;
		}
	}

}

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;
		}
	}

}

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

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.

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

Les références

Recommended Posts

Modèle de chaîne de responsabilité en Java
Apprenez le modèle de conception «Chaîne de responsabilité» en Python
Modèle de façade en Java
Motif singleton en Java
Modèle de poids mouche en Java
Modèle d'itérateur en Java
Modèle de prototype en Java
Modèle de proxy en Java
[Gang of Four] Apprentissage des modèles de conception - Chaîne de responsabilité
Modèle de méthode de modèle en Java
Apprentissage de la reconnaissance de formes en vidéo Partie 1 Champ de reconnaissance de formes
Motif singleton en Python
Autorisations Linux sur Java
J'ai étudié les modèles de conception (mémo personnel) Partie 6 (modèle de chaîne de responsabilité, modèle de façade, modèle de médiateur)
Utiliser DataFrame en Java
Vérifier l'existence de tables BigQuery en Java
Résumé des modèles de prototypes d'introduction aux modèles de conception appris en langage Java
Mesurons le résultat de l'exécution du programme avec C ++, Java, Python.
Le résultat de l'apprentissage automatique des ingénieurs Java avec Python www
Exemple de source du modèle Observer réalisé par Java, PHP, Python
Résumé des modèles singleton de l'introduction aux modèles de conception appris en langage Java
Partiel en cas de problème
Liste des nœuds dans les diagrammes
Jugement d'équivalence d'objet en Python
Implémentation du tri rapide en Python
Comment implémenter du code Java en arrière-plan de Red Hat (Linux ONE)
Chapitre 4 Résumé de l'introduction aux modèles de conception appris en langage Java
Résumé du chapitre 3 de l'introduction aux modèles de conception appris en langage Java