Ingenieria del Software IV Patrones de diseño

Ingenieria del Software IV Patrones de diseño
Marina Saiz Felix

Patrones de diseño Contenido
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ño Introducció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

Clasificación: Patrones de Creación Patrones estructurales Patrones de Comportamiento Abstract Factory Builder Factory Method Prototype Singleton Adapter Bridge Composite Decorator Facade Flyweight Proxy Chain of Responsibility Command Interpreter Iterator Mediator Memento Observer State Strategy Template Method Visitor

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ño De 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ño De 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()

Patrones de diseño De 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.

Patrones de diseño Estructurales
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
JAVA C# public interface Subject { public void request(); } abstract class Subject { abstract public void Request(); } public class RealSubject implements Subject { public void request() { System.out.println("RealSubject.request() executing"); } class RealSubject : Subject{ override public void Request(){ Console.WriteLine("Called RealSubject.Request()"); }

JAVA C# public class Proxy implements Subject { private RealSubject rs = new RealSubject(); public void request() { rs.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 subject proxy Subject s = new Proxy(); // call request through proxy s.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 Suponer que tenemos la interfaz IVehicle: /** * Interface IVehicle. */ public interface IVehicle { public void start(); public void stop(); public void forward(); public void reverse(); public String getName(); }

Ejemplo sin utilizar Proxy Y una clase Car que implementa la IVehicle interface: /* 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.

Ejemplo sin utilizar Proxy /*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.

Ejemplo utilizando Proxy /* 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(); }}

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

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

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: //Objeto SomeClass 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ásico proxy.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…

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ño Aplicaciones: 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ño Conclusiones
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

Ingenieria del Software IV Patrones de diseño

Presentaciones similares

Presentación del tema: "Ingenieria del Software IV Patrones de diseño"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback

Iniciar la sesión

Autorizarse a través de una red social:

Ingenieria del Software IV Patrones de diseño

Presentaciones similares

Presentación del tema: "Ingenieria del Software IV Patrones de diseño"— Transcripción de la presentación:

Presentaciones similares

Sobre el proyecto

Feedback