PROXY

Nombre

Proxy

Clasificación

Estructural

Intención

Provee un sustituto de un objeto para contro-lar su acceso.

También conocido como

Surrogate (sustituto).

Motivo

Una razón para controlar el acceso de un ob-jeto es postergar el costo de su creación hasta el momento en que lo necesitemos. Considere un editor de texto, que ofrece la capacidad de embeber objetos gráficos en el documento. Algunas gráficas necesitan cargar imágenes pesadas, y por lo tanto es costoso crearlas. Por otro lado, abrir un documento debe ser rápido, por eso debemos evitar crear todos los objetos pesados una vez abrimos el documento, esto además se puede hacer ya que no todos los objetos se utilizaran instantáneamente. Esta restricción sugiere crear cada objeto por demanda, lo que podemos lograr utilizando el patrón proxy.

Aplicabilidad

Proxy se utiliza siempre que se necesite utili-zar una referencia versátil a un objeto. A con-tinuación se describen algunas situaciones comunes en las que se debe aplicar el patrón proxy:
• Proxy remoto. Se desea representar un objeto remoto como local.
• Proxy virtual. Se desea crear objetos pe-sados por demanda.
• Proxy protector. Se desea controlar el acceso a un objeto.
• Una referencia inteligente remplaza a un punto básico de acceso para ejecutar cambios cuando un objeto es accedido.

Estructura


Participantes

• Proxy: mantiene una referencia que le permite acceder al sujeto real. Puede manejar al sujeto si RealSubject y la in-terfaz Subject son lo mismo. Implementa la misma interfaz que el sujeto real, de esta manera, proxy puede ser remplaza-do por RealSubject. Controla el acceso a real subject, también puede crearlo y eliminarlo. Además de estas responsabi-lidades hay unas adicionales, que de-penden del tipo de proxy con el que se trabaje.

1. Un proxy remoto, es responsable de codificar una petición y sus argumentos, y de enviar la petición codificada a al sujeto real en una dirección diferente.
2. Un proxy virtual puede almacenar in-formación adicional del objeto real, de esta manera puede posponer el acceso a él.
3. Un proxy de protección revisa que el llamado tengan las restricciones de acceso, para ejecutar la petición.

• Subject: define la interfaz para RealSub-ject y proxy, así proxy puede remplazar al Realsubject. • RealSubject: representa el objeto real que el proxy representa.

Colaboración

Proxy envía peticiones a RelaSubject cuando es apropiado, dependiendo del tipo de pr-oxy.

Consecuencias

El patrón de diseño proxy introduce cierto rango de desvío sobre el acceso de un obje-to, los usos de este desvío dependen del ti-po de proxy.
• Un proxy remoto oculta el hecho que ob-jetos residen en diferentes espacios de direcciones.
• Un proxy virtual tales como crear o copiar un objeto bajo demanda.
• Un proxy para protección o las referen-cias inteligentes permiten realizar tareas de control sobre los objetos accedidos.

Codigo ejemplo
El código ejemplo utiliza un proxy virtual para hacer la creación por demanda de una serie de imágenes que pueden tornar el programa pesado si se cargan todas al inicio; el programa permite visualizar en pantalla los diagrama de clases de los diferentes patrones estructurales.

//Interfaz que define el objeto (Subject)

import java.awt.Image;

public interface Imagen {

public Image obtenerImagen();

}

//Esta clase es la clase encargada de crear el objeto sustituto

//que se encarga de controlar el acceso al objeto real (Proxy)

import java.awt.Image;

public class ImagenProxy implements Imagen {

private Imagen imagen=null;

private String nombreImagen;

public ImagenProxy(String nombreImagen){

this.nombreImagen= nombreImagen;

}

public Image obtenerImagen() {

if(imagen == null)imagen=new ImagenReal(nombreImagen);

return imagen.obtenerImagen();

}

}

//Este es el objeto real (SubjectReal)

import java.awt.Image;

import java.awt.image.BufferedImage;

import java.io.IOException;

import javax.imageio.ImageIO;

public class ImagenReal implements Imagen {

private BufferedImage imagen;

public ImagenReal(String nombreImagen){

cargarImagen(nombreImagen);

}

public Image obtenerImagen() {

return (Image)imagen;

}

public void cargarImagen(String nombre){

try{

imagen = ImageIO.read(getClass().getClassLoader().getResource("DiagramasDeClase\\"+ nombre));

}catch(IOException e){

System.out.println("Error intentando cargar la imagen");

}

}

}

//Clase cliente que utiliza el objeto real (Client)

import javax.swing.JPanel;

import javax.swing.JRadioButton;

import javax.swing.ButtonGroup;

import javax.swing.JFrame;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.Image;

import java.awt.Color;

import java.awt.Graphics;

public class Cliente extends JFrame implements ActionListener{

private JPanel panel;

private JRadioButton adapter;

private JRadioButton bridge;

private JRadioButton composite;

private JRadioButton decorator;

private JRadioButton facade;

private JRadioButton proxy;

private ButtonGroup grupo;

private Image imagen=null;

private ImagenProxy [] imagenes = {new ImagenProxy("Adapter.jpg"), new ImagenProxy("Bridge.jpg"), new ImagenProxy("Composite.jpg"),new ImagenProxy("Decorator.jpg"),new ImagenProxy("Facade.jpg"),new ImagenProxy("Proxy.jpg")};

private Imagen miImagen = imagenes[0];

public Cliente(){

panel = new JPanel();

adapter= new JRadioButton("Adapter");

bridge=new JRadioButton("Bridge");

composite= new JRadioButton("Composite");

decorator= new JRadioButton("Decorator");

facade= new JRadioButton("Facade");

proxy = new JRadioButton("Proxy");

grupo = new ButtonGroup();

this.setTitle("DIAGRAMAS DE CLASES PATRONES ESTRUCTURALES");

this.setSize(650,500);

this.setResizable(false);

this.setVisible(true);

this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

grupo.add(adapter);

grupo.add(bridge);

grupo.add(composite);

grupo.add(decorator);

grupo.add(facade);

grupo.add(proxy);

panel=(JPanel)this.getContentPane();

panel.setLayout(null);

panel.add(adapter);

panel.add(bridge);

panel.add(composite);

panel.add(decorator);

panel.add(facade);

panel.add(proxy);

adapter.setBounds(20, 20, 70, 20);

bridge.setBounds(110, 20, 70, 20);

composite.setBounds(210, 20, 90, 20);

decorator.setBounds(330, 20, 90, 20);

facade.setBounds(450, 20, 70, 20);

proxy.setBounds(560, 20, 70, 20);

adapter.addActionListener(this);

bridge.addActionListener(this);

composite.addActionListener(this);

decorator.addActionListener(this);

facade.addActionListener(this);

proxy.addActionListener(this);

}

public static void main(String args[]){

JFrame.setDefaultLookAndFeelDecorated(true);

new Cliente();

}

public void paint(Graphics g){

imagen=miImagen.obtenerImagen();

g.drawImage(imagen,20,120, 600,330,this);

}

public void actionPerformed(ActionEvent e) {

if(e.getSource()==adapter){

miImagen = imagenes[0];

}

if(e.getSource()==bridge){

miImagen = imagenes[1];

}

if(e.getSource()==composite){

miImagen = imagenes[2];

}

if(e.getSource()==decorator){

miImagen = imagenes[3];

}

if(e.getSource()==facade){

miImagen = imagenes[4];

}

if(e.getSource()==proxy){

miImagen = imagenes[5];

}

repaint();

}

}

Usos conocidos

Un proxy es utilizado en las clases de constructor de bloques de texto de ET++, para crear objetos por demanda.

Patrones relacionados

• Adapter provee una interfaz adicional al objeto que adapta, en contraste proxy ofrece la misma interfaz a un objeto.
• Decorator puede tener una implementa-ción parecida a Proxy, pero la intención de decorator es agregar responsabilida-des a un objeto, y la de proxy es contro-lar el acceso de este.

Referencias bibliográficas
[1] Erich Gamma et al, Elements of reusable object-oriented software.
[2] Steve Holzner, Design patterns for dummies, Wiley Publishing Inc, Indianapolis, EEUU, 2006, 339.
[3] Jesús García Molina, Análisis y diseño de software - Patrones de diseño, dis.um.es/~jmolina/astema3.