Contenido

INTRODUCCION.............................................................................................. 3
Proporciona.................................................................................................... 3
Marco Teorico................................................................................................. 5
1.

framework de Spring............................................................................ 5

1.1.

Inyeccin de dependencia e inversin de control.................................5

1.2. Mdulos................................................................................................ 5
1.2.1. El contenedor....................................................................................... 6
1.2.2. El ncleo............................................................................................... 6
1.2.3. El contexto........................................................................................... 6
1.2.4. Los Lenguajes de expresin.................................................................6
1.2.5. Integracin y acceso de Datos.............................................................7
1.2.6. Web...................................................................................................... 7
1.2.7. AOP...................................................................................................... 7
1.2.8. Test....................................................................................................... 8

INTRODUCCION
Spring es un framework de aplicaciones Java/J2EE desarrollado usando licencia de
OpenSource.
Se basa en una configuracin a base de JavaBeans bastante simple. Es potente en cuanto
a la gestin del ciclo de vida de los componentes y fcilmente ampliable. Es interesante
el uso de programacin orientada a aspectos (IoC). Tiene plantillas que permiten un ms
fcil uso de Hibernate, iBatis, JDBC..., se integra "de fbrica" con Quartz, Velocity,
Freemarker, Struts, Webwork2 y tienen un plugin para eclipse.
Ofrece un ligero contenedor de bean para los objetos de la capa de negocio, DAOs y
repositorio de Datasources JDBCy sesiones Hibernate. Mediante un Xml definimos el
contexto de la aplicacin siendo una potente herramienta para manejar objetos
Songleton o factorias que necesitan su propia configuracin.
El objetivo de Spring es no ser intrusito, aquellas aplicaciones configuradas para usar
beans mediante Spring no necesitan depender de interfaces o clases de Spring, pero
obtienen su configuracin a travs de las propiedades de sus beans.
Este concepto puede ser aplicado a cualquier entorno, desde una aplicacin J2EE a un
applet
Como ejemplo podemos pensar en conexiones a base de datos o de persistencia de
datos, como Hibernate, la gestin de transacciones genrica de Spring para DAOs es
muy interesante.
La meta a conseguir es separar los accesos a datos y los aspectos relacionados con las
transacciones, para permitir objetos de la capa de negocio reutilizables que no dependan
de ninguna estrategia de acceso a datos o transacciones.
Spring ofrece una manera simple de implementar DAOs basados en Hibernate sin
necesidad de manejar instancias de sesion de Hibernate o participar en transacciones.
No necesita bloques try-catch, innecesario para el chequeo de transacciones.
Podramos conseguir un mtodo de acceso simple a Hibernate con una sola lnea.

Proporciona
Una potente gestin de configuracin basada en JavaBeans, aplicando los
principios de Inversin de Control (IoC). Esto hace que la configuracin de
aplicaciones sea rpida y sencilla. Ya no es necesario tener singletons ni ficheros

de configuracin, una aproximacin consistente y elegante. Estas definiciones de

beans se realizan en lo que se llama el contexto de aplicacin.
Una capa genrica de abstraccin para la gestin de transacciones, permitiendo
gestores de transaccin aadibles (pluggables), y haciendo sencilla la
demarcacin de transacciones sin tratarlas a bajo nivel. Se incluyen estrategias
genricas para JTA y un nico JDBC DataSource. En contraste con el JTA
simple o EJB CMT, el soporte de transacciones de Springno est atado a
entornos J2EE.
Una capa de abstraccin JDBC que ofrece una significativa jerarqua de
excepciones (evitando la necesidad de obtener de SQLException los cdigos que
cada gestor de base de datos asigna a los errores), simplifica el manejo de
errores, y reduce considerablemente la cantidad de cdigo necesario.
Integracin con Hibernate, JDO e iBatis SQL Maps en trminos de soporte a
implementaciones DAO y estrategias con transacciones. Especial soporte a
Hibernate aadiendo convenientes caractersticas de IoC, y solucionando
muchos de los comunes problemas de integracin de Hibernate .Todo ello
cumpliendo con las transacciones genricas de Springy la jerarqua de
excepciones DAO.
Funcionalidad AOP, totalmente integrada en la gestin de configuracin de
Spring. Se puede aplicar AOP a cualquier objeto gestionado por Spring,
aadiendo aspectos como gestin de transacciones declarativa. Con Spring se
puede tener gestin de transacciones declarativa sin EJB, incluso sin JTA, si se
utiliza una nica base de datos en un contenedor Web sin soporte JTA.
Un framework MVC (Model-View-Controller), construido sobre el ncleo de
Spring. Este framework es altamente configurable va interfaces y permite el uso
de mltiples tecnologas para la capa vista como pueden ser JSP, Velocity, Tiles,
iText o POI. De cualquier manera una capa modelo realizada con Spring puede
ser fcilmente utilizada con una capa web basada en cualquier otro framework
MVC, como Struts, WebWork o Tapestry

Toda esta funcionalidad puede usarse en cualquier servidor J2EE, y la mayora de

ella ni siquiera requiere su uso. El objetivo central de Spring es permitir que objetos
de negocio y de acceso a datos sean reutilizables, no atados a servicios J2EE
especficos. Estos objetos pueden ser reutilizados tanto en entornos J2EE (Web o
EJB), aplicaciones standalone, entornos de pruebas, etc. Sin ningn problema.
La arquitectura en capas de Spring ofrece mucha de flexibilidad. Toda la funcionalidad
est construida sobre los niveles inferiores. Por ejemplo se puede utilizar la gestin de
configuracin basada en JavaBeans sin utilizar el framework MVC o el soporte AOP.

Marco Terico
1. Framework de Spring
Es un framework de cdigo abierto de desarrollo de aplicaciones para la plataforma
Java. La primera versin fue escrita por Rod Jonhson. Es una plataforma Java que
otorga una infraestructura de apoyo global al desarrollo de aplicaciones Java. De este
modo, Spring se encarga de la infraestructura para que nosotros nos centremos en la
aplicacin.

Unos ejemplos pueden ser:

Inyeccin de dependencia e inversin de control.
Integracin del acceso a datos.
Facilitar el desarrollo de aplicaciones web separando claramente las partes del
modelo, vista y controlador.

Poder ejecutar mtodos transaccionales en una base de datos sin necesidad de lidiar con
API de transaccin, mtodos remotos sin tener que lidiar con API de procedimientos
remotos, mtodos de gestin sin JMX, control de mensajes sin JMS...

1.1.

Inyeccin de dependencia e inversin de control

El trmino Aplicacin Java es un trmino tan amplio que podra ir desde un applet
hasta aplicaciones empresariales en servidores de nivel n.
Java proporciona una gran cantidad de herramientas para desarrollar aplicaciones, pero
carece de medios para organizar los elementos. Normalmente es el arquitecto Java el
que se encarga de esta tarea pudiendo utilizar patrones.
La inversin de control de Spring lo que hace es preocuparse de proporcionar una
manera formal de creacin de componentes dispares de una manera homognea y de
una manera funcional. Codifica componentes que se integran en las aplicaciones.
Diversas instituciones y empresas eligen Spring como una manera de disear
aplicaciones robustas fciles de mantener.

1.2. Mdulos
El framework de Spring consiste en elementos organizados en veinte mdulos. Estos
mdulos se agrupan en el Contenedor (core container), Acceso a datos e integracin,
modelo vista controlador (mdulo web MVC), aspectos (AOP), instrumentacin y test.
El siguiente diagrama muestra cmo se divide:

1.2.1. El contenedor
El contenedor consiste en un ncleo, objetos bean, un contexto y un lenguaje de
expresiones.

1.2.2. El ncleo
Y los beans son la parte fundamental de Spring, incluyendo la inversin de control y la
inyeccin de dependencia. Este contenedor es una versin ms compleja del patrn
Factory. Elimina la necesidad de programar singletons y permite desacoplar la
configuracin y especificacin de dependencias de la lgica de programacin.

1.2.3. El contexto
Se construye sobre la slida base del ncleo. As permite determinadas configuraciones.
As la internacionalizacin, propagacin de eventos, lectura de recursos o la creacin de
contextos (como el web) formarn parte de este mdulo.

1.2.4. Los Lenguajes de expresin

Permiten una potente herramienta de consulta y manipulacin de un objeto en tiempo de
ejecucin. Es una extensin del Unified EL, especificado en la especificacin JSP 2.1.
El lenguaje permite asignar y obtener valores de las propiedades, asignar propiedades,
invocar mtodos, acceder al contexto de matrices, listas, ndices, operadores aritmticos
y lgicos, variables, y obtencin de objetos por nombre del contendor de Spring.

1.2.5. Integracin y acceso de Datos

La capa de Integracin y acceso a datos consiste en la integracin de los mdulos
JDBC, ORM, OXM, JMS y de transaccin.
El mdulo JDB Cotorga una capa de abstraccin que elimina la necesidad de crear
cdigo tedioso y trasforma las excepciones generadas por el proveedor de base de datos.
El mdulo ORM otorga una integracin con los APIS ms populares de ORM como
puedan ser JPA, JDO, Hibernate o iBatis.
El mdulo OXM otorga una capa de abstraccin para el mapeo Objeto/XML en
distintas implementaciones como JAXB, Castor, XMLBeans, JiBX o XStream.
El mdulo JMS contiene caractersticas para la produccin y consumo de mensajes.
El mdulo de Transaccin permite transacciones programticas y declarativas para las
clases que implementan interfaces especiales y para todos los POJO.

1.2.6. Web
La capa web consiste en los mdulos Web, Web-Servlet, Web-Struts y Web-Portlet.
El mdulo Web permite integracin bsica de caractersticas como la subida multiparte
de un fichero, la inicializacin de la inversin de control del contenedor usando listeners
Servlet y un contexto de lgica web.
El mdulo Servlet contiene la implementacin modelo visto controlador. El framework
Spring MVC permite una separacin entre el modelo, el cdigo y los formularios web y
se integra con todas las otras caractersticas de Spring.
El mdulo Web-Struts permite la integracin de clases integrando Struts, actualmente
este soporte esta obsoleto en Spring 3.0.
El mdulo Web-Portlet permite las caractersticas web en sistemas empotrados.

1.2.7. AOP
El mdulo AOP de Spring permite una implementacin de programacin orientada a
aspectos permitiendo definir mtodos e interceptores, puntos de corte, etc. Para
desacoplar el cdigo.
Permite la integracin con AspectJ
l mdulo de instrumentacin otorga instrumentacin de clases as como un cargador de
clases a ser usadas en determinadas aplicaciones de servidor.

1.2.8. Test
El mdulo de test permite probar las aplicaciones de Spring y los componentes con
JUnit o TestNG. Permite la carga consistente de contextos de Spring. As se permiten
objetos mock que prueban tu cdigo de manera aislada.