Este artigo descreve o uso do modo de cadeia de responsabilidade para os alunos se despedirem. Compartilhe -o para sua referência, como segue:
1. Definição do padrão
Na cadeia do modelo de responsabilidade, muitos objetos são conectados por referências à sua próxima casa por cada objeto, formando uma cadeia. A solicitação de aplicativo do cliente é passada nessa cadeia até que um objeto na cadeia decida processar a solicitação. O cliente que faz essa solicitação não sabe qual objeto na cadeia lida com a solicitação, que permite ao sistema reorganizar dinamicamente a cadeia e atribuir responsabilidades sem afetar o cliente.
(1) Função do processador abstrato: Defina uma interface para solicitações de processamento. Se necessário, a interface pode definir um método para definir e retornar a referência à próxima casa. Esse papel é geralmente implementado por uma classe abstrata Java ou interface Java.
(2) Função específica de processamento: Após receber a solicitação, o processador específico pode optar por processar a solicitação ou passar a solicitação para a próxima casa.
2. Exemplos de modelo
1 Análise de padrão
Emprestamos a licença dos alunos para ilustrar este modelo
2 Diagrama de classe estática do padrão de cadeia de responsabilidade
3 exemplos de código
3.1 interface do aluno
pacote com.demo.chain.message;/** * interface do aluno * * @Author * */interface pública ISTUDENT {/** * Obtenha o status da condição do aluno * * 0: pequenas coisas (o monitor de classe pode lidar com isso) * 1: o monitor de classe não pode lidar com as coisas que o professor pode lidar com o professor * * 2: O professor não pode lidar com isso ( * * * * * * * * * * * * * * * * * * * * * * * * / ** * Obtenha a mensagem de licença do aluno * * @return */ public String getRequestMessage ();}3.2 Os alunos percebem um aluno
pacote com.demo.chain.message;/** * Classe de implementação do aluno * * @author * */public classe aluno implementa ISTUDENT {// tamanho da condição private int state = -1; // Mensagem de despedida Mensagem de string final privada; estudante público (int state, string mensagem) {this.state = state; this.Message = message; } / ** * Obtenha o status de licença do aluno * * 0: Coisas pequenas (o monitor de classe pode lidar) * * 1: O monitor de classe não pode lidar com coisas que o professor pode manusear * * * 2: o professor não pode lidar com coisas que o diretor pode lidar com * * * * / public int getState () {return this.state; } / ** * Obtenha a mensagem de licença do aluno * * @return * / public String getRequestMessage () {return this.message; }}3.3 interface de processamento abstrato-ihandler
pacote com.demo.chain.handle; importar com.demo.chain.message.istudent;/** * interface do processador abstrato * * @author * */interface pública iHandler {// Process Pedido Public void handleRequest (estudante iStudent); // Defina o próximo manipulador Public Void Sethandler (Ihandler Handler);}3.4 Abstracthandler
pacote com.demo.chain.handle; importar com.demo.chain.message.istudent;/** * manipulador abstrato * * @author * */public abstract classe abstracthandler implementa Ihandler {// Próximo manipulador privado iHandler; // deixa o nível privado int state = -1; // Nível de configuração do construtor Public abstracthandler (int state) {this.state = state; } // lidera solicitações à subclasse para lidar com o processamento específico do processo de void public abstrato (aluno ISTUDENT); // lidera solicitações públicas void handlerequest (aluno de istudente) {// se o objeto do aluno existir se (aluno! = Null) {if (this.state == student.getState ()) {// se o nível de licença for consistente com o atual, o objeto atual será processado. } else {if (this.Handler! = null) {System.out.println ("Solicite o líder superior para responder!"); // Se o objeto atual não puder ser processado, ele será entregue ao próximo processador para processar isso.Handler.HandleRequest (Student); }}}}} // Defina o próximo processador public void sethandler (iHandler Handler) {this.Handler = Handler; }}3.5 Squad LeaderHandler
pacote com.demo.chain.handle; importar com.demo.chain.message.istudent;/** * manipulador abstrato * * @author * */public abstract classe abstracthandler implementa Ihandler {// Próximo manipulador privado iHandler; // deixa o nível privado int state = -1; // Nível de configuração do construtor Public abstracthandler (int state) {this.state = state; } // lidera solicitações à subclasse para lidar com o processamento específico do processo de void public abstrato (aluno ISTUDENT); // lidera solicitações públicas void handlerequest (aluno de istudente) {// se o objeto do aluno existir se (aluno! = Null) {if (this.state == student.getState ()) {// se o nível de licença for consistente com o atual, o objeto atual será processado. } else {if (this.Handler! = null) {System.out.println ("Solicite o líder superior para responder!"); // Se o objeto atual não puder ser processado, ele será entregue ao próximo processador para processar isso.Handler.HandleRequest (Student); }}}}} // Defina o próximo processador public void sethandler (iHandler Handler) {this.Handler = Handler; }}3.6 Professor-professor-mão
pacote com.demo.chain.impl; importar com.demo.chain.handle.abstracthandler; importar com.demo.chain.message.istudent;/** * Handler de professores * * @author * */public class ProfessorHandler estende o abstimento {Professor público () {(1); } // Subclasse Solicitação de processamento específica @Override Public void Process (estudante ISTUDENT) {System.out.println ("Resposta do professor:" + Student.getRequestMessage ()); }}3.7 Mestre-mestre-mestre principal
pacote com.demo.chain.impl; importar com.demo.chain.handle.abstracthandler; importar com.demo.chain.message.istudent;/** * manipulador principal * * @author * */public class SchoolMasterHandler Extrends A AbsTacthandler {Public SchoolMasterHandler () {Public SchoolHandHandler Extrends. } // Subclasse Solicitação de processamento específico @Override Public void Process (ISTudent Student) {System.out.println ("Resposta do diretor:" + Student.getRequestMessage ()); }}3.8 Aparência Classe 1 ProcessHandler
pacote com.demo.chain.process; import com.demo.chain.handle.iHandler; importar com.demo.chain.impl.schoolmasterHandler; import com.demo.chain.impl.squadleaderHandler; Chain Association * * @author * */public class ProcessHandler {// Classe Leader Handler Private Final Ihandler Sqmshandler; // Manipulador de professores Private Final Ihandler Techhandler; // Principal Handler Private Final Ihandler Scmshandler; // Singleton Mode Private ProcessHandler ProcessHandler = new ProcessHandler (); / *** Método construtor para estabelecer uma cadeia de responsabilidade para processamento de licença*/ Private ProcessHandler () {// Criar Objeto de Processamento // Líder de classe this.sqmshandler = new SquadleaderHandler (); // professor this.teChhandler = new professorHandler (); // principal this.scmshandler = new SchoolMasterHandler (); / *** Estabeleça uma cadeia de responsabilidade*/ // Defina o próximo manipulador do líder da classe: professor this.sqmshandler.sethandler (this.techhandler); // Defina o próximo manipulador do professor: diretor this.techhandler.sethandler (this.scmshandler); } / ** * Obtenha uma instância do objeto Singleton * * @return * / public static processhaHandler getInstance () {return ProcessHandler; } / ** * Envie uma solicitação de licença * * @param mensagem * / public void sendMessage (estudante de ISTudent) {// Envie para o primeiro manipulador: o líder da classe lida com isso.sqmshandler.handlerequest (aluno); }}3.9 Cliente Client
pacote com.demo; importar java.util.random; importar com.demo.chain.message.istudent; importar com.demo.chain.message.student; import com.demo.chain.process.processler; ** ** ** ** * * * * * @author * */public client {Class. args) {// obtenha o objeto de aparência ProcessHandler ProcessHandler = processHandler.getInstance (); // Crie um objeto de número aleatório para gerar aleatoriamente objeto de aluno aleatório = novo aleatório (); for (int i = 0; i <3; i ++) {// obtenha número aleatório int radom = aleatoriamente.nextInt (3); Estudante de istudente = novo aluno (radom, "aluno" + i + "Estou doente, quero tirar despedir!"); System.out.println ("#Não #######Ás #######Ás ##########H##############################################) // Processar o Mensagem ProcessHandler.sendMessage (aluno); System.out.println ("#################################################/n"); }}}4 resultados de execução
#######################################################
Solicite uma resposta do líder superior!
Solicite uma resposta do líder superior!
A resposta do diretor: o aluno 0 está doente e quer se despedir!
#######################################################
#######################################################
Solicite uma resposta do líder superior!
Solicite uma resposta do líder superior!
A resposta do diretor: o aluno 1 está doente e quer se despedir!
#######################################################
#######################################################
O monitor de aula aprovado: o aluno 2 está doente e quer se despedir!
#######################################################
Iii. Os princípios de design deste padrão
1 Princípio de "Close Open"
2 Princípio de responsabilidade única
4. Use ocasiões
(1) Existem vários objetos que processam a mesma solicitação. Ainda é incerto qual é usado para lidar com isso. É determinado apenas em tempo de execução que o objeto lida com ele.
(2) A mensagem possui vários destinatários e o objeto receptor não está claro. Você só precisa enviar uma mensagem para um dos objetos e lidar com isso internamente.
(3) Múltiplos objetos de processamento da mesma mensagem podem aumentar ou diminuir dinamicamente e precisam ser especificados dinamicamente.
5. Diagrama de classe estática do padrão de cadeia de responsabilidade
Para mais conteúdo relacionado ao Java, os leitores interessados neste site podem visualizar os tópicos: "Estrutura de dados Java e tutorial de algoritmo", "Resumo da operação Java Dom Node Tips", "Resumo de Dicas de Operação de Arquivos e Diretórios de Java" e "Resumo das dicas de operação do Java Cache"
Espero que este artigo seja útil para a programação Java de todos.