Spring Framework
Campus Party México 2010
Javier A. Ramírez Hernández
Software Developer
9 años desarrollando software
5 años desarrollando java
conferencista de:
javamexico
spring i/o
campus party
miembro del core de javamexico
javamexico.org/blogs/benek
twitter.com/_benek
javaMexico.org
comunidad de desarrolladores java:

difundir la tecnología java
incentivar el aprendizaje y desarrollo en la plataforma java
crear un punto en común para los desarrolladores del país
impulsar la generación de proyectos de software libre dentro y fuera de la comunidad
@javamexico
¿Spring Framework?
Framework de código abierto para la plataforma Java.
Liberado bajo la Apache License 2.0.
Solución ligera y modular a problemas comúnes por medio de "best practices".
Creado por Rod Johnson en el año 2000. SpringSource. VMWare.
Permite utilizar la mayoría de sus módulos a elección, sin necesidad de "cargar" con todo el paquete.
¿Framework?
Implementaciones de conceptos, técnicas, patrones de diseño o buenas prácticas en conjunto, para resolver una o varias problemáticas.

Spring implementa algunas de estas técnicas para facilitarnos el desarrollo y evitarnos problemáticas ya conocidas.

Algunos ejemplos son: Inversion of Control, Dependency Injection, Factory Pattern, Aspectos, etc...
¿De qué se compone Spring?
Al rededor de 20 módulos con diferentes propósitos.
Spring se basa principalmente en las técnicas de Inversión de Control (IoC) e Inyección de Dependencias (DI).
Características clave
Desarrollo en POJOs (Plain Old Java Objects).
Configuración basada en XML o anotaciones.
Integración para acceso a datos (JDBC/Hibernate).
Integración AOP.
Seguridad con Spring Security (antes Acegi), que provee mecanismos de autenticación y autorización.
Soporte para testing e integración con jUnit y TestNG.
Core Container
Core.
Beans.
Context.
Expression Language.
Core y Beans.
proveen las partes fundamentales del framework.
Inversión de Control e Inyección de Dependencias.
alta cohesión y bajo acoplamiento
BeanFactory, implementación de Factory pattern.
realiza singletons por nosotros y desacopla la configuración de las dependencias de la lógica de la aplicación.
Factory Pattern
Patrón de diseño "creacional" para facilitar, ordenar y/o restringir la creación de objetos.
En lugar de:
                Objeto o = new Objeto();
Haríamos (por ejemplo):
                Objeto o = FabricaDeObjetos.getInstance("x");
Context
Se basa en las características del módulo Beans y agrega soporte para:
internacionalización
resource-loading
propagación de eventos (ApplicationEvent & ApplicationListener
Soporte para características empresariales como EJB, JMX, etc...
la interfaz ApplicationContext es nuestro punto de referencia del módulo "context".
Spring Expression Language (SpEL)
A partir de Spring 3.0
SpEL extiende las posibilidades al inyectar valores a propiedades.
Ejemplo:
<bean id="padre" class="org.javamexico.cpmexico.Persona">
    <property name="nombre" value="Javier"/>
    <property name="apellido" value="Ramirez"/>
</bean>
<bean id="hijo" class="org.javamexico.cpmexico.Persona">
    <property name="nombre" value="Javi"/>
    <property name="apellido" value="#{padre.apellido}"/>
</bean>
¿Sencillo?
Más posibilidades de SpEL:
Podemos acceder a las Java System Properties: #{systemProperties['user.region']}
Acceder a elementos de un arreglo: #{arreglo[0]}
Acceder a elementos de un mapa: #{mapa['key']}
Llamar métodos con o sin argumentos: #{'cadena'.substring(2,3)}
Operaciones aritméticas: #{(2 + 2) * 5}
Crear objetos: #{new Object()}
Pasemos al código ;-)
Más features:
Módulo JDBC. Provee una capa que abstrae la relativa "complejidad" (tedio) de JDBC.
Módulo ORM. Provee capas de integración a los ORMs más populares (Hibernate, JPA, JDO, iBatis).
Módulo JMS. Provee características para producir y consumir mensajes.
Módulo Web. Provee una implementación del patrón de diseño MVC, integración con Struts y Portlets.
Módulo AOP. Implementación del paradigma de Programación Orientada a Aspectos (AOP).
JDBC
¿Quién hace qué?
definir los parámetros de la conexión ------------------------------------->
abrir la conexión ------------------------------------------>
especificar la sentencia SQL ------------------------------------------------->
declarar los parámetros y asignar su valor ------------------------------->
preparar y ejecutar la sentencia ------------------------>
realizar el loop para iterar los resultados ------------->
crear la lógica para cada iteración ----------------------------------------->
procesar las excepciones ------------------------------->
gestionar las transacciones ----------------------------->
cerrar la conexión, statement y resultset ------------->
Spring
Nosotros
X
X
X
X
X
X
X
X
X
X
AOP
Programación Orientada a Aspectos
Paradigma de intercepción de métodos.
Invocaciones típicas de funcionalidades system-wide:
Usando AOP
Dependencia típica entre objetos
Aspect-Oriented
¡Gracias!
Javier Alberto Ramírez Hernández
@_benek
www.javamexico.org