Contenu de cet article
1. Introduction au modèle de chaîne de responsabilité
Deuxièmement, l'implémentation du code
Comme son nom l'indique, le modèle de chaîne de responsabilité crée une chaîne d'objets destinataires pour la demande. Ce mode donne le type de requête et découple l'expéditeur et le destinataire de la requête. Ce type de modèle de conception est un modèle de comportement.
Dans ce modèle, chaque destinataire contient généralement une référence à un autre destinataire. Si un objet ne peut pas gérer la demande, il transmettra la même demande au destinataire suivant, et ainsi de suite.
1. Introduction au modèle de chaîne de responsabilité
Intention: pour éviter de coupler l'expéditeur et le destinataire de la demande, permettez à plusieurs objets de recevoir la demande, de connecter ces objets dans une chaîne et de transmettre la demande le long de cette chaîne jusqu'à ce qu'un objet la gère.
La solution principale: le sous-traitant de la chaîne de responsabilité est responsable du traitement de la demande, et le client n'a qu'à envoyer la demande à la chaîne de responsabilité, et n'a pas besoin de se soucier des détails de traitement de la demande et du transfert de la demande. , donc la chaîne de responsabilité sera l'expéditeur de la demande et le processeur de la demande découplée.
Quand l'utiliser: filtrez de nombreux canaux lors du traitement des messages.
Comment résoudre: toutes les classes interceptées implémentent une interface unifiée.
Code clé: Handler s'agrège, juge s'il est approprié dans HandlerRequest et le transmet si les conditions ne sont pas remplies, et le définit avant de le transmettre à qui.
Exemples d'application: 1. "Tambour pour faire passer des fleurs" dans le Dream of Red Mansions. 2. Les événements bouillonnent dans JS. 3. Le traitement de l'encodage par Apache Tomcat dans JAVA WEB, l'intercepteur de Struts2 et le filtre du servlet jsp.
Avantages: 1. Réduisez le degré de couplage. Il dissocie l'expéditeur et le destinataire de la demande. 2. Simplifiez l'objet. Pour que l'objet n'ait pas besoin de connaître la structure de la chaîne. 3. Améliorer la flexibilité d'attribution des responsabilités aux objets. En changeant les membres de la chaîne ou en mobilisant leur ordre, il est permis d'ajouter ou de supprimer dynamiquement des responsabilités. 4. Il est très pratique d'ajouter de nouvelles classes de traitement des requêtes.
Inconvénients: 1. Il n'y a aucune garantie que la demande sera acceptée. 2. Les performances du système seront affectées dans une certaine mesure et il n'est pas pratique de déboguer le code, ce qui peut provoquer des appels en boucle. 3. Il peut ne pas être facile d'observer les caractéristiques au moment de l'exécution, ce qui entrave le débogage.
Scénarios d'utilisation: 1. Il existe plusieurs objets qui peuvent gérer la même demande et quel objet gère la demande est automatiquement déterminé au moment de l'exécution. 2. Soumettez une demande à l'un des multiples objets sans spécifier clairement le destinataire. 3. Un groupe d'objets peut être désigné de manière dynamique pour traiter la demande.
Remarque: il existe de nombreuses applications dans JAVA WEB.
Deuxièmement, l'implémentation du code
Les exemples d'implémentation de code de tous les modèles de conception peuvent être consultés sur Code Cloud. Si vous êtes intéressé, vous pouvez le vérifier. Adresse Code Cloud: https://gitee.com/no8g/java-design-patterns
2.1 Logique métier
Dans la Chine ancienne, l'éthique des «trois obédiences et quatre vertus» a été formulée pour les femmes. «Trois obédiences» se réfère à «suivre le père s'il n'est pas marié, suivre le mari s'il est marié et suivre le fils si le mari est mort». c'est-à-dire qu'une femme doit obéir lorsqu'elle n'est pas mariée Père, obéir au mari après s'être mariée, et obéir au fils même lorsque le mari est mort. Par exemple, une femme qui veut faire du shopping, le même genre de demande, elle doit obtenir le consentement de son père avant de se marier, et doit obtenir la permission de son mari après le mariage. Et si le mari décède? En général, les hommes meurent plus tôt que les femmes et ils doivent demander à leurs fils s’ils s’autorisent à faire du shopping. Je suppose que vous vous demanderez bientôt quoi faire si vous n’avez pas de fils. Demandez à mon beau-frère, à mon neveu, etc. Dans la société patrilinéaire, les femmes n'occupent qu'une position subalterne. Maintenant, en pensant aux femmes en Chine, c'est encore relativement misérable. Vous devez demander des instructions lorsque vous allez faire les courses. Il n'y a que deux choix en tant que père, mari et fils: ou prendre Dites-lui d'autoriser ou de ne pas faire ses courses, ou demandez-lui de demander à la personne suivante, c'est la contrainte de tout le système social.
Les règles métier sont appliquées à notre projet, puis voyons comment implémenter les «trois conformités» à travers notre programme. Les exigences sont très simples: décrivez le système des «trois conformités» des femmes anciennes à travers le programme, alors regardons d'abord le diagramme de classe :
Nous pouvons résumer dans une telle structure, la demande féminine est d'abord envoyée à la classe père, et la classe père voit qu'elle doit être traitée par elle-même et y répond. Si la fille est déjà mariée, la demande doit être transmis au gendre pour traitement. Une fois que le gendre ira au paradis pour faire un rapport, le fils traitera la demande, semblable à cette demande:
Chaque nœud de père, mari et fils a deux choix: soit prendre la responsabilité et faire une réponse, soit transmettre la demande au lien suivant. L'analyse de la structure est déjà très claire, alors voyons comment implémenter cette fonction, regardons d'abord le diagramme de classes:
À partir du diagramme de classes, les trois classes d'implémentation Father, Husband et Son n'ont besoin que d'implémenter les méthodes abstraites du constructeur et de la classe parent. La façon de gérer ces requêtes a été transférée vers la classe abstraite Hanlder. Voyons comment Hanlder réalise:
Le résultat est également correct, la classe d'appel métier Client n'a pas besoin de juger qui doit le traiter, et les sous-classes de la classe abstraite Handler peuvent continuer à être ajoutées à l'avenir, mais notre chaîne de livraison est augmentée, et la classe appelante n'a pas besoin de comprendre le processus de changement, ou même Il n'est pas nécessaire de savoir qui traite cette demande.
L'explication ci-dessus est le modèle de chaîne de responsabilité. Vérifiez si les trois catégories Père, Mari et Fils sont acceptées lors du traitement des demandes des femmes. Chaque lien n'a que deux options: soit prendre la responsabilité et répondre, soit la transmettre. Demande, il y aura éventuellement un lien pour répondre, le diagramme de classe général est le suivant:
2.2 Implémentation du code
package com.iot.practice.designpattern.chainofresponsibility.chainofresponsibilitypattern;
import com.iot.practice.designpattern.chainofresponsibility.IWomen;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
/**
* <p>Client 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月19日 11:37</p>
* <p>@remark：</p>
*/
public class ChainOfResponsibilityClient {
public static void main(String[] args) {
// 随机挑选几个女性
Random random = new Random();
List<IWomen> iWomenList = new ArrayList<>();
for (int i = 0; i < 5; i++) {
iWomenList.add(new IWomenImpl(random.nextInt(4), "我要看电影"));
}
// 定义三个请示对象
Handler father = new Father();
Handler husband = new Husband();
Handler son = new Son();
// 设置请示顺序
father.setNext(husband);
husband.setNext(son);
for (IWomen iWomen : iWomenList) {
father.HandleMessage(iWomen);
}
}
}
package com.iot.practice.designpattern.chainofresponsibility.chainofresponsibilitypattern;
import com.iot.practice.designpattern.chainofresponsibility.IWomen;
/**
* <p>Handler 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月19日 10:56</p>
* <p>@remark：
* 有没有看到，其实在这里也用到模版方法模式，在模版方法中判断请求的级别和当前能够处理的级别，
* 如果相同则调用基本方法，做出反馈；如果不相等，则传递到下一个环节，由下一环节做出回应。基本方
* 法 response 要各个实现类都要实现，我们来看三个实现类：
* </p>
*/
public abstract class Handler {
/**
* 能处理的级别
*/
private int level = 0;
/**
* 责任传递，下一个人责任人是谁
*/
private Handler nextHandler;
/**
* 构造函数：每个类都要说明一下自己能处理哪些请求
*
* @param level 能处理的级别
*/
public Handler(int level) {
this.level = level;
}
/**
* 一个女性（女儿，妻子或者是母亲）要求逛街，你要处理这个请求
*
* @param iWomen 女性统称
*/
public final void HandleMessage(IWomen iWomen) {
if (iWomen.getType() == this.level) {
this.response(iWomen);
} else {
// 有后续环节，才把请求往后递送
if (this.nextHandler != null) {
this.nextHandler.HandleMessage(iWomen);
} else {
// /已经没有后续处理人了，不用处理了
System.out.println("-----------没地方请示了，不做处理！---------\n");
}
}
}
/**
* 如果不属于你处理的返回，你应该让她找下一个环节的人，比如
* 女儿出嫁了，还向父亲请示是否可以逛街，那父亲就应该告诉女儿，应该找丈夫请示
*
* @param handler 处理类
*/
public void setNext(Handler handler) {
this.nextHandler = handler;
}
/**
* 有请示那当然要回应
*
* @param iWomen 女性统称
*/
public abstract void response(IWomen iWomen);
}
package com.iot.practice.designpattern.chainofresponsibility;
/**
* <p>IWomen 此接口用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月19日 9:55</p>
* <p>@remark：古代悲哀女性的总称</p>
*/
public interface IWomen {
/**
* 获得个人状况
*
* @return 个人状况数值
*/
public int getType();
/**
* 获得个人请示，你要干什么？出去逛街？约会?还是看电影
*
* @return 干什么
*/
public String getRequest();
}
package com.iot.practice.designpattern.chainofresponsibility.chainofresponsibilitypattern;
import com.iot.practice.designpattern.chainofresponsibility.IWomen;
/**
* <p>IWomenImpl 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月19日 11:23</p>
* <p>@remark：</p>
*/
public class IWomenImpl implements IWomen {
/**
* 通过一个int类型的参数来描述妇女的个人状况
* 1---未出嫁
* 2---出嫁
* 3---夫死
*/
private int type = 0;
/**
* 妇女的请示
*/
private String request = "";
/**
* 构造函数传递过来请求
*
* @param type 个人状况
* @param request 妇女的请示
*/
public IWomenImpl(int type, String request) {
this.type = type;
this.request = request;
// 为了显示好看点，我在这里做了点处理
switch(this.type) {
case 1:
this.request = "女儿的请求是：" + request;
break;
case 2:
this.request = "妻子的请求是：" + request;
break;
case 3:
this.request = "母亲的请求是：" + request;
break;
}
}
/**
* 获得自己的状况
*
* @return 自己的状况
*/
@Override
public int getType() {
return this.type;
}
/**
* 获得妇女的请求
*
* @return 妇女的请求
*/
@Override
public String getRequest() {
return this.request;
}
}
package com.iot.practice.designpattern.chainofresponsibility.chainofresponsibilitypattern;
import com.iot.practice.designpattern.chainofresponsibility.IWomen;
/**
* <p>Father 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月19日 11:13</p>
* <p>@remark：</p>
*/
public class Father extends Handler {
/**
* 父亲只处理女儿的请求
*/
public Father() {
super(1);
}
/**
* 父亲的答复
*
* @param iWomen 女性统称
*/
@Override
public void response(IWomen iWomen) {
System.out.println("--------女儿向父亲请示-------");
System.out.println(iWomen.getRequest());
System.out.println("父亲的答复是:同意\n");
}
}
package com.iot.practice.designpattern.chainofresponsibility.chainofresponsibilitypattern;
import com.iot.practice.designpattern.chainofresponsibility.IWomen;
/**
* <p>Husband 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月19日 11:15</p>
* <p>@remark：</p>
*/
public class Husband extends Handler {
/**
* 丈夫只处理妻子的请求
*/
public Husband() {
super(2);
}
/**
* 丈夫的答复
*
* @param iWomen 女性统称
*/
@Override
public void response(IWomen iWomen) {
System.out.println("--------妻子向丈夫请示-------");
System.out.println(iWomen.getRequest());
System.out.println("丈夫的答复是：同意\n");
}
}
package com.iot.practice.designpattern.chainofresponsibility.chainofresponsibilitypattern;
import com.iot.practice.designpattern.chainofresponsibility.IWomen;
/**
* <p>Son 此类用于：</p>
* <p>@author：hujm</p>
* <p>@date：2021年02月19日 11:18</p>
* <p>@remark：</p>
*/
public class Son extends Handler {
/**
* 儿子只处理母亲的请求
*/
public Son() {
super(3);
}
/**
* 儿子的答复
*
* @param iWomen 女性统称
*/
@Override
public void response(IWomen iWomen) {
System.out.println("--------母亲向儿子请示-------");
System.out.println(iWomen.getRequest());
System.out.println("儿子的答复是：同意\n");
}
}
finir!