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

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

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.

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.
4
ARQUITECTURA EN PIPELINE

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:
5
ARQUITECTURA EN PIPELINE

ESTRUCTURA

CAPITULO II:
6
ARQUITECTURA EN PIPELINE

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):
7
ARQUITECTURA EN PIPELINE

 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.
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.

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;
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);
this.list.setModel(listModel);
11
ARQUITECTURA EN PIPELINE

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

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) {

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

} catch (IllegalAccessException ex) {

12
ARQUITECTURA EN PIPELINE

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
packagepatronproxy;

//Interfaz que define el objeto (Subject)

importjava.awt.Image;
13
ARQUITECTURA EN PIPELINE

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;
//Este es el objeto real (SubjectReal)

importjava.awt.Image;

importjava.awt.image.BufferedImage;

importjava.io.IOException;

importjavax.imageio.ImageIO;
14
ARQUITECTURA EN PIPELINE

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) {

15
ARQUITECTURA EN PIPELINE

// 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.
16
ARQUITECTURA EN PIPELINE

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