ingenieria del software iv patrones de diseño marina saiz felix

Ingenieria del Software IVPatrones de diseño

Marina Saiz Felix

Patrones de diseñoContenido

Introducción Patrones de diseño más importantes

Visión general: Clasificación Descripción Ejemplo de uso de patrones en la implementación

del lenguaje Visión concreta: Patrón Proxy

Aplicación: Dynamic Proxies (Java y C#) Otros patrones

Conclusiones

Patrones de diseñoIntroducción

Objetivo: Reutilización del conocimiento:

Cada patrón describe un problema que ocurre una y otra vez en nuestro entorno y describe también el núcleo de la solución al problema, de forma que puede utilizarse un millón de veces sin tener que hacer dos veces lo mismo” [Alexander]

Definición:

Un patrón es una solución a un problema general que puede adaptarse a un problema concreto

Patrones de Creación

Patrones estructurales

Patrones de Comportamient

o

Abstract FactoryBuilder

Factory MethodPrototypeSingleton

AdapterBridge

CompositeDecorator

FacadeFlyweight

Proxy

Chain of ResponsibilityCommandInterpreter

IteratorMediatorMementoObserver

StateStrategy

Template MethodVisitor


Clasificación:


Clasificación:

Patrones de creación: relativo a la creación de objetos

Patrones de comportamiento: caracteriza la forma en que clases y objetos interactúan y la distribución de responsabilidades

Patrones estructurales: trata de la composición de clases u objetos

Patrones de diseñoDe Creación

Factory Method:

Definición:define un interfaz para crear un objeto, pero deja que las subclases decidan qué clase instanciar. Este patrón delega la instanciación de una clase a sus subclases

Aplicación en .NET (FCL) System.Collections.IEnumerable System.Net.WebRequest System.Security.Cryptography System.Security.Policy:IIdentityPermissionFactory ASP.NET HTTP Pipeline

Patrones de diseñoDe Creación

Singleton:

Definición: asegura que una clase sólo tendrá una instancia, y provee un punto global de acceso a la misma.

Aplicación en Java La clase java.lang.Runtime del API de Java es

una clase Singleton, no tiene constructores públicos y se obtiene su única instancia llamando a getRuntime()


Clasificación:




Patrones de diseñoDe comportamiento

Command

Definición: Encapsula una petición como un objeto, esto facilita la parametrización de los requerimientos ,el encolado de multiples peticiones y su reordenación, y permite implementar el hacer/deshacer mediante métodos.

Aplicación Java

Las clases Button y MenuItem de Java facilitan la utilización de este patrón, declaran los métodos getActionCommand y setActionCommand para dar nombres a las acciones realizadas por los objetos, facilitándose una correspondencia entre ambos.

.NET: System.EventsArgs


Iterator

Definición: Permite acceder secuencialmente a los elementos de estructura de datos u objetos preservando su estructura interna.

Aplicación en Java Las clases Collection del paquete

java.util utilizan el patrón Iterator.


Mediator

Definición: Define un objeto que encapsula cómo interactúan un conjunto de objetos. Promueve un bajo acoplamiento al evitar que los objetos se refieran unos a otros explícitamente, y permite variar la interacción entre ellos de forma independiente.

Aplicación en Java Java's AWT usa el patrón mediator en la

implementación de la java.awt.Dialog class.


Observer

Definición: Notifica automáticamente de los cambios de estado de un objeto a todos sus dependientes. Permite de forma dinámica implementar dependencias entre objetos, de forma que los objetos dependientes sean notificados de los cambios que se producen en los objetos de los que dependen.

Aplicaciones Java

Delegación de eventos en Java. C#

Events & Delegates


State

Definición: Modelo para que un objeto cambie su comportamiento dependiendo de su estado, pudiendo incluso aparentar que cambia de clase.

Usos: StateEdit AccesibleState DirStateFactory

StateEditable StateFactory


Template Method

Definición: Encapsula un algoritmo en una clase abstracta de forma que puede ser reutilizada.

Aplicación Es muy frecuente su utilización en algoritmos

genéricos de ordenación y búsqueda. En la plataforma .NET se utiliza un patrón template

para implementar una forma génerica de gestión de eventos.


Clasificación:




Patrones de diseñoEstructurales

Adapter

Definición: Convierte la interfaz de una clase en otra más compatible con nuestras necesidades.

Aplicación: Java

WindowAdapter class .NET

System.XML namespace


Composite

Definición: permite construir objetos complejos componiendo de forma recursiva objetos similares en una estructura de árbol. Permite manipular todos los objetos contenidos en el árbol de forma uniforme, ya que todos ellos poseen una interfaz común definida en la clase raíz.

Aplicación en Java: Paquete java.awt


Decorator

Definición: Añadir nuevas responsabilidades dinámicamente a un objeto, es una alternativa a crear demasiadas subclases por herencia.

Aplicación en Java java.io classes : manejo de streams


Facade

Definición: Simplifica el acceso a un conjunto de clases o interfaces. Reduce la dependencia entre clases ofreciendo un punto de acceso al resto de clases

Aplicación: Java : interface JDBC C #: interface ADO.NET


Proxy Definición: proporciona un sustituto o representante

de otro objeto para controlar el acceso a éste.

Estudio Concreto:Patrón PROXY

public interface Subject { public void request();}

abstract class Subject { abstract public void Request();}

class RealSubject : Subject{ override public void Request(){ Console.WriteLine("Called RealSubject.Request()"); }}

JAVA C#

public class RealSubject implements Subject { public void request() { System.out.println("RealSubject.request() executing"); }}


JAVA C#public class Proxy implements Subject { private RealSubject rs = new RealSubject(); public void request() { rs.request(); }}public class Client { public static void main(String[] args) { // create subject proxy Subject s = new Proxy(); // call request through proxy s.request(); }}

class Proxy : Subject{ RealSubject realSubject; override public void Request(){ if( realSubject == null ) realSubject = new RealSubject(); realSubject.Request(); }

public class Client{ public static void Main( string[] args ){ // Create proxy and request a service Proxy p = new Proxy(); p.Request(); }}


Actúan como intermediarios entre el objeto cliente y el objeto deseado

Motivación:

En ocasiones se desea retrasar la instanciación de un objeto hasta que sea necesario utilizarlo. Así el objeto proxy lo sustituye ofreciendo la misma interfaz, solo cuando es necesario le solicita al objeto real la información que necesita.

Otro motivo para su uso es sustituir a un sistema remoto, de forma que se accede al mismo a través de una clase proxy, que permite controlar el acceso

Aplicación Java : Proxy Class del API Dynamic Proxies

Estudio Concreto:Patrón PROXY: Ejemplo

Ejemplo sin utilizar Proxy

/*** Interface IVehicle.*/public interface IVehicle { public void start(); public void stop(); public void forward(); public void reverse(); public String getName();}

Suponer que tenemos la interfaz IVehicle:



/* Class Car*/public class Car implements IVehicle { private String name;

public Car(String name) {this.name = name;}

public void start() { System.out.println("Car " + name + " started"); } // stop(), forward(), reverse() implemented similarly. // getName() not shown.}

Y una clase Car que implementa la IVehicle interface:


/*Class Client1.Interacts with a Car Vehicle directly.*/public class Client1 { public static void main(String[] args) { IVehicle v = new Car("Botar"); v.start(); v.forward(); v.stop(); }}



No Proxy: El Cliente interactúa directamente con los métodos definidos en la interface

Proxy: se encuentra entre la interfaz y la implementación e intercepta las llamadas a los métodos. La inteción del proxy es controlar el acceso al objeto deseado, además de mejorar la funcionalidad del mismo.


Ejemplo utilizando Proxy

/* Class VehicleProxy*/public class VehicleProxy implements IVehicle { private IVehicle v; public VehicleProxy(IVehicle v) {this.v = v;} public void start() { System.out.println("VehicleProxy: Begin of start()"); v.start(); System.out.println("VehicleProxy: End of start()"); } // stop(), forward(), reverse() implemented similarly. // getName() not shown.}


/* Class Client2.Interacts with a Car Vehicle through a VehicleProxy.*/public class Client2 { public static void main(String[] args) { IVehicle c = new Car("Botar"); IVehicle v = new VehicleProxy(c); v.start(); v.forward(); v.stop();

}}

Ejemplo utilizando Proxy


Esta implementación supone una clase proxy por cada par interface/implementation además de que cada método debe codificarse por separado.

Una mejor versión del proxy se puede implementar usando el package ava.lang.reflect. Para llevar a cabo este propósito se usa la clase java.lang.reflect.Proxy junto con la interface java.lang.reflect.InvocationHandler.

Estudio Concreto:Dynamic Proxies en Java Una dynamic proxy class es una clase que implementa

una lista de interfaces especificadas en tiempo de ejecución cuando se crea la clase.

La clase proxy implementa exactamente las interfaces especificadas en su creación

Una dynamic proxy se implementa usando los métodos estáticos que proporciona la clase java.lang.reflect.Proxy y la interface java.lang.reflect.InvocationHandler

Cada instancia de la clase tiene asociada un invocation handler object que implementa la interface InvocationHandler

Estudio Concreto:Dynamic Proxies en Java:Pasos

1.Creation of a Proxy Class

Para crear la clase proxy necesitamos el método estático getProxyClass() de la clase Proxy

El resultado de la llamada a este método es una clase objeto que extiende la Proxy Class e implementa todas las interfaces que se le pasan.

Con esto ya tenemos una clase que representa el proxy

2. Creation of a Proxy Instance

La Proxy class puede ser instanciada a través de el método estático newProxyInstance que tiene como argumentos la ClassLoader bajo la cual se ha definido el proxy, un array de interfaces (passed as an array of java.lang.Class) y una instancia de la InvocationHandler interface.

public static Object newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler ih) throws IllegalArgumentException

Returns a reference to the proxy instance.

Estudio Concreto:Dynamic Proxies en Java:Pasos

3. Method Invocation on a Proxy Instance

Cuando un método es invocado en una instancia de la clase proxy, el método es codificado y remitido al método invoke de su invocation handler.

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable

The proxy instance itself. A Method object corresponding to the method invocation to be

made on the proxy instance. The declaring class of this Method object will be the interface implemented by the proxy instance.

An array of objects containing the arguments of the method invocation.

El valor que retorna el método invoke() será el valor que retorne la instancia del proxy.

Estudio Concreto:Dynamic Proxies en Java: Ejemplo genérico

public class DynamicProxy implements InvocationHandler{

private Object target = null; public static Object newInstance(Object target){

Class targetClass = target.getClass(); Class interfaces[] = target.getInterfaces(); return Proxy. newProxyInstance(targetClass. getClassLoader(), interfaces, new DynamicProxy(target));

} private DynamicProxy(Object target) { this.target = target; }

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable{ Object invocationResult = null;

try { System.out.println("Before method " + method.getName(); invocationResult = method.invoke(this.target, args); System.out.println("After method " + method.getName(); } catch(InvocationTargetException ite) { //this is the exception thrown by the method being invoked //we just rethrow the wrapped exception to conform to the interface throw ite.getTargetException(); } catch(Exception e) { System.err.println("Invocation of " + method.getName() + " failed"); System.err.println(e.getMesage()); } finally{ return invocationResult; } } }

Estudio Concreto:Dynamic Proxies en Java

Estudio Concreto:Dynamic Proxies en Java Usar el dynamic proxy es trivial, solamente requiere utilizar

el método newInstance cada vez que se desee instanciar una implementación tal y como se muestra a continuación:

Foo aFoo = (Foo) DynamicProxy.newInstance(new FooImpl());

aFoo.doSomething(); aFoo.doAnother();

will result in invoke() intercepting doSomething() and doAnother() are called.

Estudio Concreto:Dynamic Proxies en Java:Ejemplo práctico

“Aplicación Swing que permite al usuario cambiar el título de un frame”

Se usa una instancia de la clase proxy para gestionar todos los eventos que puedan ocurrir en el frame:

We’ll add a WindowListener on the frame to close the application.

We’ll add a FocusListener on the text field to change the background color of the text field to yellow when it has the focus.

We’ll add an ActionListener on the buttons to perform their actions.

We’ll add a DocumentListener on the text field to enable the clear button only if the text field contains some text.


1.Crear la clase proxy que implemente todos los listeners que se necesitan. A continuación crear una instancia de la clase proxy. Estas dos operaciones se realizan mediante el método Proxy.newProxyInstance() :

...

// Create the dynamic proxy instance

aListenerProxy = (Proxy) Proxy.newProxyInstance( getClass().getClassLoader(), new Class[] { WindowListener.class, ActionListener.class, FocusListener.class, DocumentListener.class }, this);

...


2.Para poder crear la instancia de proxy necesitamos pasarle un InvocationHandler object que recibirá todas las llamadas a los métodos

... // Adding the proxy on the Swing components

addWindowListener((WindowListener) aListenerProxy); btnOk.addActionListener((ActionListener) aListenerProxy); btnClear.addActionListener((ActionListener) aListenerProxy); txfName.addFocusListener((FocusListener) aListenerProxy); txfName.getDocument().addDocumentListener((DocumentListener) aListenerProxy);

Estudio Concreto:Dynamic Proxies en Java:Ejemplo práctico 3.Una vez tenemos todo esto, solamente falta poner el código en

el método invoke() para implementar el comportamiento deseado:

public Object invoke(Object aProxy, Method aMethod, Object[] someArguments) {

// If a method invocation was done on the WindowListener interface

if (aMethod.getDeclaringClass() == WindowListener.class) {

// Close the demo and exit the VM

if (aMethod.getName().equals("windowClosing")) { System.exit(0); }

// If a method invocation was done on the ActionListener interface

} else if (aMethod.getDeclaringClass() == ActionListener.class) {

// Perform the action of the buttons

ActionEvent anEvent = (ActionEvent) someArguments[0];

if (anEvent.getSource() == btnOk) { setTitle(txfName.getText()); }

else { txfName.setText(""); }

…

Estudio Concreto:Dynamic Proxies en Java:Conclusiones

Desventajas creating Class objects at runtime and using reflection to dispatch

the method invocation is more CPU intensive and slower

Ventajas the runtime generation of the class provides an

alternative to reading .class files from the file system or from a remote server The first benefit can be used in an applet that utilizes RMI where the time to download the classes is critical

It also provides the possibility of having a single point of method dispatching, the InvocationHandler interface.

Estudio Concreto:Dynamic Proxies en C#

Dos maneras de llevarlo a cabo:

Usando la clase RealProxy

Usando Reflection.Emit para generar una nueva clase en tiempo de ejecución que anule/implemente los métodos necesarios y que remita las invocaciones hacia un handler genérico


System.Reflection.Emit Creación de nuevos tipos en tiempo

de ejecución Generación dinámica de assemblies Simplifica la generación de código en

run-time Los assemblies pueden ser:

Transient: solo existen en memoria Permanent: son grabados en disco


La implementación se lleva a cabo en una clase que heredará de CallHandler (una versión de InvocationHandler que se utilizaba en java) i los proxies serán creados por una clase ObjectFactory (equivalente a la java.lang.reflect.Proxy de java)

Considerando las interfaces y clases siguientes veamos como se implementaria:public interface IMyBizFace {

int DoSomething(); } public class SomeClass : IMyBizFace { public int DoSomething() { Console.WriteLine("In DoingSomething() ..."); return -347; } }

Para mantener listado de las llamadas


public class TraceDecorator : CallHandler { object _inner; public TraceDecorator(object obj) { _inner = obj; } public override object Invoke(string pStrMethodName,object[] parms) { Console.WriteLine("Proxyfying call ..."); object ret = InvokeMember(_inner,pStrMethodName,parms); Console.WriteLine("End of proxyfied call ..."); return ret; } }


La clase CallHandler se define de la siguiente forma:

public abstract class CallHandler { protected object InvokeMember(object target,string methodName,object[] parms) { return target.GetType().InvokeMember( methodName, System.Reflection.BindingFlags.InvokeMethod, null, target,parms); } public abstract object Invoke(string methodName,object[] parms); }

El código necesario para utilizar este framework seria:


//ObjetoSomeClass source = new SomeClass();

//Se combina este objeto con la ayuda de un CallHandler que añade //funcionalidad alrededor de los métodos del objeto

CallHandler sourceDecoree = new TraceDecorator(source);


Ahora deberíamos hacer:

((IMyBizFace)sourceDecoree).DoSomething();

Problema:

SourceDecoree es de tipo CallHandler q no expone los mismos interfaces que el objeto inicial. Así pues esta línea de código generará una InvalidCastException


Solución: Es necesario introducir una etapa

suplementaria, la creación de un proxy exponiendo los mismos interfaces que el objeto básico, entorno al handler:

//Se construye un proxy entorno del handler para hacer como si se aplicara los mismos//interfaces que SomeClass//IMyBizFace proxy = (IMyBizFace)ObjectFactory.NewInstance(typeof(SomeClass),sourceDecoree); //A continuación se puede trabajar con el proxy como si se trabajara con el objeto //básicoproxy.DoSomething();


Pasos a realizar Cifrar el método NewInstance() de ObjectFactory

para que genere el MSIL(Microsoft Intermediate Language) equivalente al que procedería de la compilación de la fuente anterior

Problema: MSIL es complicado

Solución: System.Reflection.Emit proporciona un API bastante

a alto nivel para generar de manera sencilla la mayoría de los elementos sintácticos como declaraciones de clases, de métodos…

Estudio Concreto:Dynamic Proxies en C# Para emitir dinámicamente un tipo con

System.Reflection.Emitió, se sigue el siguiente proceso genérico:

Creación de un AssemblyBuilder Apertura de un nuevo ModuleBuilder en el

AssemblyBuilder para contener el tipo Declaración con ayuda de un TypeBuilder Adición de los campos Adición de los constructores con ayuda de

ConstructorBuilder, emisión del código con ayuda el ILGenerator de cada ConstructorBuilder y de la enumeración OpCodes

Adición de los distintos métodos por medio de MethodBuilders, emisión del código con ayuda el ILGenerator de cada MethodBuilder y de la enumeración OpCodes


Las principales clases e interfaces que se utilizan son las siguientes:

AppDomain El ámbito en el cual se va a emitir el montaje dinámico

AssemblyBuilder Permite configurar y construir un assembly dinámicamente

ModuleBuilder Permite configurar y construir un módulo para contener el código que se va a generar

TypeBuilder Declara y configura un nuevo tipo (interfaz, clase...) de manera dinámica

FieldBuilder Declara un nuevo miembro

ConstructorBuilder Declara un nuevo constructor

MethodBuilder Declara y configura un método

ILGenerator Emite el MSIL

Enumeración OpCodes Contiene los todos opcodes soportados por MSIL


Resultado del proceso: Obtención de AssemblyBuilder y TypeBuilder

completos A partir del AssemblyBuilser es posible

guardar el assembly generado sobre el disco. A partir del TypeBuilder es posible, gracias al

método CreateType, crear un System.Type que se puede utilizar directamente en el ámbito normal para crear objetos

Patrones de diseñoAplicaciones: otros patrones Prototype

Java: JavaBean C#: Clone

Memento C#: Object Serialization

Strategy Java: El paquete java.util.zip en las clases

CheckedInputStream y CheckedOutputStream utilizan la clase Checksum la cual sigue el patrón Strategy para elegir entre los algoritmos de comprobación de errores en Streams de bytes ya sea CRC32 o Adler32.

Patrones de diseñoConclusiones

Aplicación de patrones de diseño útil para: Diseño de nuevas aplicaciones Implementación de lenguajes de

programación Dynamic Proxy: aplicación

concreta Java C#

Referencias http://java.sun.com/j2se/1.4.2/docs/api/java/lang/reflect/Proxy.html http://www.kuro5hin.org/story/2002/9/21/19225/2806 http://www.javaworld.com/javaworld/jw-11-2000/jw-1110-proxy.html http://www.dotnetguru.org/articles/dossiers/instrumentation/

proxiesdynamiques.htm http://java.sun.com/j2se/1.3/docs/guide/reflection/proxy.html#api http://www.cramon.dk/dynamicproxy.htm http://java.sun.com/j2se/1.3/docs/api/java/lang/reflect/Proxy.html http://java.sun.com/j2se/1.3/docs/guide/reflection/proxy.html http://www.prabhums.org/weblogs/files/

16ddf219448198feede4b3230470fc9fintercept_dproxy.htm http://www.comp.lancs.ac.uk/computing/research/cseg/projects/REFLEX/

RProxy/ http://www.ociweb.com/jnb/files/ProxyDemo.java http://www.codeproject.com/dotnet/dynamicproxy.asp http://www.codeproject.com/csharp/DynamicProxy.asp http://joe.truemesh.com/blog/000181.html http://blog.monstuff.com/archives/000098.html

ingenieria del software iv patrones de diseño marina saiz felix

Documents