Proxy (patrón de diseño)

De Wikipedia, la enciclopedia libre
Saltar a: navegación, búsqueda

El patrón Proxy es un patrón estructural que tiene como propósito proporcionar un subrogado o intermediario de un objeto para controlar su acceso.

Patrón Proxy

Motivación[editar]

Para explicar la motivación del uso de este patrón veamos un escenario donde su aplicación sería la solución más adecuada al problema planteado. Consideremos un editor que puede incluir objetos gráficos dentro de un documento. Se requiere que la apertura de un documento sea rápida, mientras que la creación de algunos objetos (imágenes de gran tamaño) es cara. En este caso no es necesario crear todos los objetos con imágenes nada más abrir el documento porque no todos los objetos son visibles. Interesa por tanto retrasar el coste de crear e inicializar un objeto hasta que es realmente necesario (por ejemplo, no abrir las imágenes de un documento hasta que no son visibles). La solución que se plantea para ello es la de cargar las imágenes bajo demanda. Pero, ¿cómo cargar las imágenes bajo demanda sin complicar el resto del editor? La respuesta es utilizar un objeto proxy. Dicho objeto se comporta como una imagen normal y es el responsable de cargar la imagen bajo demanda.


Aplicabilidad[editar]

El patrón proxy se usa cuando se necesita una referencia a un objeto más flexible o sofisticada que un puntero. Dependiendo de la función que se desea realizar con dicha referencia podemos distinguir diferentes tipos de proxies:

  • proxy remoto: representante local de un objeto remoto.
  • proxy virtual: crea objetos costosos bajo demanda (como la clase ImagenProxy en el ejemplo de motivación).
  • proxy de protección: controla el acceso al objeto original (ejemplo de proxy de protección: [1])
  • proxy de referencia inteligente: sustituto de un puntero que lleva a cabo operaciones adicionales cuando se accede a un objeto (ej. contar número de referencias al objeto real, cargar un objeto persistente bajo demanda en memoria, control de concurrencia de acceso tal como bloquear el objeto para impedir acceso concurrente, …).



Participantes[editar]

La clase Proxy : mantiene una referencia al objeto real (en el siguiente ejemplo se le denomina _sujetoReal) y proporciona una interfaz idéntica al sujeto (la clase Sujeto). Además controla el acceso a dicho objeto real y puede ser el responsable de su creación y borrado. También tiene otras responsabilidades que dependen del tipo de proxy:

  • proxy remoto: responsable de codificar una petición y sus argumentos, y de enviarla al objeto remoto.
  • proxy virtual: puede hacer caché de información del objeto real para diferir en lo posible el acceso a este.
  • proxy de protección: comprueba que el cliente tiene los permisos necesarios para realizar la petición.

La clase Sujeto: define una interfaz común para el proxy (Proxy) y el objeto real (de la clase SujetoReal), de tal modo que se puedan usar de manera indistinta.

La clase SujetoReal: clase del objeto real que el proxy representa.

Colaboraciones.[editar]

Dependiendo de la clase de proxy, el objeto proxy redirige las peticiones al objeto real que representa.

Ejemplos de funcionamiento:

  • Diagrama de clases para un ejemplo del patrón proxy.[2]
  • Diagrama de secuencia para un ejemplo en el que no se utiliza el patrón proxy. [3]
  • Diagrama de secuencia para un ejemplo en el que se utiliza el patrón proxy.[4]

Consecuencias.[editar]

El uso de un proxy introduce un nivel de indirección adicional con diferentes usos:

  • Un proxy remoto oculta el hecho de que un objeto reside en otro espacio de direcciones.
  • Un proxy virtual puede realizar optimizaciones, como la creación de objetos bajo demanda.
  • El proxy de protección y las referencias inteligentes permiten realizar diversas tareas de mantenimiento adicionales al acceder a un objeto.

Además, su uso también permite realizar una optimización COW (copy-on-write) , puesto que copiar un objeto grande puede ser costoso, y si la copia no se modifica, no es necesario incurrir en dicho gasto. Además el sujeto mantiene un número de referencias, y sólo cuando se realiza una operación que modifica el objeto, éste se copia. Es útil por tanto para retrasar la replicación de un objeto hasta que cambia.

Implementación.[editar]

Ejemplo Java[editar]

/**
 * Clase Cliente:  el cliente del sujeto tan solo conoce que maneja un objeto de la
 * clase Sujeto. Por tanto, funciona indistintamente con el SujetoReal
 * como con su Proxy.
 */
 
public class Cliente {
 
  /**
  * El constructor guarda la referencia al sujeto.
  */
 
  public Cliente(Sujeto sujeto) {
       _sujeto = sujeto; 
  }
 /** 
   * Lo único que realiza el cliente en su método ejecutar es 
   * llamar 2 veces al metodo1, luego 1 vez al metodo2, 
   * y de nuevo al metodo1. Comprueba con anterioridad en
   * función de la cadena que se le pasa por parámetro si 
   * el método ejecutar se realiza sobre un objeto proxy o sobre
   * un objeto sujeto real.
   */
 
  public void ejecutar(String s) {
    Proxy p;
    SujetoReal sr;
 
    if (s.equals(“proxy”)) {
        p = (Proxy) _sujeto;
        p.metodo1();
        p .metodo1();
        p .metodo2();
        p.metodo1();
   }
    else {
        sr = (SujetoReal) _sujeto;
        sr.metodo1();
        sr.metodo1();
        sr.metodo2();
        sr.metodo1();
  }
}
 
 
 /**
   *  La clase Cliente tiene el atributo _sujeto que le permite tener una referencia al sujeto al que 
   *  el cliente envía la petición de ejecutar un determinado método.
   */ 
 
     private Sujeto _sujeto;
 
 }
/**
   * La clase Sujeto dentro del patrón Proxy es la interfaz del sujeto
   * real de cara al exterior (Cliente). Es una clase abstracta cuyos
   * métodos serán implementados tanto por el sujeto real como por el proxy.
   */
 
   public abstract class Sujeto {
 
  /**
    * El constructor guarda el nombre del sujeto.
    */
     public Sujeto(String nombre) { 
         _nombre = nombre; 
    }
 
  /**
   * Método que devuelve el nombre del sujeto.
   */
     public String toString() { 
          return _nombre; 
    }
 
  /**
   * Métodos definidos de forma abstracta en la clase Sujeto, y que tendrán distintas implementaciones en las clases que heredan de ésta: Proxy
   * y SujetoReal.
   */
 
     public abstract void metodo1();
     public abstract void metodo2();
 
  /**
   * Este método llama al método toString() de la clase Proxy. Se le pasa un objeto de la clase Sujeto, pero se considera que se trata de un objeto proxy.
   */
 
     public void status (Sujeto sujeto) {
         Proxy p;
         p = (Proxy) sujeto;
         p.toString();
     }   
 
  /**
   *  La clase Sujeto tiene el atributo _nombre , que indica el nombre  de un sujeto,  tanto si se trata de un proxy
   *  como de un sujeto real.
   */ 
 
     private String  _nombre;
 
}
/**
 * Éste es el objeto Proxy. Este proxy es simultáneamente un 
 *
 * (a) proxy virtual que retrasa la creación del objeto real hasta que
 *     se invoca alguno de sus métodos.
 * (b) referencia inteligente, realizando labores de contabilización
 *     del número de veces que se invoca un método.
 */
 
public class Proxy extends Sujeto {
 
   /**
    * el constructor de la clase, además de inicializar a la parte
    * correspondiente a la superclase, establece a null la referencia
    * al sujeto real e inicializa la contabilización.
    */
 
  public Proxy (String nombre) {
     super(nombre);
    _sujetoReal = null;
   _accesosMetodo1 = 0;
   _accesosMetodo2 = 0;
  }
 
  /**
   * En lugar de realizar de cada vez una comprobación de si el
   * sujeto real esta creado y en caso contrario crearlo, se define
   * este método privado.
   */
 
  private SujetoReal obtenerSujetoReal() {
    if (_sujetoReal == null)
      _sujetoReal = new SujetoReal(this + " (Real)");
 
    return _sujetoReal;
  }
 /**
   * Los métodos delegan en el sujeto real.
   */
 
  public void metodo1() { 
    _accesosMetodo1++; 
    obtenerSujetoReal().metodo1(); 
  }
 
  public void metodo2() { 
    _accesosMetodo2++;
    obtenerSujetoReal().metodo2(); 
  }
 
  /**
    * Este método permite presentar información de contabilización
    * de uso del objeto.
    */
 
  public void toString() {
    if (_sujetoReal != null)
      System.out.println("Accesos a " + _sujetoReal + 
                         ": metodo1=" + _accesosMetodo1 + 
                         ", metodo2=" + _accesosMetodo2);
    else 
      System.out.println("Sujeto Real (" + this + ") no creado.");
  }
 
  /**
   * Atributos privados: _sujetoReal que le permite a la clase Proxy tener una referencia al sujeto real y los contabilizadores de los accesos a
  * los métodos 1 y 2.
   */
 
  private SujetoReal _sujetoReal; 
  private int  _accesosMetodo1, _accesosMetodo2;
}
/** 
 * La clase SujetoReal es el objeto sobre el que queremos
 * implementar un proxy. Extiende la clase Sujeto implementando los
 * métodos del sujeto (en realidad es el sujeto el que presenta
 * la interfaz de los métodos del sujeto real...)
 */
 
public class SujetoReal extends Sujeto {
 
  public SujetoReal(String nombre) { 
     super(nombre); 
     // aquí aparece el código de una inicialización costosa: por ejemplo,  añadir un objeto (que se le pasase como parámetro al constructor) a
     // un vector que tuviese como atributo esta misma clase (SujetoReal), y luego ordenar dicho vector de 
     // mayor a menor en función de un atributo entero que tuviese la clase a la que pertenecen los objetos que contiene el vector.
     // Otro ejemplo de inicialización costosa sería el llamar en el constructor a un método de esta clase: por
     //  ejemplo loadImageFromDisk() lo cúal sería lógico si  se tratase de una clase ImagenReal que tuviese como proxy la clase ProxyReal y 
     // como clase abstracta de la que hereda, la clase Imagen.
  }
 
  /**
    * Se implementan los dos métodos abstractos del sujeto.
    */
 
  public void metodo1()  {
      System.out.println("Ejecutando metodo1 en " + this);
   }
 
  public void metodo2() {
      System.out.println("Ejecutando metodo2 en " + this);
   }
 
}
/**
 * Programa principal. 
*/
 
public class Main {
 
   public static void main(String argv[]) {
 
    Sujeto objetoA = new Sujeto(“objetoA”);       // esta mal!! una clase abstracta no se puede instanciar //y por que nadie lo borra o lo corrige
    Cliente c = new Cliente(objetoA);
    objetoA.status(objetoA);
    c.ejecutar(“proxy”);
    objetoA.status(objetoA);
 
 
    Sujeto objetoB = new Sujeto(“objetoB”);
    Cliente d = new Cliente(objetoB);
 
    d.ejecutar(“sujeto real”);
  }
 
}

Patrones relacionados.[editar]

  • El patrón Adaptador proporciona una interfaz diferente al objeto que adapta, mientras que el proxy tiene la misma interfaz, pero ambos redirigen la petición del cliente al verdadero sujeto que la ejecuta con la posibilidad de incorporar lógica adicional : comprobación de acceso, creación del sujeto real…
  • El Proxy se puede diseñar de manera similar al patrón decorador, pero el propósito es diferente: el decorador añade responsabilidades a un objeto, el proxy sólo controla su acceso. Así, si el proxy no tiene una fuerte dependencia con el sujeto real (por ejemplo, no es de creación), y no tiene que instanciarlo, puede adoptar el mismo diseño que el decorador, y ser un proxy de cualquier sujeto (referencia a la interfaz que el cliente conoce).


Ejemplos comunes de la aplicación del patrón proxy.[editar]

A continuación se presentan algunos de los ejemplos más comunes en los que se utiliza el patrón proxy :

  • Añadir acceso de seguridad a un objeto existente. El proxy determinará si el cliente puede acceder al objeto de interés (proxy de protección).
  • Proporcionando interfaz de recursos remotos como el servicio web o recursos REST.
  • Coordinación de las operaciones costosas en recursos remotos pidiendo los recursos a distancia para iniciar la operación tan pronto como sea posible antes de acceder a los recursos.
  • Agregar una operación segura para los subprocesos a una clase existente sin cambiar el código de la clase existente.