b'\n_START_ARTICLE_\nCadena de responsabilidad\n_START_PARAGRAPH_\nEl patr\xc3\xb3n de dise\xc3\xb1o Chain of Responsibility es un patr\xc3\xb3n de comportamiento que evita acoplar el emisor de una petici\xc3\xb3n a su receptor dando a m\xc3\xa1s de un objeto la posibilidad de responder a una petici\xc3\xb3n. Para ello, se encadenan los receptores y pasa la petici\xc3\xb3n a trav\xc3\xa9s de la cadena hasta que es procesada por alg\xc3\xban objeto._NEWLINE_Este patr\xc3\xb3n es utilizado a menudo en el contexto de las interfaces gr\xc3\xa1ficas de usuario donde un objeto puede estar compuesto de varios objetos (que generalmente heredan de una super clase "vista"). No se debe confundir con el patr\xc3\xb3n Composite (patr\xc3\xb3n de dise\xc3\xb1o) que se basa en un concepto similar. Seg\xc3\xban si el ambiente de ventanas genera eventos, los objetos los manejan o los "pasan" (transmiten) hasta que alg\xc3\xban elemento consume dicho evento y se detiene la propagaci\xc3\xb3n._NEWLINE_Un claro ejemplo de cadena de responsabilidades ser\xc3\xada una estructura de datos que contiene nodos cuya implementaci\xc3\xb3n es opaca para el usuario de dicha estructura de datos (no conoce salvo la interfaz de la estructura de datos). Internamente los nodos se relacionan mediante punteros y una llamada a un m\xc3\xa9todo de la estructura de datos har\xc3\xa1 que un mensaje se propague por la cadena de nodos hasta llegar a su receptor. Es decir, una petici\xc3\xb3n de "b\xc3\xbasqueda(clave)" al contenedor de nodos har\xc3\xa1 que el mismo pase dicho mensaje a uno de los nodos (ra\xc3\xadz, primero, etc; dependiendo de como se haya implementado la estructura de datos) devolviendo el nodo el resultado si su atributo clave coincide con la b\xc3\xbasqueda o mandando dicho mensaje al siguiente nodo en caso contrario. Obviamente se dar\xc3\xada este caso a niveles te\xc3\xb3ricos pues existen formas m\xc3\xa1s optimas de solventar el anterior problema de ejemplo y; sobre todo, ha de tenerse en cuenta que una cadena muy grande de muchos elementos puede llegar a apilar en memoria una gran cantidad de llamadas a procedimientos hasta que la cadena retorne un resultado con su consiguiente coste asociado.\n_START_SECTION_\nMotivaci\xc3\xb3n\n_START_PARAGRAPH_\nSupongamos un servicio de ayuda sensible al contexto para una interfaz gr\xc3\xa1fica. El usuario puede obtener ayuda en cualquier parte de la interfaz pulsando con el rat\xc3\xb3n sobre ella. La ayuda proporcionada depende de la parte de la interfaz que se haya seleccionado as\xc3\xad como de su contexto. Si no existe informaci\xc3\xb3n de ayuda espec\xc3\xadfica para esa parte el sistema deber\xc3\xada mostrar un mensaje de ayuda m\xc3\xa1s general sobre el contexto inmediato._NEWLINE_El problema es que el objeto que en \xc3\xbaltima instancia proporciona la ayuda no conoce expl\xc3\xadcitamente al objeto (por ejemplo, el bot\xc3\xb3n) que inicializa la petici\xc3\xb3n. Necesitamos un modo de desacoplar el bot\xc3\xb3n que da lugar a la petici\xc3\xb3n de ayuda de los objetos que podr\xc3\xadan proporcionar dicha informaci\xc3\xb3n. El patr\xc3\xb3n Cadena de Responsabilidad define c\xc3\xb3mo hacerlo._NEWLINE_La idea de este patr\xc3\xb3n es desacoplar a los emisores y a los receptores d\xc3\xa1ndole a varios objetos la posibilidad de tratar una petici\xc3\xb3n. La petici\xc3\xb3n se pasa a trav\xc3\xa9s de una cadena de objetos hasta que es procesada por uno de ellos._NEWLINE_Supongamos que el usuario solicita ayuda sobre un bot\xc3\xb3n denominado "Imprimir", el cual se encuentra en una instancia de DialogoDeImpresion. El siguiente diagrama muestra c\xc3\xb3mo la petici\xc3\xb3n de ayuda se reenv\xc3\xada_NEWLINE_En este caso, la petici\xc3\xb3n no es procesada ni por unBotonDeImpresion ni por unDialogoDeImpresion; se detiene en unaAplicaci\xc3\xb3n que podr\xc3\xa1 procesarla u obviarla. El cliente que dio origen a la petici\xc3\xb3n no tiene ninguna referencia directa al objeto que finalmente la satisface._NEWLINE_Para reenviar la petici\xc3\xb3n a lo largo de la cadena, y garantizar que los receptores permanecen impl\xc3\xadcitos, cada objeto de la cadena comparte una interfaz com\xc3\xban para procesar peticiones y para acceder a su sucesor. Por ejemplo, en este sistema de ayuda podr\xc3\xada definirse una clase ManejadorDeAyuda._NEWLINE_Las clases Bot\xc3\xb3n, Dialogo y Aplicaci\xc3\xb3n usan las operaciones de ManejadorDeAyuda para tratar peticiones de ayuda. La operaci\xc3\xb3n ManejarAyuda de ManejadorDeAyuda reenv\xc3\xada la petici\xc3\xb3n al sucesor de manera predeterminada. Las subclases pueden redefinir esta operaci\xc3\xb3n para proporcionar ayuda en determinadas circunstancias; en caso contrario, pueden usar la implementaci\xc3\xb3n predeterminada para reenviar la petici\xc3\xb3n.\n_START_SECTION_\nColaboraciones\n_START_PARAGRAPH_\nCuando un cliente env\xc3\xada una petici\xc3\xb3n, \xc3\xa9sta se propaga a trav\xc3\xa9s de la cadena hasta que un objeto ManejadorConcreto se hace responsable de procesarla.\n_START_SECTION_\nPatrones relacionados\n_START_PARAGRAPH_\nEste patr\xc3\xb3n se aplica en ocasiones con el patr\xc3\xb3n Composici\xc3\xb3n. En \xc3\xa9l, los padres de los componentes pueden actuar como sucesores.\n_START_SECTION_\nJava\n_START_PARAGRAPH_\npublic class Cliente {_NEWLINE_    public static void main(String argv[]) {_NEWLINE_      Unidad smith  = new Coronel("Smith", null);_NEWLINE_      Unidad truman = new Coronel("Truman", "Tomar posici\xc3\xb3n enemiga");_NEWLINE_      Unidad ryan   = new Soldado("Ryan");_NEWLINE_      Unidad rambo  = new Soldado("Rambo");_NEWLINE_      System.out.println(rambo.orden());    // rambo ->_NEWLINE__NEWLINE_      rambo.establecerMando(truman);_NEWLINE_      System.out.println(rambo.orden());    // rambo -> truman_NEWLINE__NEWLINE_      ryan.establecerMando(rambo);_NEWLINE_      System.out.println(ryan.orden());     // ryan -> rambo -> truman_NEWLINE_    }}_NEWLINE_/** * La clase Unidad representa la clase abstracta manejadora de la cadena de responsabilidad. * El servicio delegado en la cadena es la solicitud de una orden al mando directo */public abstract class Unidad {_NEWLINE__NEWLINE_    /* en el constructor, adem\xc3\xa1s de un nombre para la unidad, se inicializa la referencia       que implementa la cadena de responsabilidad (_mando): en principio no hay sucesor */_NEWLINE__NEWLINE_    public Unidad(String nombre) { _NEWLINE_        _mando = null; _NEWLINE_        _nombre = nombre;_NEWLINE_    }_NEWLINE__NEWLINE_    public String toString() { return _nombre; }_NEWLINE__NEWLINE_    // cambia el mando de una unidad (modifica cadena de responsabilidad)_NEWLINE__NEWLINE_    public void establecerMando(Unidad mando) { _mando = mando; }_NEWLINE__NEWLINE_    /* comportamiento por defecto de la cadena: delegar en el mando directo o, si se        alcanza el final de la cadena, utilizar una resoluci\xc3\xb3n por defecto (sin orden) */_NEWLINE__NEWLINE_    public String orden() {_NEWLINE_        return (_mando != null ? _mando.orden() : "(sin orden)"); _NEWLINE_    }_NEWLINE__NEWLINE_    private Unidad _mando;_NEWLINE_    private String _nombre;}_NEWLINE_/** * La clase Coronel modifica ligeramente el comportamiento por defecto de la cadena de * responsabilidad: si el coronel tiene una orden espec\xc3\xadfica, utiliza \xc3\xa9sta para resolver * el servicio. Si no tiene una orden espec\xc3\xadfica (_orden==null), emplea el comportamiento * convencional de las unidades */public class Coronel extends Unidad {_NEWLINE__NEWLINE_    // inicializa la parte de unidad e inicializa el estado propio del Coronel (_orden)_NEWLINE__NEWLINE_    public Coronel(String nombre, String orden) {_NEWLINE_      super(nombre);_NEWLINE_      _orden = orden;_NEWLINE_    }_NEWLINE__NEWLINE_    /* refinamiento del servicio que utiliza la cadena de responsabilidad, resolviendo       localmente si tiene \xc3\xb3rdenes espec\xc3\xadficas o comport\xc3\xa1ndose convencionalmente en       caso contrario */_NEWLINE__NEWLINE_    public String orden()    { return (_orden != null ? _orden : super.orden()); }_NEWLINE__NEWLINE_    public String toString() { return ("Coronel " + super.toString()); }_NEWLINE__NEWLINE_    private String _orden;}_NEWLINE_ 1 /** 2  * Esta clase es una extensi\xc3\xb3n instanciable de la superclase Unidad que respeta el 3  * comportamiento por defecto de la cadena de responsabilidad 4  */ 5  6 public class Soldado extends Unidad { 7     // el constructor s\xc3\xb3lo tiene que inicializar la parte correspondiente a la superclase 8     public Soldado(String nombre) { 9         super(nombre);10     }11     public String toString() { return ("Soldado " + super.toString()); }12 }'