• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Msdn Webcast   InyeccióN De Dependencias Con Spring Framework
 

Msdn Webcast InyeccióN De Dependencias Con Spring Framework

on

  • 2,855 views

Presentación de un webcast para MSDN Latam de hace algunos años cuyo tema fue la intrucción al patron de IOC

Presentación de un webcast para MSDN Latam de hace algunos años cuyo tema fue la intrucción al patron de IOC

Statistics

Views

Total Views
2,855
Views on SlideShare
2,845
Embed Views
10

Actions

Likes
1
Downloads
0
Comments
0

2 Embeds 10

http://www.slideshare.net 5
http://www.linkedin.com 5

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Msdn Webcast   InyeccióN De Dependencias Con Spring Framework Msdn Webcast InyeccióN De Dependencias Con Spring Framework Presentation Transcript

    • Inyección de dependencias con Spring Framework Gabriel Oliva Chimal IT Builder / Chief Sw. Architect [email_address]
    • Objetivos de la sesión
      • Analizar propuestas de diseño para la generación de aplicaciones altamente modulares a través de la mejora en el manejo de dependencias.
      • Comprender el patrón IoC ‘Inversion of Control’ (Inyección de dependencias) y sus ventajas.
      • Demostrar la implementación de este patrón a través de Spring Framework.
      • Analizar algunas de las características adicionales de spring Framework.
    • Agenda
      • Importancia del uso de patrones de diseño.
      • El problema de las dependencias entre clases.
      • Alternativas de solución:
        • Interfaces
        • Object Factories
        • Inversion of Control (Dependency Injection)
      • Introducción a Spring Framework
      • Características de Spring Framework
    • Patrones de diseño Por que son importantes ?
    • Antecedentes
      • Debido al crecimiento en el desarrollo de software y la complejidad de las aplicaciones que se construyen, surgen diferentes estrategias para resolver problemas específicos relacionados con el diseño de sistemas.
      • Muchas de estas estrategias se han formalizado en patrones de diseño que permiten resolver de una forma fácil los retos y problemas que se presentan en la implementación.
    • Patrón
      • Un patrón es una solución probada a un problema recurrente en un contexto especifico.
      • Cada vez mas diseñadores de software están usando patrones para compartir de forma mas eficiente soluciones de arquitectura y las decisiones que se toman con respecto al diseño.
    • Por que son importantes ?
      • Los patrones de diseño son poderosas herramientas que permiten crear software altamente flexible.
      • Proveen soluciones probadas a problemas comunes en el diseño de las soluciones
      • Disminuyen el tiempo invertido a la generación de código, mientras fomentan la reutilización y aumentan la calidad del software mediante la depuración constante.
    • Análisis del problema Dependencias entre clases
    • Forma común para la resolución de dependencias
      • public class ImplementationClass1
      • {
      • public ImplementationClass1( ) {}
      • public string Name
      • {
      • get
      • {
      • return "Implementation Class 1";
      • }
      • }
      • }
      • public class ImplementationClass2
      • {
      • public ImplementationClass2( ) {}
      • public string Name
      • {
      • get
      • {
      • return "Implementation Class 2";
      • }
      • }
      • }
    • Forma común para la resolución de dependencias - Continuación
      • static void Main(string[] args)
      • {
      • ImplementationClass1 ImpClass1 = new ImplementationClass1();
      • ImplementationClass2 ImpClass2 = new ImplementationClass2();
      • Console.WriteLine ( "My name is " + ImpClass1.Name);
      • Console.WriteLine ( "My name is " + ImpClass2.Name);
      • Console.WriteLine ( " Press any key to continue ...");
      • Console.Read ();
      • }
    • Demo 1
      • Resolución de dependencias (Forma tradicional)
    • Forma tradicional
      • Ventajas:
      • Fácil de entender
      • Desventajas:
      • Se debe conocer el tipo de dato desde su declaración (Early Binding).
      • No permite ampliamente el uso de polimorfismo (se soporta, pero no se fomenta).
      • Las clases son altamente dependientes.
      • Poco adaptable (es difícil soportar funcionalidad adicional sin modificar el código)
      • Difícil de probar de forma independiente (por modulo o por unidad)
    • Alternativas de solución Técnicas para el desacoplamiento
    • Principios Sagrados del diseño de Software
      • Mantén los elementos de la solución altamente desacoplados.
      • Pero altamente cohesivos (integrados).
        • El acoplamiento determina que tan fuertemente relacionados están los componentes del software.
        • La cohesión esta relacionada con que tan bien funciona de manera integral una unidad de software (método, clase o librería).
    • Uso de Interfaces
      • namespace SpringDIExample
      • {
      • public interface IDomainObjectInterface
      • {
      • string Name{ get; }
      • }
      • public class ImplementationClass1 : IDomainObjectInterface
      • {
      • public ImplementationClass1(){}
      • public string Name
      • {
      • get
      • {
      • return "Implementation Class 1";
      • }
      • }
      • }
      • public class ImplementationClass2 : IDomainObjectInterface
      • {
      • public ImplementationClass2(){}
      • public string Name
      • {
      • get
      • {
      • return "Implementation Class 2";
      • }
      • }
      • }
      • }
    • Uso de Interfaces - Continuación
      • static void Main()
      • {
      • IDomainObjectInterface ImpClass1, ImpClass2;
      • ImpClass1 = new ImplementationClass1();
      • ImpClass2 = new ImplementationClass2();
      • Display (ImpClass1);
      • Display (ImpClass2);
      • Console.WriteLine (" Press any key to continue");
      • Console.Read ();
      • }
      • static void Display (IDomainObjectInterface DomainObj)
      • {
      • Console.WriteLine( "My name is " + (IDomainObjectInterface)DomainObj).Name );
      • }
    • Demo 2
      • Resolución de dependencias (Primer Nivel de desacoplamiento con Interfaces)
    • Uso de Interfaces
      • Ventajas:
      • Fácil de entender.
      • Provee un grado primario de desacoplamiento a través del polimorfismo (Late Binding).
      • Desventajas:
      • Las clases dependen de todos los elementos a los cuales hacen referencia sus dependencias.
      • Las clases deben saber como armar las instancias primarias y sus árboles (graphos) de dependencias.
      • Aun es difícil cambiar el comportamiento sin cambiar el código.
      • Es difícil hacer pruebas unitarias pues se deben probar también todas las dependencias.
    • Patrón – Object Factory
      • Un patrón usado ampliamente para permitir un grado mayor de desacoplamiento es el de ‘Fabrica de objetos’.
      • El patrón de fabrica permite desligar a los objetos del conocimiento de los procesos de creación de otros objetos.
    • Object Factories [Abstract Factory way]
      • Abstract Factory pattern : Tiene la función de construir e instancias un conjunto de objetos relacionados sin necesidad de especificar sus objetos concretos. El uso de Fábricas abstractas en las aplicaciones permite definir clases abstractas para crear familias de objetos.
      • A través del encapsulamiento de la lógica de construcción y creación de instancias se mantiene un mejor control sobre las dependencias y estados permitidos de los objetos.
    • Object Factory – [Static Method Way]
      • Otro tipo de patrón ‘Fabrica de Objetos’ es el llamado ‘método de fabrica’ o Factory Method, el cual es un objeto de tipo singleton (Usualmente definido como estático) cuyo único propósito es regresar la instancia de una clase
      • En algunos casos, con la finalidad de facilitar el polimorfismo, se pasa una bandera a la fabrica de objetos indicando específicamente la implementación de interface o subclase que se pretende que sea devuelta por la fábrica.
    • Demo 3
      • Resolución de dependencias (Aplicando Object Factories)
    • Uso de Object Factories
      • Ventajas:
      • Los clientes de los objetos son altamente desacoplados de los procesos de creación y inicialización.
      • La complejidad de los objetos es encapsulada
      • Permiten un alto nivel de flexibilidad.
      • Permiten la aplicación de pruebas unitarias
      • Es posible hacer fabricas genéricas y dinámicas a través del uso de ‘reflection’
      • Desventajas:
      • Las fabricas de objetos usualmente están ligadas a su contexto
      • Las fabricas de objetos deben conocer la lógica de armado respecto a las dependencias de cada objeto que construyen.
      • Para aplicaciones grandes son complejas de diseñar.
    • Patrón – Inyección de dependencias
      • IoC (Inversión de Control)
      • También conocido como patrón Hollywood [“no nos llame, nosotros lo llamaremos !!!”]
      • El Patrón de ‘Inyección de dependencias’ hace uso de Containers.
      • Los ‘containers’ son similares a las ‘fabricas de objetos’, solo que mucho mas ricos en funcionalidad, no solo proveen procesos de creación de objetos, sino que además pueden tener procesos de administración de los mismos durante toda la aplicación (Adicionalmente a los que pueden proveer las ‘fabricas de objetos’ dinámicas).
    • Spring Fmk
      • Se puede construir un ‘container’ ligero, sin embargo existen algunas implementaciones disponibles que puede ser usadas.
      • Spring.NET , ofrece un ‘DI container’ construido al rededor del patrón de ‘object factories’.
      • Spring.NET también permite el uso de fabricas preconstruidas dentro del mismo código, además de proveer un conjunto de servicios que pueden ser utilizados bajo el control del mismo framework.
    • Demo 4
      • Resolución de dependencias (Inyección de dependencias)
    • Patrón – Inyección de dependencias (Continuación)
      • Los ‘containers’ orientados a la inversión de control proveen una forma simple y poderosa de creación y configuración de las propiedades de los objetos dentro de una aplicación.
      • Sin embargo su poder radica en la habilidad de configurar propiedades que son referencias a otros objetos en la aplicación (una excelente solución para el armado de árboles o Graphos de objetos)
    • Demo 5
      • Resolución de dependencias (Soporte a la generación de Graphos de dependencias)
    • Componentes de Spring Fmk Core AOP Services Data Access Web Desktop Windows Services 3 rd Party Integration
      • El objeto IApplicationContext es el punto de entrada normal que se usa en SpringFramework.net
      • Dentro de el se encuentran (entre otras cosas) :
        • IObjectFactory
        • IResourceLocator
      • Estos son los objetos con los que generalmente se debera interactuar.
    • Soporte para AOP
      • Aspect Oriented Programming
        • Logging
        • Transactions
        • Security
        • Cualquier otro código que sea repetible o común en las aplicaciones.
    • Conclusión
      • El uso del patrón de ‘Inyección de dependencias’ permite construir aplicaciones mucho mas flexibles y robustas.
      • El uso de alguna de las implementaciones existentes reduce de manera tangible el numero de hrs. aplicadas a labores de desarrollo.
      • Spring.NET es una de las mejores implementaciones en el mercado.
    • Recursos
      • http://en.wikipedia.org/wiki/Dependency_injection
      • http://sourceforge.net/projects/springnet/
      • http://www.springframework.net/
      • http://msdn.microsoft.com/msdnmag/issues/05/09/DesignPatterns/default.aspx
    • Preguntas ???
    • Gracias !!!
      • Gabriel Oliva Chimal
      • IT Builder / Chief Software Architect
      • gabrielolivach@netscape.net
      • [email_address]
      • http://gabrieloliva.blogspot.com/