Conteúdo deste artigo
1. Introdução ao modelo de cadeia de responsabilidade
Como o nome indica, o Padrão de Cadeia de Responsabilidade cria uma cadeia de objetos de destinatário para a solicitação. Este modo fornece o tipo de solicitação e separa o remetente e o destinatário da solicitação. Este tipo de padrão de design é um padrão comportamental.
Nesse modelo, geralmente cada destinatário contém uma referência a outro destinatário. Se um objeto não puder lidar com a solicitação, ele passará a mesma solicitação para o próximo destinatário e assim por diante.
1. Introdução ao modelo de cadeia de responsabilidade
Intenção: para evitar o acoplamento do remetente e do receptor da solicitação, possibilite que vários objetos recebam a solicitação, conecte esses objetos em uma cadeia e passe a solicitação ao longo dessa cadeia até que um objeto a trate.
A principal solução: o processador na cadeia de responsabilidade é responsável pelo processamento da solicitação, e o cliente só precisa enviar a solicitação para a cadeia de responsabilidade, não precisando se preocupar com os detalhes de processamento da solicitação e transferência da solicitação , então a cadeia de responsabilidade será o remetente da solicitação e o processador da solicitação Desacoplada.
Quando usar: filtre muitos canais ao processar mensagens.
Como resolver: todas as classes interceptadas implementam uma interface unificada.
Código-chave: Handler se agrega, julga se é apropriado em HandlerRequest e o transmite se as condições não forem atendidas e o define antes de transmiti-lo a quem.
Exemplos de aplicação: 1. "Tambores para passar flores" no Dream of Red Mansions. 2. Eventos borbulhando em JS. 3. O processamento de codificação por Apache Tomcat em JAVA WEB, o interceptor de Struts2 e o filtro de servlet jsp.
Vantagens: 1. Reduz o grau de acoplamento. Ele separa o remetente e o destinatário da solicitação. 2. Simplifique o objeto. Para que o objeto não precise conhecer a estrutura da cadeia. 3. Aumentar a flexibilidade de atribuição de responsabilidades aos objetos. Ao mudar os membros da rede ou mobilizar sua ordem, é permitido adicionar ou deletar responsabilidades de forma dinâmica. 4. É muito conveniente adicionar novas classes de processamento de solicitação.
Desvantagens: 1. Não há garantia de que a solicitação será aceita. 2. O desempenho do sistema será afetado até certo ponto e não é conveniente depurar o código, o que pode causar chamadas de loop. 3. Pode não ser fácil observar as características em tempo de execução, o que dificulta a depuração.
Cenários de uso: 1. Existem vários objetos que podem lidar com a mesma solicitação, e qual objeto lida com a solicitação é determinado automaticamente no tempo de execução. 2. Envie uma solicitação para um de vários objetos sem especificar claramente o destinatário. 3. Um grupo de objetos pode ser designado dinamicamente para processar a solicitação.
Nota: Existem muitos aplicativos em JAVA WEB.
Dois, implementação de código
Os exemplos de implementação de código de todos os padrões de design podem ser visualizados no Code Cloud. Se estiver interessado, você pode conferir. Endereço do Code Cloud: https://gitee.com/no8g/java-design-patterns
2.1 Lógica de negócios
Na China antiga, a ética das "três obediências e quatro virtudes" era formulada para as mulheres. "Três obediências" refere-se a "seguir o pai se não for casado, seguir o marido se for casado e seguir o filho se o marido morrer". quer dizer, uma mulher deve obedecer quando ela não é casada Pai, obedecer ao marido depois de se casar e obedecer ao filho mesmo quando o marido está morto. Por exemplo, uma mulher que quer sair para fazer compras, o mesmo tipo de pedido, ela deve obter o consentimento do pai antes de se casar, e deve obter a permissão do marido após o casamento.E se o marido morrer? Geralmente, os homens morrem mais cedo do que as mulheres e precisam perguntar aos filhos se eles se permitem fazer compras. Acho que em breve você perguntará o que fazer se não tiver um filho. Pergunte ao meu cunhado, sobrinho, etc. Na sociedade patrilinear, as mulheres ocupam apenas uma posição subordinada. Agora, pensando nas mulheres na China, ainda é relativamente infeliz. Você precisa pedir instruções quando for às compras. Existem apenas duas opções: pais, maridos e filhos: ou Diga-lhe para permitir ou não fazer compras, ou peça-lhe para pedir a outra pessoa, esta é a restrição de todo o sistema social.
Aplicadas ao nosso projeto estão as regras de negócios, então vamos ver como implementar as "três conformidades" por meio de nosso programa. Os requisitos são muito simples: descreva o antigo sistema de "três conformidades" das mulheres por meio do programa, então vamos examinar primeiro o diagrama de classes :
Podemos abstrair em tal estrutura, o pedido feminino é primeiro enviado para a classe pai, e a classe pai vê que precisa ser processado por si mesma e responde a ele. Se a filha já for casada, então o pedido deve ser encaminhado ao genro para processamento. Assim que o genro for ao céu para relatar, o filho atenderá ao pedido, semelhante a este pedido:
Cada nodo de pai, marido e filho tem duas opções: assumir a responsabilidade e dar uma resposta ou encaminhar a solicitação para o link subsequente. A análise da estrutura já está muito clara, então vamos ver como implementar essa função, primeiro olhe o diagrama de classes:
No diagrama de classes, as três classes de implementação Pai, Marido e Filho só precisam implementar os métodos abstratos do construtor e da classe pai. Como lidar com essas solicitações foi transferido para a classe abstrata Hanlder. Vamos ver como Hanlder consegue:
O resultado também está correto, a classe de chamada de negócios Client não precisa julgar quem precisa processá-la e as subclasses da classe abstrata Handler podem continuar a ser adicionadas no futuro, mas nossa cadeia de entrega é aumentada, e a classe de chamada não precisa entender o processo de mudança, ou mesmo Não há necessidade de saber quem está tratando dessa solicitação.
A explicação acima é o modelo da cadeia de responsabilidade. Verifique se as três categorias de Pai, Marido e Filho estão sendo aprovadas ao processar os pedidos das mulheres. Cada link tem apenas duas opções: assumir a responsabilidade e responder ou repassá-la. Solicite, eventualmente haverá um link para responder, o diagrama geral de classes é o seguinte:
2.2 Implementação do código
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");
}
}
fim!