Romance des Trois Royaumes : modèle de chaîne de responsabilité

Bonjour à tous, Aujourd'hui je vais partager avec vous 责任链模式 des patrons de conception. Utilisez des histoires de vie appropriées et des scénarios de projet réels pour parler du modèle de conception, et enfin résumez le modèle de conception en une phrase.

Histoire

Il y a deux jours, j'ai relu le Roman des Trois Royaumes, j'ai vu que Guan Yu était à Cao Ying et son cœur était à Han, et j'ai entendu dire que Liu Bei était à Yuan. Chez Shao. Ensuite, j'ai joué à "Traverser les cinq passes".

Guan Yu a passé cinq passes et tué six généraux Contenu principal :

• La première passe, Dongling Pass, a tué le général de garde Kong Xiu.

  Dongling Pass, le général de garde nommé Kong Xiu était à l'origine membre des Turbans jaunes. Après s'être rendu à Cao Cao, il reçut l'ordre de défendre Dongling Pass avec 500 personnes. Lorsque le cortège de Guan Yu a passé le col, Kong Xiu a demandé le document de dédouanement et s'est affronté avec Guan Yu. Après un seul tour, il a été tué par Guan Yu.

• Deuxième passe, Luoyang Pass, Meng Tan et Han Fu.

  Guan Yu a dépassé le col de Dongling Alors qu'il était sur le point de traverser Luoyang, Han Fu et Meng Tan ont bloqué la route avec des bois. Tout d'abord, Meng Tan a défié Guan Yu, mais il s'est brouillé avec Guan Yu et a perdu le combat. Meng Tan a tourné son cheval et a couru en arrière, attirant Guan Gong pour le poursuivre, afin que Han Fu puisse tirer des flèches par derrière pour capturer Guan Gong. mais qui aurait pensé que le cheval lapin rouge de Guan Gong était si rapide qu'il pouvait rattraper Meng Tan par derrière, a coupé Meng Tan d'un seul coup. Han Fu a paniqué et a tiré une flèche, frappant Guan Gong dans son bras gauche. Guan Gong a enduré la blessure de la flèche, s'est précipité à travers les bois, a tué Han Fu d'un seul coup, puis a traversé Luoyang.

• Le troisième col, Bishui Pass, Bianxi.

  Après avoir appris que Guan Yu avait passé le col et décapité ses généraux, Kong Xiu de Dongling Pass, Han Fu de Luoyang et Meng Tan avaient tous été tués, Bian Xi se dit qu'il était difficile de résister à Guan Gong. Il a donc fait semblant d'accueillir Guan Gong et s'est arrangé pour qu'un épéiste du temple Zhenguo attende une opportunité de tuer Guan Gong. Heureusement, Pu Jing, le vieil abbé du temple Zhenguo, l'a averti que Guan Gong était au courant du complot, s'est brouillé avec Bian Xi et a tué Bian Xi avec une épée, alors Guan Gong a passé le col Sishui.

• Le quatrième niveau, Wang Zhi.

  Ce Wang Zhi est un parent de Han Fu. Il était très en colère lorsqu'il a appris que Han Fu avait été tué par Guan Gong, alors il a voulu venger Han Fu. Lorsque Guan Gong est arrivé à Xingyang, Wang Zhi a organisé un banquet au poste pour Guan Gong et ses deux épouses. Mais Hu Ban a été secrètement envoyé pour mettre le feu à Guan Gong, dans l'espoir de le brûler vif. Mais Hu Ban a rapporté le secret à Guan Yu parce que Guan Gong avait apporté une lettre à son père Hu Hua. Guan Yu et les deux épouses impériales ont pu s'échapper du palais à l'avance, mais Hu Ban a fait semblant de mettre le feu pour confondre Wang Zhi. Cependant, Wang Zhi a découvert plus tard et tué Hu Ban Quand il est venu chasser Guan Yu, il a été tué par Guan Yu, alors Guan Gong a dépassé Xingyang.

• Le cinquième passage, Yellow River Ferry, Qin Qi.

  Ce Qin Qi n'est pas seulement le général préféré de Xiahou Dun, mais aussi le neveu du vieux général Cai Yang. Il a reçu l'ordre de garder le ferry du fleuve Jaune et de vérifier les navires qui passent. Lorsque Guan Gong est arrivé au ferry du fleuve Jaune, il cherchait un bateau pour traverser le fleuve, mais Qin Qi l'a arrêté non seulement. Qin Qi a non seulement refusé de laisser Guan Gong et d'autres traverser le fleuve, mais a également prononcé des mots arrogants. a finalement mis Guan Gong en colère et a été décapité par Guan Gong

C'est ainsi que Guan Yu a passé les cinq passes. L'ensemble du processus de meurtre de six généraux.

Ce scénario m'a rappelé un modèle de conception : Modèle de chaîne de responsabilité.

En fait, il existe de nombreux modèles de chaîne de responsabilité dans nos vies. Par exemple : fondamentalement, chaque entreprise dispose de son propre système OA, qui fournit principalement des fonctions telles que les informations de base sur les employés, les congés, les congés, le remboursement et d'autres fonctions. Si je dois prendre deux jours de congé pour quelque chose, je me connecte au système OA et je lance l'approbation du congé.

Parce que l'entreprise a la réglementation suivante pour la durée du congé :

inférieure ou égale à une demi-journée, le lien d'approbation est : chef de projet

plus d'une demi-journée, inférieure ou égale à 1 journée, le lien d'approbation : chef de projet + directeur technique

plus d'1 jour, processus d'approbation : chef de projet + directeur technique + Patron

On voit que le processus d'approbation de mon congé est chef de projet + directeur technique + Patron.

Quel est exactement le modèle de conception de la chaîne de responsabilité ?

Qu'est-ce que le modèle de chaîne de responsabilité ?

L'explication anglaise du modèle de chaîne de responsabilité est :

Évitez de coupler l'expéditeur d'une requête à son destinataire en donnant à plusieurs objets une chance de gérer la requête. Chaînez les objets récepteurs et transmettez la requête le long de la chaîne jusqu'à ce qu'un objet la gère.

Modèle de chaîne de responsabilité) traite chaque nœud dans la chaîne en tant qu'objet, chaque nœud gère différentes demandes et gère automatiquement l'objet nœud suivant en interne. Lorsqu'une requête est émise depuis la tête de chaîne, elle sera transmise à chaque objet nœud le long du chemin prédéfini de la chaîne de responsabilité jusqu'à ce qu'elle soit traitée par un objet de la chaîne, qui est 行为型设计模式.

Code commun pour le modèle de chaîne de responsabilité

Java implémente le modèle de conception de chaîne de responsabilité comme suit :

public abstract class Handler {
        protected Handler nextHandler = null;
        public abstract void handle();
        public Handler getNextHandler() {
            return nextHandler;
        }
        public void setNextHandler(Handler nextHandler) {
            this.nextHandler = nextHandler;
        }
}

public class HandlerA extends Handler{
        @Override
        public void handle() {
            if(nextHandler == null){
                System.out.println("HandlerA handle ...");
            }else{
                nextHandler.handle();
            }
        }
}

public class HandlerB extends Handler{
        @Override
        public void handle() {
            if(nextHandler == null){
                System.out.println("HandlerB handle ...");
            }else{
                nextHandler.handle();
            }
        }
}

public class HandlerC extends Handler{
    @Override
    public void handle() {
        if(getNextHandler() == null){
            System.out.println("HandlerC handle ...");
        }else{
            getNextHandler().handle();
        }
    }
}
//测试
public class  Client{
    public static void main(String[] args) {
        Handler handlerA = new HandlerA();
        Handler handlerB = new HandlerB();
        handlerA.setNextHandler(handlerB);
        handlerA.handle();
    }
}

Résultat d'exécution :

HandlerC handle ...

À partir du code ci-dessus, nous pouvons dessiner le diagramme UML :

D'après le diagramme UML , nous pouvons voir qu'il y a deux rôles très importants dans le modèle de chaîne de responsabilité :

(1), rôle de gestionnaire abstrait (Handler)

définit l'interface de traitement des requêtes. Une interface peut également fournir une méthode pour définir et renvoyer une référence à l'objet suivant. Ce rôle est généralement implémenté par une classe abstraite Java ou une interface Java.

(2), rôles de gestionnaire spécifiques (HandlerA, HandlerB, HandlerC)

Après avoir reçu la demande, le gestionnaire spécifique peut choisir de traiter la demande ou de transmettre la demande à l'objet suivant. Puisque le gestionnaire spécifique détient une référence à la prochaine maison.

责任链模式的优缺点

• 优点：请求和处理分开，两者解耦，提供系统的灵活性。
• 缺点：性能能问，一个链非常长的时候，非常耗时。因为我们避免建立很长的链。

生活中的案例

在日常生活中，责任链模式是比较常见的。我们平时处理工作中的一些事务，往往是各部门协同合作来完成某一个任务的。而每个部门都有各自的职责，因此，很多时候事情完成一半，便会转交到下一个部门，直到所有部门都审批通过，事情才能完成。

责任链模式主要解耦了请求与处理，客户只需将请求发送到链上即可，不需要关心请求的具体内容和处理细节，请求会自动进行传递，直至有节点对象进行处理。

责任链模式主要适用于以下应用场景:

• 多个对象可以处理同一请求，但具体由哪个对象处理则在运行时动态决定。
• 在不明确指定接收者的情况下，向多个对象中的一个提交请求。
• 可动态指定一组对象处理请求。

请假流程的代码实现

下面我们来对，前面的案例：OA上请假流程做一个Java代码的实现。

抽象处理者：领导类

public abstract class Leader {
    private Leader next;
    public void setNext(Leader next) {
        this.next = next;
    }
    public Leader getNext() {
        return next;
    }
    //处理请求的方法
    public abstract void handleRequest(double LeaveDays);
}

项目负责人

public class ProjectLeader extends Leader {
    @Override
    public void handleRequest(double LeaveDays) {
        if (LeaveDays <= 0.5) {
            System.out.println("项目负责人批准您请假" + LeaveDays + "天。");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(LeaveDays);
            } else {
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}

技术总监

public class TechnicalDirectorLeader extends Leader {

    @Override
    public void handleRequest(double LeaveDays) {
        if (LeaveDays <= 1) {
            System.out.println("技术总监批准您请假" + LeaveDays + "天。");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(LeaveDays);
            } else {
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}

Boss

public class BossLeader extends Leader {
    @Override
    public void handleRequest(double LeaveDays) {
        if (LeaveDays >= 2 && LeaveDays <= 30) {
            System.out.println("Boss批准您请假" + LeaveDays + "天。");
        } else {
            if (getNext() != null) {
                getNext().handleRequest(LeaveDays);
            } else {
                System.out.println("请假天数太多，没有人批准该假条！");
            }
        }
    }
}

发起审批

public class LeaveApproval {
    public static void main(String[] args) {
        //组装责任链
        Leader projectLeader = new ProjectLeader();
        Leader technicalDirectorLeader = new TechnicalDirectorLeader();
        Leader bossLeader = new BossLeader();

        projectLeader.setNext(technicalDirectorLeader);
        technicalDirectorLeader.setNext(bossLeader);

        //请假两天，提交请假流程，开启审批环节,
        projectLeader.handleRequest(2);
    }
}

审批结果

Boss批准您请假2.0天。

如果请假天数是31天，审批结果

请假天数太多，没有人批准该假条！

整个请假流程为：

Changez cet organigramme en vertical :

Juste comme ça, utilisez les deux exemples et deux images ci-dessus pour comprendre la chaîne de responsabilité. Le mode est-il plus facile ?

Inutile de se vanter. Voyons comment les maîtres utilisent le modèle de chaîne de responsabilité.

Comment les grands l'utilisent

Dans des frameworks tels que Spring et Mybatis, le modèle de chaîne de responsabilité est utilisé Voyons d'abord comment il est utilisé dans Spring.

Dans la classe org.springframework.web.servlet.DispatcherServlet du Spring MVC :

getHandler 方法的处理使用到了责任链模式，handlerMappings是之前 Spring 容器初始化好的，通过遍历 handlerMappings查找与request匹配的 Handler, 这里返回 HandlerExecutionChain 对象。这个 HandlerExecutionChain对象到后面执行的时候再分析为什么返回的是这样一个对象。

@Nullable
protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
 if (this.handlerMappings != null) {
  for (HandlerMapping mapping : this.handlerMappings) {
   HandlerExecutionChain handler = mapping.getHandler(request);
   if (handler != null) {
    return handler;
   }
  }
 }
 return null;
}

以上便是责任链模式在Spring的具体使用

总结

本文通过关二爷的过五关斩六将和OA系统中的请假审批流程，完美的解释了责任链设计模式。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!