Definição da Cadeia de Responsabilidade: Cadeia de Responsabilidade (COR) é uma série de classes que tentam processar uma solicitação. Em outras palavras, quando uma solicitação vem, os processos de classe A primeiro.
Como usar a cadeia de Modelo de Responsabilidade
Embora este parágrafo use o COR, também demonstra o que é o COR.
Existe uma interface de manipulador:
A cópia do código é a seguinte:
manipulador de interface pública {
public void HandleRequest ();
}
Este é um exemplo de manipulação de solicitações.
◆ A primeira solução que vem à mente é: Adicione várias solicitações à interface:
A cópia do código é a seguinte:
manipulador de interface pública {
public void HandleHelp ();
public void HandlePrint ();
public void HandleFormat ();
}
Especificamente, é um código para implementar a interface:
A cópia do código é a seguinte:
classe pública ConcreteHandler implementa o manipulador {
Sucessor de Manipulador Privado;
public concretehandler (sucessor de manipulador) {
this.successor = sucessor;
}
public void handleHelp () {
// Código específico para processamento da solicitação de ajuda ...
}
public void handleprint () {
// Se for uma impressão, vire para processar a impressão
sucessor.Handleprint ();
}
public void HandleFormat () {
// Se for formato, vá para o formato de processo
sucessor.HandleFormat ();
}
}
Existem três classes de implementação específicas, acima, que estão processando ajuda e processamento de formato de impressão e processamento, que provavelmente são nossas idéias de programação mais usadas.
Embora a ideia seja simples e clara, há um problema de extensão.
◆ A segunda solução: transforme cada solicitação em uma interface, para que tenhamos o seguinte código:
A cópia do código é a seguinte:
Public Interface HelpHandler {
public void HandleHelp ();
}
interface pública imprimorthandler {
public void HandlePrint ();
}
interface pública formathandler {
public void HandleFormat ();
}
Classe Public ConcreteHandler
implementa HelpHandler, PrintHandler, formathandlet {
Private HelpHandler HelpUccessor;
Impressor de impressão privada impressa;
Formathandler de formato de formato privado;
Public ConcreteHandler (HelpHandler HelpUccessor, PrintHandler PrintSuccessor, Formathandler Formatsuccessor)
{
this.helpsuccessor = helpUccessor;
this.printSuccessor = printSuccessor;
this.FormatsucCessor = formatsuccessor;
}
public void handleHelp () {
.........
}
public void handleprint () {this.printSuccessor = printSuccessor;}
public void handleFormat () {this.Formatsuccessor = formatsuccessor;}
}
Ao adicionar uma nova solicitação, esse método salva apenas a quantidade de modificação da interface e a implementação da interface do concreto -manipulador também precisa ser modificada. E o código obviamente não é simples e bonito.
◆ Solução 3: Apenas um método de parametrização é usado na interface do manipulador:
A cópia do código é a seguinte:
manipulador de interface pública {
public void handlerequest (solicitação de string);
}
Então o código de implementação do manipulador é o seguinte:
classe pública ConcreteHandler implementa o manipulador {
Sucessor de Manipulador Privado;
public concretehandler (sucessor de manipulador) {
this.successor = sucessor;
}
public void handlerequest (solicitação de string) {
if (request.equals ("help")) {
// Aqui está o código específico para manusear ajuda} mais
// passa para o próximo sucessor.handle (solicitação);
}
}
}
Vamos primeiro assumir que a solicitação é do tipo String. Claro que podemos criar uma solicitação de classe especial
◆ A solução final: o código do manipulador de interface é o seguinte:
A cópia do código é a seguinte:
manipulador de interface pública {
public void handlerequest (solicitação de solicitação);
}
Definição da classe de solicitação:
Public classe solicitação {
tipo de sequência privada;
solicitação pública (tipo string) {this.type = type;}
public String getType () {return type;}
public void Execute () {
// Código de comportamento específico real da solicitação}
}
Então o código de implementação do manipulador é o seguinte:
A cópia do código é a seguinte:
classe pública ConcreteHandler implementa o manipulador {
Sucessor de Manipulador Privado;
public concretehandler (sucessor de manipulador) {
this.successor = sucessor;
}
public void handlerequest (solicitação de solicitação) {
se (solicitar a instância do helpRequest) {
// Aqui está o código específico para manusear ajuda} else se (solicitar a instância do PrintReCest) {
request.execute ();
}outro
// passa para o próximo sucessor.handle (solicitação);
}
}
}
Esta solução é cor.
1. Vantagens do COR: Porque é impossível prever a que tipo de solicitações do mundo exterior pertencem, se cada classe encontrar uma solicitação que não pode processar, basta desistir. Isso, sem dúvida, reduz o acoplamento entre as classes.
2. A desvantagem do COR é sua ineficiência, porque a conclusão de uma solicitação pode ter que ser percorrida até o final antes de ser concluída. Em Java AWT1.0, o manuseio dos botões do mouse é usar o Cor.
A escalabilidade é ruim porque, no COR, deve haver um manipulador de interface unificado.