Chain of Responsibility: diferenças entre revisões
Reversão. Conteúdo copiado de [http://www.cic.unb.br/~jhcf/MyBooks/iess/Patterns/BehavioralPatterns-82slides.pdf] |
|||
| Linha 1: | Linha 1: | ||
O [[padrões de projeto de software|padrão de projeto de software]] '''Chain of Responsibility''' representa um encadeamento de objetos receptores para o processamento de uma série de solicitações diferentes. Esses objetos receptores passam a solicitação ao longo da cadeia até que um ou vários objetos a tratem. |
|||
== Propósito == |
|||
'''Chain of responsibility''' é um padrão de projeto de software comportamental. Como o próprio nome já diz (Encadeamento de Atendentes), evita o acoplamento entre solicitantes e atendentes permitindo que mais de um objeto tenha chance de tratar a solicitação. Encadeia os atendentes e passa a solicitação através desta cadeia até que algum deles a trate <ref>http://wiki.ifba.edu.br/ads/tiki-download_file.php?fileId=176&highlight=chain%20of%20resposibility/</ref>. |
|||
Cada objeto receptor possui uma lógica descrevendo os tipos de solicitação que é capaz de processar e como passar adiante aquelas que requeiram processamento por outros receptores. A delegação das solicitações pode formar uma árvore de recursão, com um mecanismo especial para inserção de novos receptores no final da cadeia existente. |
|||
== Participantes == |
|||
=== Handler (HelpHandler) === |
|||
Define uma interface para atender as requisições, e pode também, implementar a ligação ao sucessor. |
|||
Dessa forma, fornece um acoplamento mais fraco por evitar a associação explícita do remetente de uma solicitação ao seu receptor e dar a mais de um objeto a oportunidade de tratar a solicitação. |
|||
=== ConcreteHandler (PrintButton, PrintDialog) === |
|||
Tem a função de Atender a requisição pela qual é responsável. Caso não seja possível, repassa ao seu sucessor, e também tem acesso ao seu sucessor. |
|||
Um exemplo da aplicação desse padrão é o mecanismo de herança nas linguagens orientadas a objeto: um método chamado em um objeto é buscado na classe que implementa o objeto e, se não encontrado, na superclasse dessa classe, de maneira recursiva. |
|||
=== Client === |
|||
Tem a função de iniciar a requisição a um ConcreteHandler da cadeia. |
|||
== Situações de utilização == |
|||
== Estrutura == |
|||
[[imagem:Estrutura_chain_of_responsibility.JPG |estilo|alinhamento|dimensão|Estrura básica do padrão chain of responsibility]] |
|||
* mais de um objeto pode tratar uma solicitação e o objeto que a tratará não é conhecido a priori; |
|||
<ref>http://www.cic.unb.br/~jhcf/MyBooks/iess/Patterns/BehavioralPatterns-82slides.pdf</ref>. |
|||
* 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 |
|||
== Aplicabilidade == |
|||
mensagens, e o sistema necessita de determinar qual o objeto que irá tratar a |
|||
Esse padrão de projeto deve ser usado quando: |
|||
requisição. O padrão de projeto Chain of Responsibility permite determinar |
|||
* Mais de um objeto pode atender uma requisição. No entanto, o objeto deve ser buscado de forma excedente. |
|||
quem será o objeto que irá tratar a requisição durante a execução. Cada objeto |
|||
* Você deseja emitir uma requisição para um de vários objetos, sem especificar qual irá receber o pedido. |
|||
pode tratar ou passar a mensagem para o próximo na cascata. |
|||
* O conjunto de objetos que pode tratar um pedido deve ser especificado dinamicamente. |
|||
Em um escritório, por exemplo, onde se tem 4 linha 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. |
|||
=={{Ligações externas}}== |
|||
== Consequências == |
|||
*{{Link|pt|http://www.pg.cefetpr.br/coinf/simone/patterns/chain.php|Referência a Chain of Responsibility no portal de padrões de projeto da Profa. Simone Nasser Matos (CEFET-PR)}} |
|||
* Reduz o acoplamento. |
|||
** Um Objeto não precisa conhecer qual é o outro objeto que atende a requisição. |
|||
** emissor e o receptor não se conhecem explicitamente. |
|||
** Simplifica as conexões entre os objetos, pois mantém-se uma única referência para o seu sucessor apenas. |
|||
** O objeto não possui conhecimento da estrutura atual da cadeia. |
|||
* Mais flexibilidade na atribuição de responsabilidades para objetos. |
|||
* O recebimento não é garantido. |
|||
** A requisição pode ser repassada até o final da cadeia sem receber nenhum tratamento. |
|||
{{esboço-prog}} |
|||
== Exemplo == |
|||
Observe os trechos de código a seguir e veja como funciona a Chain Of Responsibility do tratamento de eventos no AWT 1.0 <ref>http://www.cic.unb.br/~jhcf/MyBooks/iess/Patterns/BehavioralPatterns-82slides.pdf</ref>. |
|||
{{Padrões de projeto}} |
|||
<source lang="java"> |
|||
Class Component { |
|||
.. |
|||
public boolean postEvent(Event e) { |
|||
if (handleEvent(e)) { |
|||
e.consume(); |
|||
return true; |
|||
} |
|||
Component parent = this.parent; |
|||
... |
|||
if (parent != null) { ... |
|||
if (parent.postEvent(e)) { |
|||
e.consume(); |
|||
return true; |
|||
} |
|||
} |
|||
return false; |
|||
} |
|||
} |
|||
</source> |
|||
<br /> |
|||
<source lang="java"> |
|||
public class BancoApplet extends Applet { |
|||
Button clientesButton, contasButton, crediteButton, debiteButton; |
|||
public boolean handleEvent(Event evt) { |
|||
if (evt.id == Event.ACTION_EVENT) { |
|||
if (evt.target == clientesButton) { |
|||
... |
|||
}else if (evt.target == contasButton) { |
|||
... |
|||
}else if (evt.target == crediteButton) { |
|||
... |
|||
}else if (evt.target == debiteButton) { |
|||
... |
|||
} |
|||
else { |
|||
return super.handleEvent(evt); |
|||
} |
|||
} |
|||
} |
|||
</source> |
|||
<br /> |
|||
<div class="references" style="-moz-column-count:3; column-count:3;"> |
|||
</div> |
|||
{{ref-section}} |
|||
[[en:Chain of Responsibility]] |
|||
[[fr:chaîne de responsabilité]] |
|||
[[it:catena della responsabilità]] |
|||
[[ja:責任のチェーン]] |
|||
[[ru:Цепь ответственности]] |
|||
[[Categoria:Programação orientada a objetos]] |
|||
[[Categoria:Padrões de projeto de software]] |
|||
[[Categoria:Engenharia de software]] |
[[Categoria:Engenharia de software]] |
||
[[Categoria:Padrões de projeto de software]] |
|||
[[Categoria:Programação orientada a objetos]] |
|||
Revisão das 01h46min de 18 de novembro de 2011
O padrão de projeto de software Chain of Responsibility representa um encadeamento de objetos receptores para o processamento de uma série de solicitações diferentes. Esses objetos receptores passam a solicitação ao longo da cadeia até que um ou vários objetos a tratem.
Cada objeto receptor possui uma lógica descrevendo os tipos de solicitação que é capaz de processar e como passar adiante aquelas que requeiram processamento por outros receptores. A delegação das solicitações pode formar uma árvore de recursão, com um mecanismo especial para inserção de novos receptores no final da cadeia existente.
Dessa forma, fornece um acoplamento mais fraco por evitar a associação explícita do remetente de uma solicitação ao seu receptor e dar a mais de um objeto a oportunidade de tratar a solicitação.
Um exemplo da aplicação desse padrão é o mecanismo de herança nas linguagens orientadas a objeto: um método chamado em um objeto é buscado na classe que implementa o objeto e, se não encontrado, na superclasse dessa classe, de maneira recursiva.
Situações de utilização
- 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 linha 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.
Ligações externas
