Em Orientação a Objetos, Chain of Responsibility é um padrão GOF cuja principal função é evitar a dependência entre um objeto receptor e um objeto solicitante. Consiste em uma série de objetos receptores e de objetos de solicitação, onde cada objetos de solicitação possui uma lógica interna que separa quais são tipos de objetos receptores que podem ser manipulados. O restante é passado para o próximo objetos de solicitação da cadeia.
Devido a isso, é um padrão que utiliza a ideia de baixo acoplamento por permitir que outros objetos da cadeia tenham a oportunidade de tratar uma solicitação.
Estrutura
Passo-a-passo A base mantém um ponteiro como "próximo"; Cada classe derivada implementa sua própria contribuição para manusear o pedido (request); Se o pedido precisa ser passado para outra classe, então a classe derivada "chama de volta" à classe padrão, delegando um novo ponteiro; O cliente (terceirizado ou não) cria e encadeia a cadeia, a qual pode incluir uma ligação do último nó até o nó da raiz; O cliente lança e deixa cada request com a raiz da cadeia; As delegações recursivas produzem um efeito de ilusão;
Situações de Uso Mais de um objeto pode tratar uma solicitação e o objeto que a tratará não é conhecido a priori; O objeto que trata a solicitação deve ser escolhido automaticamente; Deve-se emitir uma solicitação para um dentre vários objetos, sem especificar explicitamente o receptor; O conjunto de objetos que pode tratar uma solicitação deveria ser especificado dinamicamente.
Em um sistema orientado a objetos esses interagem entre si através de mensagens, e o sistema necessita de determinar qual o objeto que irá tratar a requisição. O padrão de projeto Chain of Responsibility permite determinar quem será o objeto que irá tratar a requisição durante a execução. Cada objeto pode tratar ou passar a mensagem para o próximo na cascata.
Em um escritório, por exemplo, onde se tem 4 linhas telefônicas, a primeira linha é o primeiro objeto, a segunda linha é o segundo, e assim sucessivamente até a gravação automática que é o quinto objeto. Se a primeira linha estiver disponível ela irá tratar a ligação, se não ela passa a tarefa para o próximo objeto, que é a segunda linha. Se essa estiver ocupada ela passa a tarefa para a próxima e assim sucessivamente até que um objeto possa tratar a tarefa.
Nesse caso, se todas as linhas estiverem ocupadas o último objeto, que é a gravação automática, tratará da tarefa.
Exemplo
Java Abaixo está um exemplo do padrão na linguagem de programação Java. Neste exemplo, temos atores diferentes, cada um estabelecendo um limite de compras à seu sucessor. Toda vez que um ator recebe um pedido de compra que exceda seu limite, o pedido é passado ao seu sucessor.
A classe abstrata PurchasePower com o método abstrato processRequest: abstract class PurchasePower { protected static final double BASE = 500; protected PurchasePower successor;
abstract protected double getAllowable();
abstract protected String getRole();
public void setSuccessor(PurchasePower successor)
this.successor = successor;
public void processRequest(PurchaseRequest request)
if (request.getAmount() < this.getAllowable())
System.out.println(this.getRole() + " will approve $" + request.getAmount());
else if (successor != null)
successor.processRequest(request);
}Temos quatro implementações da classe abstrata acima: Manager (Gerente), Director (Diretor), Vice President (Vice Presidente) e President (Presidente), cada uma multiplicando seu poder de compra:class ManagerPPower extends PurchasePower { protected double getAllowable()
return BASE*10;
protected String getRole()
return "Manager";
class DirectorPPower extends PurchasePower { protected double getAllowable()
return BASE*20;
protected String getRole()
return "Director";
class VicePresidentPPower extends PurchasePower { protected double getAllowable()
return BASE*40;
protected String getRole()
return "Vice President";
class PresidentPPower extends PurchasePower { protected double getAllowable()
return BASE*60;
protected String getRole()
return "President";
}O código abaixo define que a classe PurchaseRequest mantenha os dados em uma outra classe, como neste exemplo:class PurchaseRequest {
private double amount; private String purpose;
public PurchaseRequest(double amount, String purpose)
this.amount = amount; this.purpose = purpose;
public double getAmount()
return amount;
public void setAmount(double amt)
amount = amt;
public String getPurpose()
return purpose;
public void setPurpose(String reason)
purpose = reason;
}No uso que fizemos deste exemplo, temos a devida ordem (do menor poder de compra para o maior): Manager -> Director -> Vice President -> Presidentclass CheckAuthority { public static void main(String[] args)
ManagerPPower manager = new ManagerPPower(); DirectorPPower director = new DirectorPPower(); VicePresidentPPower vp = new VicePresidentPPower(); PresidentPPower president = new PresidentPPower(); manager.setSuccessor(director); director.setSuccessor(vp); vp.setSuccessor(president);
// Press Ctrl+C to end. try
while (true)
System.out.println("Enter the amount to check who should approve your expenditure."); System.out.print(">"); double d = Double.parseDouble(new BufferedReader(new InputStreamReader(System.in)).readLine()); manager.processRequest(new PurchaseRequest(d, "General"));
} catch (Exception e)
System.exit(1);
Regras Importantes Chain of Responsibility, Command, Mediator, e Observer são como endereços, podendo ser separados entre remetentes e destinatários, mas com consequências diferentes. O Chain of Responsibility passa um pedido ao remetente junto com uma cadeia de potenciais destinatários. Chain of Responsibility pode usar o padrão Command para representar pedidos como objetos. Chain of Responsibility é frequentemente aplicado em conjunto com o padrão Composite. Os componentes da classe-mãe podem ser usados para a classe-filha também.
Referências externas
Ligações externas
Categoria:Programação orientada a objetos Categoria:Padrões de projeto de software Categoria:Engenharia de software