Cadena de responsabilitat

De Viquipèdia
Salta a: navegació, cerca

La Cadena de responsabilitat (Chain of Responsibility) és un patró de comportament dintre dels patrons de disseny en enginyeria de programari.

La seva principal finalitat és evitar una relació directa preestablerta entre un emissor d’una petició i el seu receptor final. D'aquesta manera es proporciona a més d'un objecte la possibilitat de tractar una petició.

Consta d'una estructura en cadena, on existeix un objecte (client) que genera una petició i els objectes receptors (Manipuladors) encadenats es passen la petició fins que és processada per algun d'aquests.

Estructura[modifica | modifica el codi]

Diagrama de classes de Cadena de responsabilitat

Participants[modifica | modifica el codi]

  • Manipulador:

- Defineix una interfície per tractar les peticions.[1]

- (opcional) Implementa l'enllaç al successor.[1]

  • ManipuladorConcret

- Tracta les peticions de les quals és responsable.[1]

- Pot accedir al successor.[1]

- Si el ManipuladorConcret pot manegar la petició, ho fa. En cas contrari ho reenvia al seu successor.[1]

  • Client

- Inicialitza la petició a un objecte ManipuladorConcret de la cadena.[1]

Conseqüències[modifica | modifica el codi]

  • Redueix l'acoblament: Ni el receptor ni l'emissor es coneixen explícitament entre ells. I un objecte de la cadena tampoc ha de conèixer l'estructura d'aquesta.[2]
  • Afegeix flexibilitat per assignar responsabilitats a objectes.[2]
  • No és garantida la recepció: Donat que les peticions no tenen un receptor explícit, no hi ha garantia que siguin manipulades. Una petició pot quedar sense tractar quan la cadena no està ben configurada.[2]

Aplicabilitat[modifica | modifica el codi]

  • En els casos en què hi ha més d'un objecte que pot manipular una petició i el manipulador no es coneix “a priori”.[1]
  • Es vol enviar una petició entre diversos objectes sense especificar explícitament el receptor.[1]
  • En el cas en què el conjunt d'objectes que conformen la cadena es defineixen dinàmicament.[1]

Utilitzacions conegudes[modifica | modifica el codi]

  • MacApp i ETT++ hi fan menció però amb el nom de “EventHandler”.[3]
  • En la biblioteca de TCL de symantec es coneix amb el nom de ‘Bureaucrat’.[3]
  • AppKit de NeXT utilitza el nom “Responder”.[3]

Exemple en Java[modifica | modifica el codi]

En aquest exemple es reflecteix l'ús del patró per les 4 operacions aritmètiques bàsiques, on la primera operació rep un objecte que conté dos valors numèrics i una operació a realitzar. L'objecte es va propagant per la cadena fins que troba l'operació que la pot executar.

Diagrama de classes[modifica | modifica el codi]

Diagrama de classes del exemple.

Codi[modifica | modifica el codi]

1 public interface IEslavoCadena {
2     public void afegirSeguentEslavo(IEslavoCadena seguent);
3     public void calcular(Numero n);
4 }

Objecte a propagar.

 1 public class Numero {
 2     private final int n1;
 3     private final int n2;
 4     private final String operacio;
 5     
 6     public Numero(int n1, int n2, String operacio){
 7         this.n1 = n1;
 8         this.n2 = n2;
 9         this.operacio = operacio;
10     }
11     
12     public int obtenirN1(){
13         return n1;
14     }
15     
16     public int obtenirN2(){
17         return n2;
18     }
19     
20     public String obtenirOperacio(){
21         return operacio;
22     }
23 }

Operacions bàsiques.

 1 public class Suma implements IEslavoCadena{
 2     private IEslavoCadena seguent;
 3     
 4     @Override
 5     public void afegirSeguentEslavo(IEslavoCadena seguent) {
 6         this.seguent = seguent;
 7     }
 8 
 9     @Override
10     public void calcular(Numero n) {
11         if(n.obtenirOperacio().equalsIgnoreCase("sumar")){
12             System.out.printf("Resultat de la suma %d\n", (n.obtenirN1()+n.obtenirN2()));
13         }
14         else if(seguent != null){
15             seguent.calcular(n);
16         }
17         else{
18             throw new RuntimeException("No hi ha següent");
19         }
20     }
21     
22 }
 1 public class Resta implements IEslavoCadena{
 2     private IEslavoCadena seguent;
 3     
 4     @Override
 5     public void afegirSeguentEslavo(IEslavoCadena seguent) {
 6         this.seguent = seguent;
 7     }
 8 
 9     @Override
10     public void calcular(Numero n) {
11         if(n.obtenirOperacio().equalsIgnoreCase("resta")){
12             System.out.printf("Resultat de la resta %d\n", (n.obtenirN1()-n.obtenirN2()));
13         }
14         else if(seguent != null){
15             seguent.calcular(n);
16         }
17         else{
18             throw new RuntimeException("No hi ha següent");
19         }
20     }
21     
22 }
 1 public class Producte implements IEslavoCadena{
 2     private IEslavoCadena seguent;
 3     
 4     @Override
 5     public void afegirSeguentEslavo(IEslavoCadena seguent) {
 6         this.seguent = seguent;
 7     }
 8 
 9     @Override
10     public void calcular(Numero n) {
11         if(n.obtenirOperacio().equalsIgnoreCase("producte")){
12             System.out.printf("Resultat del producte %d\n", (n.obtenirN1()*n.obtenirN2()));
13         }
14         else if(seguent != null){
15             seguent.calcular(n);
16         }
17         else{
18             throw new RuntimeException("No hi ha següent");
19         }
20     }
21     
22 }
 1 public class Divisio implements IEslavoCadena{
 2     private IEslavoCadena seguent;
 3     
 4     @Override
 5     public void afegirSeguentEslavo(IEslavoCadena seguent) {
 6         this.seguent = seguent;
 7     }
 8 
 9     @Override
10     public void calcular(Numero n) {
11         if(n.obtenirN2() == 0) throw new RuntimeException("Intent de divisió per 0");
12         if(n.obtenirOperacio().equalsIgnoreCase("divisio")){
13             System.out.printf("Resultat de la divisio %d\n", (n.obtenirN1()/n.obtenirN2()));
14         }
15         else if(seguent != null){
16             seguent.calcular(n);
17         }
18         else{
19             throw new RuntimeException("No hi ha següent");
20         }
21     }
22     
23 }

Programa principal.

 1 public class Main{
 2 
 3     public static void main(String[] args) {
 4         IEslavoCadena suma = new Suma();
 5         IEslavoCadena resta = new Resta();
 6         IEslavoCadena producte = new Producte();
 7         IEslavoCadena divisio = new Divisio();
 8         
 9         Numero n1 = new Numero(5, 5, "producte");
10         Numero n2 = new Numero(15, 3, "divisio");
11         
12         suma.afegirSeguentEslavo(resta);
13         resta.afegirSeguentEslavo(producte);
14         producte.afegirSeguentEslavo(divisio);
15         
16         suma.calcular(n1);
17         suma.calcular(n2);
18     }
19     
20 }

Referències[modifica | modifica el codi]

A Wikimedia Commons hi ha contingut multimèdia relatiu a: Cadena de responsabilitat Modifica l'enllaç a Wikidata
  1. 1,0 1,1 1,2 1,3 1,4 1,5 1,6 1,7 1,8 Gamma, Erich. Patrones de Diseño (en español), p. 207. ISBN 0-201-63361-2. 
  2. 2,0 2,1 2,2 Gamma, Erich. Patrones de diseño (en español), p. 208. ISBN 0-201-63361-2. 
  3. 3,0 3,1 3,2 Gamma, Erich. Patrones de diseño (en español), p. 213. ISBN 0-201-63361-2.