23 Padrões de design Capítulo 19: Modelo de cadeia de responsabilidade Java
Definição: permite que vários objetos tenham a oportunidade de processar a solicitação, evitando assim a relação de acoplamento entre o remetente e o receptor da solicitação. Conecte esses objetos a uma corrente e passe a solicitação ao longo da cadeia até que um objeto a processe.
Tipo: padrão comportamental
Diagrama de classe:
Vamos primeiro olhar para um pedaço de código:
Teste public void (int i, solicitação de solicitação) {if (i == 1) {Handler1.Response (request); } else if (i == 2) {handler2.Response (request); } else if (i == 3) {Handler3.Response (solicitação); } else if (i == 4) {handler4.Response (request); } else {Handler5.Response (request); }}A lógica de negócios do código é a seguinte: o método possui dois parâmetros: o número inteiro i e uma solicitação de solicitação. De acordo com o valor de I, que lidará com a solicitação, se eu == 1, ele será tratado pelo Handler1, se eu == 2, ele será tratado pelo Handler2 e assim por diante.
Na programação, esse tipo de método de processamento de negócios é muito comum. Todas as classes que processam solicitações incluem se ... else ... declarações de julgamento condicional conectadas a uma cadeia de responsabilidade de processar a solicitação. Eu acredito que todo mundo costuma usar. As vantagens desse método são que ele é muito intuitivo, simples e claro e relativamente fácil de manter, mas esse método também tem várias dores de cabeça:
Código inchado: em aplicativos reais, as condições de julgamento geralmente não são tão simples para determinar se são 1 ou 2. Pode exigir cálculos complexos, talvez consultando o banco de dados, etc. Isso terá muito código extra. Se houver muitas condições de julgamento, essa afirmação se ... else ... é basicamente impossível de ler.
Alto grau de acoplamento: se quisermos continuar adicionando classes que processam solicitações, devemos continuar adicionando mais se as condições do julgamento; Além disso, a ordem dessa condição também é escrita para os mortos. Se quisermos alterar o pedido, só podemos modificar esta instrução de condição.
Como já entendemos as deficiências, precisamos encontrar uma maneira de resolvê -las. A lógica de negócios desse cenário é muito simples: se a condição 1 for atendida, será processada pelo Handler1 e, se não for atendida, será transmitida; Se a condição 2 for atendida, será processada pelo Handler2 e, se não for atendida, será transmitida e assim por diante até o final da condição. De fato, o método de melhoria também é muito simples, que é colocar a parte das condições de julgamento na classe de processamento. Este é o princípio do modelo de conexão de responsabilidade.
A estrutura da cadeia de modelo de responsabilidade
O diagrama de classes da cadeia de padrão de responsabilidade é muito simples, consiste em uma classe abstrata processada e seu conjunto de classes de implementação:
Classe de processamento abstrato: A classe de processamento abstrata inclui principalmente uma variável de membro Nexthandler apontando para a próxima classe de processamento e uma solicitação de mão de método que lida com a solicitação. A principal idéia do método Handrequest é que, se as condições de processamento forem atendidas, essa classe de processamento será processada, caso contrário, será processada pelo Nexthandler.
Classe de processamento específica: a classe de processamento específica implementa principalmente a lógica de processamento específica e as condições aplicáveis para o processamento.
Depois de entender a idéia geral do modelo de cadeia de responsabilidade, será mais fácil entender ao olhar para o código:
nível de classe {private int nível = 0; nível público (nível int) {this.level = nível; }; public boolean acima (nível de nível) {if (this.Level> = Level.level) {return true; } retornar false; }} classe solicitação {nível de nível; solicitação pública (nível de nível) {this.level = nível; } nível público getLevel () {retorno nível; }} classe Response {} Classe Abstract Class Handler {Private Handler Nexthandler; Resposta final pública HandleRequest (solicitação de solicitação) {resposta resposta = null; if (this.gethandlerLEvel (). acima (request.getLevel ())) {resposta = this.Response (request); } else {if (this.nextHandler! = null) {this.nextHandler.HandleRequest (solicitação); } else {System.out.println ("----------"); }} Retornar resposta; } public void setNextHandler (manipulador de manipulador) {this.nextHandler = manipulador; } nível abstrato protegido GethandlerLEvel (); Resposta de Resumo do Público Resposta (Solicitação de solicitação); } classe ConcreteHandler1 estende o manipulador {nível protegido GethandlerLEvel () {retorna novo nível (1); } resposta pública Resposta (solicitação de solicitação) { System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ class ConcreteHandler2 estende o manuseio {Nível protegido GethandlerLevel () {Retorne Novo Nível (3); System.Println (------ Solicitações são processadas pelo processador 3 ----- "); Handler2.SetNextHandler (Handler3);No código, a classe de nível simula as condições de determinação; A solicitação e a resposta correspondem a solicitações e respostas, respectivamente; O manipulador de classe abstrato julga principalmente as condições e um nível de processamento é simulado aqui. Somente o nível de processamento da classe de processamento é maior que o nível da solicitação pode ser processado, caso contrário, será entregue ao próximo processador para processamento.
Defina a relação de execução frontal e traseira da cadeia na classe do cliente e entregue a solicitação à primeira classe de processamento durante a execução. Este é o padrão da cadeia de responsabilidade. A função que ele conclui é a mesma que a instrução If ... else ... no artigo anterior.
Prós e contras do modelo de cadeia de responsabilidade
Comparado com se ... else ..., o padrão da cadeia de responsabilidade tem uma capacidade de acoplamento mais baixa, pois distribui os julgamentos condicionais em várias classes de processamento, e a ordem de processamento prioritária dessas classes de processamento pode ser definida à vontade. O modelo da cadeia de responsabilidade também tem suas desvantagens, que é a mesma que a declaração se ... else ... ou seja, antes de encontrar a classe de processamento correta, todas as condições de julgamento devem ser executadas. Quando a cadeia de responsabilidade é relativamente longa, o problema de desempenho é mais grave.
Cenários aplicáveis para a cadeia de Modelo de Responsabilidade
Assim como o exemplo inicial, se você se sentir sobrecarregado ao usar a declaração If ... else ... para organizar uma cadeia de responsabilidade e o código parece ruim, você pode usar a cadeia do modo de responsabilidade para refatorá -la.
Resumir
O modelo de cadeia de responsabilidade é na verdade uma versão flexível de If ... else ... declaração. Ele coloca essas condições de julgamento em cada classe de processamento. A vantagem disso é que é mais flexível, mas também traz riscos. Por exemplo, ao configurar o relacionamento entre a classe de processamento antes e depois da aula de processamento, você deve ter muito cuidado para julgar a relação entre a lógica condicional antes e depois da classe de processamento e ter cuidado para não ter referências circulares na cadeia.
O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.