Your SlideShare is downloading. ×
Patrones proxy
Patrones proxy
Patrones proxy
Patrones proxy
Patrones proxy
Patrones proxy
Patrones proxy
Patrones proxy
Patrones proxy
Patrones proxy
Patrones proxy
Patrones proxy
Patrones proxy
Patrones proxy
Patrones proxy
Patrones proxy
Patrones proxy
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×
Saving this for later? Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime – even offline.
Text the download link to your phone
Standard text messaging rates apply

Patrones proxy

313

Published on

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
313
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
8
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. 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
  • 2. 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
  • 3. 2 ARQUITECTURA EN PIPELINE 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
  • 4. 3 ARQUITECTURA EN PIPELINE 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.
  • 5. 4 ARQUITECTURA EN PIPELINE 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:
  • 6. 5 ARQUITECTURA EN PIPELINE ESTRUCTURA
  • 7. 6 ARQUITECTURA EN PIPELINE 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:
  • 8. 7 ARQUITECTURA EN PIPELINE 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.
  • 9. 8 ARQUITECTURA EN PIPELINE 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.
  • 10. 9 ARQUITECTURA EN PIPELINE 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;
  • 11. 10 ARQUITECTURA EN PIPELINE 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);
  • 12. 11 ARQUITECTURA EN PIPELINE 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) { :
  • 13. 12 ARQUITECTURA EN PIPELINE java.util.logging.Logger.getLogger(Cliente.class.getName()).log(java.util.logging.Level.SEVERE, null, ex); } catch (IllegalAccessException ex) { java.util.logging.Logger.getLogger(Cliente.class.getName()).log(java.util.logging.Level.SEVERE, null, ex); } catch (javax.swing.UnsupportedLookAndFeelException ex) { java.util.logging.Logger.getLogger(Cliente.class.getName()).log(java.util.logging.Level.SEVERE, 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
  • 14. 13 ARQUITECTURA EN PIPELINE packagepatronproxy; //Interfaz que define el objeto (Subject) importjava.awt.Image; 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) importjava.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(); }} IMAGEN REAL packagepatronproxy;
  • 15. 14 ARQUITECTURA EN PIPELINE //Este es el objeto real (SubjectReal) importjava.awt.Image; 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;
  • 16. 15 ARQUITECTURA EN PIPELINE 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:
  • 17. 16 ARQUITECTURA EN PIPELINE  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

×