Septiembre

2010

Presentacin de Spring Framework Resumen Ejecutivo Este documento tiene por finalidad presentar las caractersticas y capacidades de Spring Framework para ser utilizado como Framework base de un sistema. La primera seccin, describe los componentes y tecnologas que forman parte de Spring Framework, se explican los conceptos bsicos de Inyeccin de Dependencias, Programacin Orientada a Aspectos y Abstraccin de Servicios Empresariales. Finalmente, se describen y ejemplifican aquellas caractersticas que hacen de este producto uno de los mas utilizados del mercado.

P r e m i z e - J o r g e L . M i d d l e t o n

Table of Contents
Que es Spring? ....................................................................................................... 3 Principios de Spring ............................................................................................... 3 Capacidades de Spring ........................................................................................... 3 Arquitectura de Spring........................................................................................... 5 Escenario de aplicacin .......................................................................................... 6 Ejemplos de utilizacin .......................................................................................... 7 Transacciones Declarativas para POJOs .............................................................. 7 Capa de Integracin/Acceso a Datos .................................................................. 7 Capa de Presentacin con JSF............................................................................. 9 Arquitectura propuesta........................................................................................ 10 Enlaces y Lecturas ................................................................................................ 12

Que es Spring?
Spring es un Framework open source creado por Rod Johnson y Jrgen Hller. Fue creado para atacar la complejidad de los desarrollos empresariales (J2EE). Las caractersticas puras de Spring pueden ser utilizadas por cualquier aplicacin Java, pero tiene extensiones para construir tambin aplicaciones Web sobre la plataforma JEE. Aunque Spring no impone ningn modelo de programacin especifico, se ha convertido en el producto de facto para el desarrollo de aplicaciones Java Enterprise.

Principios de Spring

Spring esta basado en los siguientes principios: Simple, aunque poderoso: Si bien el enfoque que ofrece el Framework debe ser fcil de usar no debe sacrificar la potencia. Por ejemplo, la configuracin del manejo de transacciones en Spring es muy simple y a la vez robusto. Permite integrarse transparentemente a manejadores de transacciones distribuidas (JTA) como tambin a transacciones locales. A su vez, en una misma transaccin pueden enlistarse operaciones JDBC como Hibernate si as se necesitase. Flexibilidad: En lugar de utilizar un enfoque monoltico Spring incluye varios mdulos que son independientes unos de otros. Por esta razn, es posible utilizar Spring en reas donde se agrega mayor valor y se puede adaptar paso a paso en lugar de todo de una. Adems Spring ofrece una gran cantidad de hooks para extender un comportamiento especfico. Elecciones: Este principio est muy relacionado con la flexibilidad. Spring no obliga al desarrollador a utilizar un enfoque o tecnologa especfica. Por ejemplo, Spring es compatible con una gran variedad Framework de persistencia (JDBC, JPA, JDBC, Hibernate, JDO, Apache OJB). Adems, en reas como la Web, Spring se integra transparentemente con Frameworks como JSF, Struts, Tapestry, Webwork. Spring posee varias maneras de configuracin de aplicaciones que van desde XML hasta aplicaciones basadas en anotaciones Java.

Capacidades de Spring

Los siguientes puntos describen las capacidades principales de Spring: Framework liviano: Spring es liviano en trminos de tamao en carga. El total de libreras de Spring puede ser distribuido en un archivo JAR nico que pesa poco ms de 2,5 MB. Y la sobrecarga de procesamiento requerido por Spring es insignificante. Es ms, Spring es no intrusiva: los objetos en una aplicacin basada en Spring no requieren dependencias de clases especificas de Spring. Inyeccin de Dependencias: (DI) significa que los objetos que colaboran son inyectados por el container. As, los objetos no depende de ninguna de la tecnologa para encontrar otros objetos. En su lugar, es responsabilidad de Spring proporcionar los colaboradores. De esta manera fcilmente se puede tambin cambiar las dependencias para las pruebas unitarias. La inyeccin de dependencias promueve as el concepto de acoplamiento dbil (loose coupling) de los componentes de la aplicacin. 3

 Programacin Orientada a Aspectos: (AOP) es una tcnica probada durante 10 aos para aadir al cdigo aspectos como seguridad, transacciones, auditoria, logging, etc.. Sin AOP todos los mtodos en el cdigo tiene que cuidar de estos aspectos y por lo tanto depende de la tecnologa empleada en seguridad o en transacciones. Utilizando AOP, todo el cdigo que se ocupa de ese aspecto puede ser colocado en un lugar especfico. El cdigo de negocio no tiene que preocuparse de ello. Por lo tanto, las preocupaciones de negocio son separadas de cuestiones tcnicas tales como transacciones o seguridad cumpliendo con el objetivo llamado "Separacin de Responsabilidades - Separation of Concerns" por el pionero de las Ciencias de la Computacin Edsger W. Dijkstra en 1974. Abstraccin de Servicios Empresariales: permite el uso de APIs comunes, como JDBC o JMS de una manera simple y menos propensa a errores. Por lo general, incluso las tareas ms simples como hacer una consulta de base de datos con JDBC o enviando un mensaje con JMS tienen ms de 10 lneas de cdigo. Adems, es muy difcil obtener el control de errores - algunos tutoriales ni siquiera mencionan este tema. La Abstraccin del Servicio elimina esta complejidad innecesaria y permite hacer una consulta de base de datos o enviar un mensaje en una sola lnea de cdigo. Tambin se ocupa del manejo de errores y de unificar las API cuando sea necesario, es decir, todas las excepciones de persistencia de todos los Frameworks son traducidas en una jerarqua comn para que sean manejadas de la misma forma. Administracin de Transacciones. El soporte que ofrece Spring para el manejo de transacciones es muy potente y mejora las capacidades ofrecidas en EJB 3.0. Dentro de las caractersticas principales podemos mencionar: o Modelo de programacin consistente a travs de la API de transacciones, tales como Java Transaction API (JTA), JDBC, Hibernate, Java Persistence API (JPA) y Java Data Objects (JDO). o Gestin declarativa de transacciones. o Simplificacin de la API para la gestin de transacciones programticas. o Excelente integracin con el soporte de acceso a datos. o Spring permite definir declarativamente las reglas de rollback. Mediante esta funcionalidad se definen reglas que especifican si para cierta excepcin se debe hacer rollback o no. Por el momento, esta funcionalidad no esta presente en la especificacin EJB 3.0.

Arquitectura de Spring
La arquitectura de Spring est diseada para soportar objetos simples. A veces en el mundo Java son tambin llamados POJOs (Plain Old Java Objects).

La caracterstica bsica de un objeto es que no depende necesariamente en una tecnologa. La independencia de la tecnologa es una prctica bien conocida en el desarrollo de software. Esto tiene varias ventajas: La inversin en el cdigo de negocio se mantiene incluso si se utiliza una nueva tecnologa. Por lo tanto, si usted decide migrar la aplicacin a un nuevo entorno, como una nueva versin de un servidor de aplicaciones o una alternativa ligera como un servidor Web, la lgica de negocio en s no es cambiada. El desarrollador puede concentrarse en crear valor de negocio en lugar de tratar con la tecnologa. Esto lo hace ms productivo en trminos de valor de negocio generado a travs del tiempo. Los objetos pueden ser fcilmente probados de manera aislada. En lugar de utilizar un entorno similar a produccin, todos los objetos colaborando pueden ser intercambiados por objetos de prueba (mock objects). Estos proporcionan un comportamiento similar al entorno de produccin pero son mucho ms simples. Esto permite pruebas ms rpidas y simulacin de situaciones excepcionales de otro modo difciles de prever en un entorno similar a produccin. El principal beneficio es que los errores pueden ser rastreados hasta el objeto real que se esta probando. Las pruebas de forma aislada por lo general no son suficientes. Al utilizar el enfoque de objetos simples (POJOs), tambin es posible usar un ambiente ligero para probar las colaboraciones entre los objetos. As, en lugar de desplegar la aplicacin a una infraestructura de servidor, que es una tarea que consume tiempo, esta prueba puede iniciarse desde el Entorno de desarrollo (IDE), que acelera en gran medida el desarrollo y permite una depuracin ms sencilla de las aplicaciones. 5

Escenario de aplicacin
La siguiente imagen muestra (cuadros amarillos) un escenario tpico donde Spring se convierte en la eleccin mas lgica. El administrador de transacciones de Spring hace que la aplicacin Web sea totalmente transaccional, tal y como sera si se utiliza transacciones gestionadas por un contenedor EJB. Toda la lgica de negocios puede llevarse a cabo con simples POJO y gestionado por el contenedor de IOC de Spring. Los servicios adicionales incluyen soporte para el envo de correo electrnico y validaciones independientes de la capa Web, que le permite seleccionar el lugar de ejecucin de las reglas de validacin. El soporte ORM de Spring se integra fcilmente con JPA, Hibernate, JDO o iBATIS, por ejemplo, al utilizar Hibernate, puede seguir utilizando los archivos de mapeos existentes y la configuracin estndar de SessionFactory de Hibernate. Los Framework de UI pueden ser integrados con la capa de negocios basada en Spring transparentemente, permitiendo as utilizar toda la potencia del manejo de transacciones de Spring. Slo se tendr que enlazar la lgica de negocio utilizando las capacidades de integracin Web que posee Spring (WebApplicationContext).

Ejemplos de utilizacin
Este apartado tiene por finalidad mostrar ejemplos de como Spring nos ayuda a concentrarnos en la lgica de negocios y no pensar en los aspectos tcnicos de una aplicacin. Segn la imagen anterior tenemos las siguientes categoras:

Transacciones Declarativas para POJOs

La administracin de transacciones de Spring se basa en AOP para procesar la configuracin declarativa de las mismas. El siguiente ejemplo muestra como se aplica un aspecto de transacciones a todos los servicios bajo el paquete x.y.service.
<aop:config> <aop:pointcut id="fooServiceMethods" expression="execution(* x.y.service.*.*(..))"/> <aop:advisor advice-ref="txAdvice" pointcut-ref="fooServiceMethods"/> </aop:config> <tx:advice id="txAdvice" transaction-manager="txManager"> <tx:attributes> <tx:method name="get*" read-only="true"/> <tx:method name="*" propagation="REQUIRED" no-rollback-for="InstrumentNotFoundException"/> </tx:attributes> </tx:advice> <bean id="txManager" class="org.springframework.orm.hibernate3.HibernateTransactionManager"> <property name="sessionFactory" ref="sessionFactory" /> </bean>

Capa de Integracin/Acceso a Datos

El soporte de acceso a datos permite principalmente dos cosas, primero proveer una capa de abstraccin que simplifique considerablemente la codificacin de acceso a datos y la manipulacin de errores generados en la capa de datos. En segundo lugar, ofrece de buenas practicas y un conjunto de clases que se integran con el sistema de transacciones. Para el caso concreto de Hibernate, tenemos las siguientes ventajas: HibernateTemplate asegura de que las instancias de la Session sean correctamente abiertas y cerradas y automticamente hacer que nuestras invocaciones participen en la transaccin. Las instancias del template son thread-safe y reutilizables. Para las operaciones bsicas del CRUD, HibernateTemplate ofrece otros mtodos que puede ser sustituida por una lnea. Spring provee otra clase conveniente la HibernateDaoSupport que nos da mtodos get y set del SessionFactory y un mtodo getHibernateTemplate() para usarlo en subclases. Esto nos permite implementar DAO's simples. Nos ayuda a convertir las HibernateExceptions en DataAccessException siguiendo la jerarqua de excepciones. HibernateTemplate puede ser considerada como una Alternativa para trabajar con la API Session de Hibernate3.

La siguiente tabla muestra quien hace que accin cuando se trabaja con Spring JDBC. Podemos ver que se simplifica demasiado la codificacin de acceso a datos.
Accion Define connection parameters. Open the connection. Specify the SQL statement. Declare parameters and provide parameter values Prepare and execute the statement. Set up the loop to iterate through the results (if any). Do the work for each iteration. Process any exception. Handle transactions. Close the connection, statement and resultset. Spring X X X X X X Usted X X X X

A continuacin se muestran algunos ejemplos:

int rowCount= this.jdbcTemplate.queryForInt("select count(*) from t_actor");

Actor actor = this.jdbcTemplate.queryForObject( "select first_name, last_name from t_actor where id = ?", new Object[]{1212L}, new RowMapper<Actor>() { public Actor mapRow(ResultSet rs, int rowNum) throws SQLException { Actor actor = new Actor(); actor.setFirstName(rs.getString("first_name")); actor.setLastName(rs.getString("last_name")); return actor; } });

this.jdbcTemplate.update( "call SUPPORT.REFRESH_ACTORS_SUMMARY(?)", Long.valueOf(unionId));

Utilizando HibernateDaoSupport
public class ProductDaoImpl extends HibernateDaoSupport implements ProductDao { public Collection loadProductsByCategory(String category) throws DataAccessException { return this.getHibernateTemplate().find( "from test.Product product where product.category=?", category); } }

 Ahora utilizando JPA

public class ProductDaoImpl extends JpaDaoSupport implements ProductDao { public Collection loadProductsByCategory(String category) throws DataAccessException { Map<String, String> params = new HashMap<String, String>(); params.put("category", category); return getJpaTemplate().findByNamedParams( "from Product as p where p.category = :category", params); } }

Capa de Presentacin con JSF

Para integrar Spring con la capa de presentacin simplemente tenemos que realizar la siguiente configuracin. Primero es necesario configurar el ELResolver de manera que Spring trabaje como un Service Locator para inyectar beans configurados en Spring en un ManagedBean.
<faces-config> <application> <el-resolver>org.springframework.web.jsf.el.SpringBeanFacesELResolver</elresolver> ... </application> </faces-config>

Lo anterior define que se va a utilizar Spring para resolver las expresiones en JSF, esto nos permite entonces realizar la siguiente configuracin:
<managed-bean> <managed-bean-name>userList</managed-bean-name> <managed-bean-class>com.whatever.jsf.UserList</managed-bean-class> <managed-bean-scope>request</managed-bean-scope> <managed-property> <property-name>userManager</property-name> <value>#{userManager}</value> </managed-property> </managed-bean>

Aqu el valor #{userManager} se resuelve mediante SpringBeanFacesELResolver el cual se fija si existe un bean con ese identificador en el registro de Spring y si lo encuentra lo asigna para que pueda ser utilizado en el ManagedBean. Finalmente solo queda configurar el archivo web.xml para agregar el siguiente listener el cual permite inicializar el registro de Spring.
<listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listenerclass> </listener>

Arquitectura propuesta
Teniendo en cuenta las capacidades y beneficios de Spring, se tiene pensado utilizarlo en el sistema de Negocios Internacionales. La arquitectura pensada podemos verla en los siguientes diagramas:

10

El primer diagrama muestra los componentes principales de alto nivel que forman parte de la aplicacin. En el segundo diagrama podemos ver en detalle cuales serian los componentes que forman parte de la propuesta, a saber: Spring-JSF Integration Layer: este componente utiliza Spring para integrar la capa de presentacin con los servicios de la capa de lgica de negocio. Registro de Servicios Spring: se encarga de mantener un registro de todos los servicios de la aplicacin. Inyeccin de Dependencias: permite configurar e inyectar los colaboradores de los servicios con el fin de construir la aplicacin. Transacciones Declarativas: componente de Spring encargado de procesar y administrar el manejo de transacciones en la aplicacin. Asegura la correcta sincronizacin entre servicios. Servicios: este componente muestra realmente los servicios que se construirn en la aplicacin. Estos servicios son simples POJOs totalmente independientes de Spring. Integracin Hibernate: capa de abstraccin de Spring que permite el acceso a los datos de una manera limpia y robusta. Se integra con el componente de Transacciones para asegurar la consistencia de la informacin. Tambin generaliza y traduce los errores generados en la capa de acceso a datos. En resumen se pretende que toda la capa de servicios este soportada por Spring y que mediante las tcnicas de DI y AOP el desarrollo se concentre en la lgica de negocios pura y no en aspectos tcnicos de la aplicacin. Otro punto asociado con esto es que utilizando Spring tenemos la posibilidad de redisear o cambiar la aplicacin sin afectar todo el cdigo, por ejemplo es posible cambiar la implementacin de un servicio transparentemente solo cambiando la configuracin Spring y sin tener que cambiar cdigo Java. Esto ofrece un enorme beneficio ya que permite que la aplicacin evolucione constantemente de acuerdo a la evolucin del negocio. Por otro lado, la integracin con JSF nos da la flexibilidad de poder cambiar la implementacin de los servicios de negocio sin afectar la presentacin. En cuanto a la integracin con la capa de datos, se quiere utilizar Spring ya que el mismo ofrece un conjunto de clases que aceleran el desarrollo de la capa de acceso a datos. Al utilizar estas clases inmediatamente tenemos una disminucin en la cantidad de lneas de codificacin. Al utilizar Hibernate en conjunto con el manejador de transacciones, eliminamos considerablemente los errores asociados a la codificacin de las mismas (begin, commit, rollback). Otro punto donde se desea utilizar Spring es en las pruebas unitarias. Para esto, Spring cuenta con un Framework de Pruebas muy potente que permite aplicar buenas practicas en el desarrollo de casos de pruebas. Finalmente pero no menos importante Spring permite que los arquitectos puedan tener mayor control sobre el desarrollo de la aplicacin. Por ejemplo, al contar con

11

transacciones que se configuran como aspectos, se elimina la codificacin de las mismas y por lo tanto el arquitecto no tiene que estar revisando mtodo por mtodo para asegurar la calidad del producto.

Enlaces y Lecturas
http://en.wikipedia.org/wiki/Spring_Framework Spring - A Managers Overview http://www.springsource.com/products/white-paper-spring- managers-overview http://www.springsource.org http://static.springsource.org/spring/docs/3.0.x/spring-framework- reference/html/overview.html http://static.springsource.org/spring/docs/3.0.x/spring-framework- reference/html/transaction.html http://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/orm.html

12