Padrão da cadeia de responsabilidade: vários objetos são conectados a uma cadeia por referências correspondentes à próxima casa de seus objetos, e a solicitação é passada nessa cadeia até que um objeto receptor na cadeia processe a solicitação. Como o cliente solicitante não sabe quem acabará por lidar com a solicitação na cadeia, o sistema pode reorganizar e alocar dinamicamente responsabilidades sem afetar o cliente, evitando assim o acoplamento entre o remetente da solicitação e o manipulador de solicitação.
Existem três papéis envolvidos na cadeia de responsabilidade:
1. Função do processador abstrato
2. Função do manipulador específico
3. Pequeno exemplo do remetente de solicitação: suponha que você vá comprar uma casa e precise negociar ao comprar uma casa. As posições da pessoa que vende a casa são diferentes e os preços com desconto também são diferentes. Posições diferentes podem formar uma cadeia para processar a solicitação. Estabelecemos provisoriamente: * vendedores de base só podem oferecer desconto de 3% * Gerente de vendas: 5% de desconto * Diretor de vendas: 8% de desconto * Chefe: 10% de desconto
Instância java
Diagrama de classe:
/ *** Responsabilidade abstrata*/ Classe de abstração pública ifilter {private ifilter sucessor; public ifilter getsuccessor () {return sucessor; } public void SetSuccessor (ifilter sucessor) {this.successor = sucessor; } abstrato público void handleFilter (); HISTÓRIO PÚBLICO ABRATO VOID 2 (); } / *** Responsabilidades específicas*/ classe pública ConcreteFilter estende o ifilter {nome da string privada; public concretefilter (nome da string) {this.name = name; } @Override public void handleFilter () { / * * lide primeiro, se houver um sucessor, lidar com ele uma vez * / system.out.println (nome + "solicitação processada"); if (getSuccessor ()! = null) {getSuccessor (). handleFilter (); }} @Override public void handleFilter2 () { / * * Se houver um sucessor, o sucessor será tratado sozinho. Caso contrário, você mesmo lidará com isso*/ se (getSuccessor ()! = Null) {getSuccessor (). HandleFilter2 (); } else {System.out.println (nome + "solicitação processada"); }}} Public class Test {public static void main (string [] args) {ifilter filter1 = new concreteFilter ("filtro de permissão"); // filtro de permissão Filter 2 filtro2 = new concreteFilter ("sufix-filter"); // filtro de sufixo ifilter3 = novo concreto de concreto ("estilo-filter"; filtro2.SetSUccessor (filtro3); System.out.println ("----- O seguinte é tratado por todos os processadores (incluindo sucessores), o pedido também é um passe de nível a nível ------"); filtro1.HandLeFilter (); System.out.println ("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Imprimir:
------ A seguir, o processo de cada processador (incluindo sucessores), e o pedido também é um nível após o outro ----- filtro de permissão lida com o filtro de sufixo de solicitação lida com o filtro de estilo de solicitação lida com a solicitação ------- A seguir, é apresentado o processo do último successor---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------