Download - Patrones proxy

UNIVERSIDAD NACIONAL DE

TRUJILLO FACULTAD DE CIENCIAS FÍSICAS Y MATEMÁTICAS

ESCUELA ACADÉMICA PROFESIONAL DE ING. INFORMÁTICA

TEMA:

PATRONES DE DISEÑO SOFTWARE ESTRUCTURALES

PROXY

CURSO:

TOPICOS EN SOFTWARE

PROFESOR:

DIAZ PULIDO ARTURO

INTEGRANTES:

ABANTO VERA ANGELICA MARIA

CASTILLO FARFAN GEORGE

IDROGO ZAVALETA ALEX JAIME

TRUJILLO – PERÚ

2014

1 ARQUITECTURA EN PIPELINE

INDICE

DEDICATORIA ............................................................................................... 2

INTRODUCCIÓN ............................................................................................ 3

MARCO TEÓRICO ........................................................................................ 4

CAPITULO I: PATRON PROXY ............................................................................................................. 4

CAPITULO II: CARACTERISTICAS ..................................................................................................... 6

CAPITULO III: APLICABILIDAD ......................................................................................................... 6

CAPITULO IV: CONSECUENCIAS ....................................................................................................... 7

CAPITULO V: VENTAJAS Y DESVENTAJAS ..................................................................................... 8

CÓDIGO ........................................................................................................... 9

CONCLUSIONES .......................................................................................... 10

REFERENCIA BIBLIOGRAFICA ............................................................. 16


DEDICATORIA

Con mucho cariño y estima dedicamos este trabajo a las

personas quienes luchan diariamente por ver de nosotros

personas dignas en la sociedad y en el sendero de la

vida.

El presente trabajo lo dedicamos a usted profesor Arturo

días Pulido por el esfuerzo que realiza con la Institución

de formarnos profesionalmente y ser futuros Ingenieros

Informáticos de capacidad competitiva.

Abanto Vera Angélica María

Castillo Farfán George

Idrogo Zavaleta Alex Jaime


INTRODUCCIÓN

El presente documento aborda uno de los patrones estructurales del grupo de los cuatro (GOF), el

patrón Proxy, el cual según Erich Gamma su propósito es proporcionar un sustituto de un

determinado objeto para controlar el acceso a dicho objeto.

También esta investigación presenta la problemática a la cual es aplicable y la solución que propone

el patrón estructural Proxy incluyendo diagramas de clases y abordamos la responsabilidad que este

debe de realizar. Asimismo se muestra el código de ejemplo implementando el patrón estructural.


MARCO TEÓRICO

CAPITULO I:

EL PATRÓN PROXY

Este patrón consiste en interponer un intermediario (Proxy) entre un objeto y los demás que lo

utilizan. Se diferencia del patrón Adaptador en que el objeto "adaptado" solamente puede ser

manipulado a través del objeto Proxy.

Se suele utilizar para implementar comportamientos "vagos" (lazy). Por ejemplo, si tenemos

muchos objetos imagen en un documento, se tardaría mucho tiempo en abrir el documento al cargar

las imágenes de disco. Para evitarlo podemos sustituir los objetos imagen por objetos proxy Imagen,

con el mismo interfaz, pero que solamente cargan la imagen cuando se va a visualizar.

Debemos insistir en dos aspectos que caracterizan el patrón Proxy:

El objeto Apoderado tiene el mismo interfaz que el objeto "Protegido". Para facilitar esto se

puede derivar el objeto Apoderado de la misma clase padre que el objeto "Protegido", pero

no es absolutamente necesario.

El objeto "Protegido" solamente puede ser manipulado por su correspondiente Apoderado.

Un ejemplo típico de aplicación del patrón proxy es el de un editor de documentos. El editor podrá

incluir imágenes y dibujos complejos, y se plantea el problema de recuperar todos estos costosos

objetos cada vez que se abre el documento. La aplicación del patrón proxy soluciona el problema

definiendo un "representante", que ocupe su lugar, hasta que sea necesario cargarlos.

PROPOSITO

Proporcionar un representante o sustituto de otro objeto para controlar el acceso a éste.

MOTIVACIÓN

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.

Solución:


ESTRUCTURA


CAPITULO II:

CARACTERISTICAS

Proporciona soluciones concretas en la creación de objetos pesados.

Proporciona soluciones técnicas para la utilización de las cargas de objetos de gran tamaño.

Se utilizan en situaciones frecuentes.

Favorece la reutilización de código.

CAPITULO III:

APLICABILIDAD

El patrón proxy se usa cuando se necesita una referencia a in objeto más flexible o sofisticado que

un puntero. Algunas situaciones comunes de aplicación son:

Proxy remoto:Representa un objeto en otro espacio de direcciones.

Proxy virtual: Crea objetos costosos por encargo (como la clase ImageProxy en el ejemplo

de motivación).

Proxy de protección:Controla el acceso a un objeto.

Referencia inteligente: Sustituto de un puntero que lleva a cabo operaciones adicionales

cuando se accede a un objeto (ej. contar el número de referencias, cargar un objeto

persistente en memoria, bloquear el objeto para impedir acceso concurrente,...).

PARTICIPANTES

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 (ImageProxy):

Mantiene una referencia al objeto real.

Proporciona una interfaz idéntica a la del objeto real.

Controla el acceso al objeto real, y puede ser responsable de crearlo y borrarlo

Otras responsabilidades dependen del tipo de proxy:

- Proxies remotos: codifican las peticiones, y las envían al objeto real.

- Proxies virtuales: pueden guardar información del objeto real (caché).

- Proxies de protección: comprueban que el cliente tiene los permisos necesarios

para realizar la petición.

Subject (Graphic): Define una interfaz común para el proxy y el objeto real, de tal modo

que se puedan usar de manera indistinta.

RealSubject (Image): Clase del objeto real que el proxy representa.

CAPITULO IV:

CONSECUENCIAS

El patrón de diseño proxy introduce cierto rango de desvió sobre el acceso de un objeto, los usos de

este desvió dependen del tipo de proxy.

Un proxy remoto puede ocultar 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.

Los proxies de protección y las referencias inteligentes permiten realizar tareas de

mantenimiento adicionales al acceder a un objeto.

Optimización copy-on-write

Copiar un objeto grande puede ser costoso.

Si la copia no se modifica, no es necesario incurrir en dicho gasto.

El sujeto mantiene un número de referencias, y sólo cuando se realiza una operación que

modifica el objeto, éste se copia.


CAPITULO V:

VENTAJAS Y DESVENTAJAS PROXY

Ventajas:

Mantiene una referencia que permite al proxy acceder al objeto real.

Proporciona una interfaz igual que la del sujeto real.

Controla el acceso al sujeto real, y puede ser responsable de crearlo y borrarlo.

Otras responsabilidades, depende del tipo de proxy:

Proxy remoto codifica peticiones y se las manda al sujeto.

Proxy virtual guarda información adicional sobre el sujeto, para retardar el acceso

al mismo.

Proxy de protección comprueba.

Copiar un objeto grande puede ser costoso, si la copia no se modifica, no ay necesidad de

incurrir en dicho gasto.

El sujeto mantiene una cuenta de referencias, solo cuando se hace objeto.

Una operación que modifica el objeto, se copia realmente ejemplo:

Clase String.

Desventajas:

Introduce un nivel de induración adicional, que tiene muchos posibles usos.

Un proxy remoto puede ocultar el hecho de que un objeto reside en otro espacio de

direcciones.

Un proxy virtual puede optimizarsarse, como crear objetos de bajo demanda.

Tanto los proxy de protección, como las referencias inteligentes permiten realizar tareas de

un mantenimiento adicionales cuando se accede a un objeto.


CÓDIGO

CLIENTE:

packagepatronproxy;

importjavax.swing.JFrame;

importjava.awt.Image;

importjava.awt.Graphics;

importjava.io.File;

importjava.io.FileInputStream;

importjava.io.FileOutputStream;

importjava.io.IOException;

importjavax.swing.DefaultListModel;

importjavax.swing.JFileChooser;

importjavax.swing.filechooser.FileNameExtensionFilter;

public class Cliente extends javax.swing.JFrame {

privateImage imagen=null;


private Imagen miImagen = new ImagenProxy("Imagen1.jpg");

public Cliente() {

initComponents();

}

public void paint(Graphics g){

imagen=miImagen.obtenerImagen();

g.drawImage(imagen,110,90, 600,330,this);

}

private void btnCargarActionPerformed(java.awt.event.ActionEventevt) {

// TODO add your handling code here:

JFileChooserfc = new JFileChooser();

fc.setFileFilter(new FileNameExtensionFilter("Archivos de texto","jpg","png","jpeg","bmp"));

intopcion = fc.showDialog(this, "Abrir");

if (opcion == JFileChooser.APPROVE_OPTION) {

//obtenemos ruta de la imagen

String filepath = fc.getSelectedFile().toString();

intpos = filepath.lastIndexOf(System.getProperty("file.separator"));

StringnomFich = null;

if (pos> 0) nomFich = filepath.substring(pos + 1 ) ;

//agregamos al jlist "list" la nueva imagen

DefaultListModellistModel = new DefaultListModel();

for(inti=0 ; i<this.list.getModel().getSize() ; i++ ){

listModel.addElement(this.list.getModel().getElementAt(i));

}

listModel.addElement(nomFich);


this.list.setModel(listModel);

//-------------------------------------------

}

}

private void listMouseClicked(java.awt.event.MouseEventevt) {

// TODO add your handling code here:

if (evt.getClickCount() == 2) {

int index = list.locationToIndex(evt.getPoint());

String seleccionaImagen= list.getSelectedValue().toString();

miImagen = new ImagenProxy(seleccionaImagen);

repaint();

}

}

public static void main(String args[]) {

//<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">

try {

for (javax.swing.UIManager.LookAndFeelInfoinfo :

javax.swing.UIManager.getInstalledLookAndFeels()) {

if ("Nimbus".equals(info.getName())) {

javax.swing.UIManager.setLookAndFeel(info.getClassName());

break;

}

}

} catch (ClassNotFoundException ex) {

java.util.logging.Logger.getLogger(Cliente.class.getName()).log(java.util.logging.Level.SEVERE,

null, ex);

} catch (InstantiationException ex) {



null, ex);

} catch (IllegalAccessException ex) {


null, ex);

} catch (javax.swing.UnsupportedLookAndFeelException ex) {


null, ex);

}

//</editor-fold>

java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {

JFrame.setDefaultLookAndFeelDecorated(true);

newCliente().setVisible(true);

}

});

}

// Variables declaration - do not modify

privatejavax.swing.JButtonbtnCargar;

privatejavax.swing.ButtonGroup buttonGroup1;

private javax.swing.JLabel jLabel2;

privatejavax.swing.JScrollPane jScrollPane1;

privatejavax.swing.JList list;

// End of variables declaration

}

IMAGEN


packagepatronproxy;

//Interfaz que define el objeto (Subject)


public interface Imagen {

publicImageobtenerImagen();

}

IMAGENPROXY

packagepatronproxy;

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

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


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();

} }

IMAGEN REAL

packagepatronproxy;


//Este es el objeto real (SubjectReal)


importjava.awt.image.BufferedImage;

importjava.io.IOException;

importjavax.imageio.ImageIO;

public class ImagenReal implements Imagen {

privateBufferedImageimagen;

publicImagenReal(String nombreImagen){

cargarImagen(nombreImagen);

}

publicImageobtenerImagen() {

return (Image)imagen;

}

public void cargarImagen(String nombre){

try{

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

}catch(IOException e){

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

}

}

}

PATRONES PROXY

packagepatronproxy;


importjavax.swing.JOptionPane;

importorg.jvnet.substance.SubstanceLookAndFeel;

importorg.jvnet.substance.watermark.SubstanceImageWatermark;

public class Patronproxy {

public static void main(String[] args) {

// TODO codeapplicationlogichere

try {

Cliente.setDefaultLookAndFeelDecorated(true);

SubstanceLookAndFeel.setSkin("org.jvnet.substance.skin.MagmaSkin");

SubstanceLookAndFeel.setCurrentTheme("org.jvnet.substance.theme.SubstanceLightAquaTheme")

;

SubstanceLookAndFeel.setImageWatermarkOpacity(new Float(1));

Cliente c = new Cliente();

c.setVisible(true);

} catch (Exception e) {

JOptionPane.showMessageDialog(null,"Ocurrio un

error..."+e.getMessage(),"Mensaje",JOptionPane.ERROR);

}

}

}

CONCLUSIONES

Con el estudio del patrón Proxy hemos concluido que:


Se debe implementar el patrón proxy cuando haya objetos que tomen mucho tiempo en

cargarse, por ejemplo cargar una imagen que consume demasiada memoria.

El patrón Proxy proporciona un representante o sustituto de otro objeto para controlar el

acceso a éste.

REFERENCIA BIBLIOGRAFICA

http://www.ciberaula.com/articulo/patron_proxy/

http://patronesdediseno.blogspot.com/2009/05/patron-proxy.html

http://es.wikipedia.org/wiki/Proxy

http://arantxa.ii.uam.es/~eguerra/docencia/0708/11%20Proxy.pdf

http://modelosprogramacion.blogspot.com/2009/05/proxy.html

http://www.slideshare.net/maitin30/patron-de-diseo-proxy

http://www.ciberaula.com/articulo/patron_proxy/

http://patronesdediseno.blogspot.com/2009/05/patron-proxy.html

http://es.wikipedia.org/wiki/Proxy_(patr%C3%B3n_de_dise%C3%B1o)

http://arantxa.ii.uam.es/~eguerra/docencia/0708/11%20Proxy.pdf

http://modelosprogramacion.blogspot.com/2009/05/proxy.html

http://www.slideshare.net/maitin30/patron-de-diseo-proxy