Introducción a Spring Framework

Spring es un framework open source creado por Rod Johnson, el cual fue inicialmente descrito en su libro “Expert One-on-One: J2EE Design and Development”. El objetivo de Rod Johnson era implementar un framework que permitiese desarrollar aplicaciones empresariales de manera más fácil y rápida, utilizando POJOs (Plain Old Java Object) para lograr cosas que antes eran solamente posibles con EJBs.

Uno de los principales objetivos de Spring es no ser intrusito. Esto quiere decir, que aquellas aplicaciones configuradas para utilizar “Beans” mediante Spring no necesitan depender de interfaces o clases de Spring, obteniendo su configuración a través de las propiedades de sus "Beans".

Este concepto puede ser aplicado a cualquier entorno, desde una aplicación J2EE hasta un applet.

Spring está compuesto por un conjunto características, las cuales están agrupadas en seis módulos principales:

El paquete “Core” es la parte más fundamental del framework ya que provee a este, las características de Inversión de Control (IoC) y Inyección de dependencias (ID). El concepto básico dentro del “Core” es el “BeanFactory”, el cual provee una sofisticada implementación del “Patrón Factory”, que remueve la necesidad generalizada de “Singletons” y nos permite desacoplar la configuración y especificación de las dependencias de nuestra lógica de programación.

El paquete “Context” está construido sobre una solida base provista por el paquete “Core”, el cual proporciona un medio de acceso a los objetos contenidos en el framework de forma tal, que recuerda en cierta medida a la manera en cómo trabaja el registro JNDI. Este paquete hereda algunas características del paquete “Beans” y añade soporte para internacionalización (I18N), propagación de eventos, carga de recursos y la transparente creación de contextos, como por ejemplo, un “Servlet Container”.

El paquete “DAO” provee una capa de abstracción a JDBC, eliminando la tediosa codificación propia de JDBC y el parseo de los códigos de errores específicos de cada proveedor de base de datos. Así también, este paquete proporciona mecanismos de manejo de transacciones tanto programáticamente como declarativamente, cuyo manejo no está restringido a clases que implementen algún tipo de interfaz especial, sino que también está pensado para cualquiera de nuestros POJOs.

El paquete “ORM” provee una capa de integración con las APIs más populares de “Mapeo Objeto-Relacional”, tales como JPA, JDO, Hibernate y iBatis. Usando este paquete nosotros pidremos utilizara cualquiera de estos ORM en combinación con todas las otras características que Spring ofrece.

El paquete “AOP” de Spring, provee una implementación para la programación “Orientada a Aspectos” compatible con el “AOP Alliance” que nos permite definir, por ejemplo, interceptores a un método (method-interceptors) y puntos de corte (pointcuts) para desacoplar limpiamente algunas funcionalidades implementadas en el código que lógicamente deberían conversar por separado.

El paquete “Web” de Spring provee características de integración orientadas a la Web, tales como funcionalidades para la carga de archivos, la inicialización del contenedor IoC usando “Servlet Listeners” y un contexto de aplicación orientado a la web.

El paquete “MVC” de Spring, provee una implementación del patrón MVC (Moldeo-Vista-Controlador) para las aplicaciones web. Spring MVC provee una limpia separación entre el código del modelo de dominio y los formularios web, integrándose a todas las otras características que este framework entrega.

Ejemplo Basico

Para poder comenzar a desarrollar en Spring lo primero que necesitamos es descargarnos la versión 2.5.5 desde www.springframework.org.

En la sección de “download” encontraran tres tipo de archivos a descargar: Spring 2.5.5 (spring-framework-2.5.5.zip), Spring 2.5.5 incluyendo la documentación (spring-framework-2.5.5-with-docs.zip) y Spring 2.5.5 incluyendo todas las dependencias (spring-framework-2.5.5-with-dependencies.zip). Para este ejemplo y los futuros ejemplos, necesitaremos la última de estas tres opciones.

Una vez descargados los archivos, procedemos a crear el proyecto. Para este caso, tenemos varias opciones: podemos utilizar Netbeans 6.x el cual ya incluye soporte para Spring, Eclipse 3.x al cual se le debe instalar Spring IDE o IntelliJ el cual también incluye soporte para Spring.

En este caso utilizare IntelliJ para los ejemplos.

Primero creamos el proyecto seleccionado la opción “File --> New Project…”. Luego seleccionamos la opción “Create Project from scratch” y presionamos el botón “Next”.

A continuación, ingresamos el nombre del proyecto, que para nuestro caso será “SpringBasico” y presionamos el botón “Next”.

Luego, seleccionamos la opción “Create source Directory” y presionamos el botón “Next”.

Por último, seleccionamos que la tecnología deseada para utilizar en el proyecto es “Spring” y presionamos el botón “Finish”. Con lo que se nos construirá la estructura básica de nuestro proyecto.

El único problema, es que la última versión de IntelliJ IDEA solamente tiene soporte hasta la versión 2.0.7 de Spring, razón por la cual necesitaremos cambiar la librería “Spring.jar” por la versión que nosotros descargamos.

Para esto, nos posicionamos sobre el proyecto, presionamos el botón derecho del mouse y seleccionamos la opción “Module Settings”.

Luego, en las opciones de “Project Settings” seleccionamos “Libraries”. Es aquí donde cambiaremos el nombre de nuestro paquete de librerías y modificaremos el “Spring.jar”.

El primer paso será cambiar el nombre del paquete “Spring-2.0.7” por “Spring-2.5.5”. Luego, seleccionamos la ruta del archivo “Spring.jar” y presionamos el botón “Detach”. Por último, presionamos el botón “Attach Classes…”, seleccionamos el archivo “Spring.jar” que se encuentra en la carpeta “dist” de la versión que descargamos anteriormente y presionamos el botón “Ok”.

Para finalizar, presionamos el botón “Apply” para que confirme y actualice todos los cambios, y presionamos el botón “OK”.

El último cambio lo deberemos realizar sobre el archivo “spring-config.xml”. Como IntelliJ solamente tiene soporta para Spring 2.0.7, la definición XSD de este archivo es para la versión 2 de Spring. Por esta razón, deberemos cambiar esta por la versión 2.5.

<beans xmlns="http://www.springframework.org/schema/beans" xsi="http://www.w3.org/2001/XMLSchema-instance" p="http://www.springframework.org/schema/p" context="http://www.springframework.org/schema/context" schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd">

Para nuestro primer ejemplo, desarrollaremos una idea simple que nos permita ver algunos de los beneficios básicos de Spring.

Imaginemos que necesitamos construir un robot, al cual le ensamblaremos un par de piernas, un par de brazos y una cabeza. Una primera propuesta a nuestro problema sería la siguiente:

package cl.jug.spring.basico.paso1;<br /><br />public class BrazoImpl {<br /><br /> private String tipo;<br /><br /> public void setTipo(String tipo){<br /> this.tipo = tipo;<br /> }<br /><br /> public void mover(){<br /> System.out.println("Moviendo el brazo : " + tipo);<br /> }<br /> <br />}

package cl.jug.spring.basico.paso1;<br /><br />public class PiernaImpl {<br /><br /> private String tipo;<br /><br /> public void setTipo(String tipo){<br /> this.tipo = tipo;<br /> }<br /><br /> public void arrodillarse(){<br /> System.out.println("Arrodillando la pierna : " + tipo);<br /> }<br /><br /> public void saltar(){<br /> System.out.println("Saltando con la pierna : " + tipo);<br /> }<br /><br /> public void correr(){<br /> System.out.println("Corriendo con la pierna : " + tipo);<br /> }<br /> <br />}

package cl.jug.spring.basico.paso1;<br /><br />public class CabezaImpl {<br /><br /> public void mover(){<br /> System.out.println("Moviendo la cabeza");<br /> }<br /><br /> public void pensar(){<br /> System.out.println("Pensando.....");<br /> }<br /><br />}

package cl.jug.spring.basico.paso1;<br /><br />public class RobotImpl {<br /><br /> private CabezaImpl cabezaImpl;<br /> private BrazoImpl brazoDImpl;<br /> private BrazoImpl brazoIImpl;<br /> private PiernaImpl piernaDImpl;<br /> private PiernaImpl piernaIImpl;<br /><br /> public RobotImpl(){<br /> cabezaImpl = new CabezaImpl();<br /> brazoDImpl = new BrazoImpl();<br /> brazoDImpl.setTipo("derecho");<br /> brazoIImpl = new BrazoImpl();<br /> brazoIImpl.setTipo("izquierdo");<br /> piernaDImpl = new PiernaImpl();<br /> piernaDImpl.setTipo("derecha");<br /> piernaIImpl = new PiernaImpl();<br /> piernaIImpl.setTipo("izquierda");<br /> }<br /><br /> public void moverRobot(){<br /> cabezaImpl.mover();<br /> brazoDImpl.mover();<br /> brazoIImpl.mover();<br /> piernaDImpl.correr();<br /> piernaIImpl.correr();<br /> }<br /><br />}

package cl.jug.spring.basico.paso1;<br /><br />public class Test {<br /><br /> public static void main(String args[]){<br /> RobotImpl robotImpl = new RobotImpl();<br /> robotImpl.moverRobot();<br /> }<br /><br />}

El problema con esta implementación es que el código esta “Altamente Acoplado”. Que sucedería si decidimos cambiar la implementación de un brazo? No solamente tendríamos que modificar la clase “BrazoImpl”, sino también la clase “RobotImpl”. Es aquí donde la inversión de control “IoC” y la inyección de dependencias “ID” nos ayudan (más información de IoC y ID la pueden encontrar aquí).

El primer cambio que tendremos que realizar al código, es que cada pieza del robot deberá implementar una interfaz, con lo cual estaremos definiendo un contrato para cada una de estas piezas, y en el caso de que necesitemos diseñar un nuevo brazo o una nueva pierna, simplemente deberemos implementar la interfaz asociada al tipo de pieza.

package cl.jug.spring.basico.paso2;<br /><br />public interface Brazo {<br /><br /> void mover();<br /> <br />}

package cl.jug.spring.basico.paso2;<br /><br />public class BrazoImpl implements Brazo{<br /><br /> private String tipo;<br /><br /> public void setTipo(String tipo){<br /> this.tipo = tipo;<br /> }<br /><br /> public void mover(){<br /> System.out.println("Moviendo el brazo : " + tipo);<br /> }<br /><br />}

package cl.jug.spring.basico.paso2;<br /><br />public interface Pierna {<br /><br /> void arrodillarse();<br /> void saltar();<br /> void correr();<br /><br />}

package cl.jug.spring.basico.paso2;<br /><br />public class PiernaImpl implements Pierna{<br /><br /> private String tipo;<br /><br /> public void setTipo(String tipo){<br /> this.tipo = tipo;<br /> }<br /><br /> public void arrodillarse(){<br /> System.out.println("Arrodillando la pierna : " + tipo);<br /> }<br /><br /> public void saltar(){<br /> System.out.println("Saltando con la pierna : " + tipo);<br /> }<br /><br /> public void correr(){<br /> System.out.println("Corriendo con la pierna : " + tipo);<br /> }<br /><br />}

package cl.jug.spring.basico.paso2;<br /><br />public interface Cabeza {<br /><br /> void mover();<br /> void pensar();<br /> <br />}

package cl.jug.spring.basico.paso2;<br /><br />public class CabezaImpl implements Cabeza{<br /><br /> public void mover(){<br /> System.out.println("Moviendo la cabeza");<br /> }<br /><br /> public void pensar(){<br /> System.out.println("Pensando.....");<br /> }<br /><br />}

package cl.jug.spring.basico.paso2;<br /><br />public interface Robot {<br /><br /> void moverRobot();<br /> <br />}

package cl.jug.spring.basico.paso2;<br /><br />public class RobotImpl implements Robot{<br /><br /> private Cabeza cabeza;<br /> private Brazo brazoD;<br /> private Brazo brazoI;<br /> private Pierna piernaD;<br /> private Pierna piernaI;<br /><br /><br /> public void moverRobot(){<br /> cabeza.mover();<br /> brazoD.mover();<br /> brazoI.mover();<br /> piernaD.correr();<br /> piernaI.correr();<br /> }<br /><br /> <br /> public void setCabeza(Cabeza cabeza) {<br /> this.cabeza = cabeza;<br /> }<br /><br /> public void setBrazoD(Brazo brazoD) {<br /> this.brazoD = brazoD;<br /> }<br /><br /> public void setBrazoI(Brazo brazoI) {<br /> this.brazoI = brazoI;<br /> }<br /><br /> public void setPiernaD(Pierna piernaD) {<br /> this.piernaD = piernaD;<br /> }<br /><br /> public void setPiernaI(Pierna piernaI) {<br /> this.piernaI = piernaI;<br /> }<br /> <br />}

Pero quien se encargara de ensamblar el robot? Aquí es donde Spring entra en acción. En el archivo “spring-config.xml” definiremos cada una de estas piezas como “Beans” de Spring.

<?xml version="1.0" encoding="UTF-8"?><br /><beans xmlns="http://www.springframework.org/schema/beans" xsi="http://www.w3.org/2001/XMLSchema-instance" p="http://www.springframework.org/schema/p" context="http://www.springframework.org/schema/context" schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"><br /><br /> <bean id="brazoD" class="cl.jug.spring.basico.paso2.BrazoImpl"><br /> <property name="tipo" value="derecho"><br /> </bean><br /><br /> <bean id="brazoI" class="cl.jug.spring.basico.paso2.BrazoImpl"><br /> <property name="tipo" value="izquierdo"><br /> </bean><br /><br /> <bean id="piernaD" class="cl.jug.spring.basico.paso2.PiernaImpl"><br /> <property name="tipo" value="derecha"><br /> </bean><br /><br /> <bean id="piernaI" class="cl.jug.spring.basico.paso2.PiernaImpl"><br /> <property name="tipo" value="izquierda"><br /> </bean><br /><br /> <bean id="cabeza" class="cl.jug.spring.basico.paso2.CabezaImpl"><br /><br /> <bean id="robot" class="cl.jug.spring.basico.paso2.RobotImpl"><br /> <property name="brazoD" ref="brazoD"><br /> <property name="brazoI" ref="brazoI"><br /> <property name="piernaD" ref="piernaD"><br /> <property name="piernaI" ref="piernaI"><br /> <property name="cabeza" ref="cabeza"><br /> </bean><br /><br /></beans>

Como podemos observar, para definir un bean en Spring se utiliza el tag “bean”, al cual se le asigna un “id” único y la clase que define al bean.

Utilizando el tag “property” se puede inyectar un valor al bean. El atributo “name” es el nombre del atributo de la clase que tiene definido un método set en el bean, y el atributo “value”, es el valor que se le inyectara a este bean a través del método set.

Ahora, nuestra clase Test es mucho más simple:

package cl.jug.spring.basico.paso2;<br /><br />import org.springframework.beans.factory.BeanFactory;<br />import org.springframework.beans.factory.xml.XmlBeanFactory;<br />import org.springframework.core.io.ClassPathResource;<br /><br />public class Test {<br /><br /> public static void main(String[] args) throws Exception {<br /> BeanFactory factory = new XmlBeanFactory(new ClassPathResource("spring-config.xml"));<br /> Robot robot = (Robot) factory.getBean("robot");<br /> robot.moverRobot();<br /> }<br /><br />}

Hasta aquí todo bien, pero.....……que sucedería si tuviéramos que definir 60 beans que representen a algunos objetos del dominio de nuestra aplicación, los que a su vez dependen de 15 objetos de servicios o cualquier otra cosa. Lo único que conseguiríamos sería un gran archivo XML con muchas definiciones de beans.

Una solución sería dividir este XML, en XMLs más pequeños, pero igual seguiríamos con el problema de que en la medida que se necesiten nuevos bean se seguirán definiendo nuevos archivos XML.

Con la versión de Spring 2.5 tenemos una mejor opción, el uso de anotaciones!!. En esta versión, Spring provee un conjunto de anotaciones que resuelven la dependencia de los objetos sin tener que utilizar XML.

Veamos un ejemplo de esto:

package cl.jug.spring.basico.paso3;<br /><br />public interface Brazo {<br /><br /> void mover();<br /><br /> void setTipo(String tipo);<br /> <br />}

package cl.jug.spring.basico.paso3;<br /><br />import org.springframework.stereotype.Component;<br />import org.springframework.context.annotation.Scope;<br /><br />@Scope("prototype")<br />@Component("brazo")<br />public class BrazoImpl implements Brazo{<br /><br /> private String tipo;<br /><br /> public void setTipo(String tipo){<br /> this.tipo = tipo;<br /> }<br /><br /> public void mover(){<br /> System.out.println("Moviendo el brazo : " + tipo);<br /> }<br /><br />}

package cl.jug.spring.basico.paso3;<br /><br />public interface Pierna {<br /><br /> void arrodillarse();<br /> void saltar();<br /> void correr();<br /><br /> void setTipo(String tipo);<br /><br />}

package cl.jug.spring.basico.paso3;<br /><br />import org.springframework.stereotype.Component;<br />import org.springframework.context.annotation.Scope;<br /><br />@Scope("prototype")<br />@Component("pierna")<br />public class PiernaImpl implements Pierna{<br /><br /> private String tipo;<br /><br /> public void setTipo(String tipo){<br /> this.tipo = tipo;<br /> }<br /><br /> public void arrodillarse(){<br /> System.out.println("Arrodillando la pierna : " + tipo);<br /> }<br /><br /> public void saltar(){<br /> System.out.println("Saltando con la pierna : " + tipo);<br /> }<br /><br /> public void correr(){<br /> System.out.println("Corriendo con la pierna : " + tipo);<br /> }<br /><br />}

package cl.jug.spring.basico.paso3;<br /><br />public interface Cabeza {<br /><br /> void mover();<br /> void pensar(); <br /> <br />}

package cl.jug.spring.basico.paso3;<br /><br />import org.springframework.stereotype.Component;<br />import org.springframework.context.annotation.Scope;<br /><br />@Scope("prototype")<br />@Component("cabeza")<br />public class CabezaImpl implements Cabeza{<br /><br /> public void mover(){<br /> System.out.println("Moviendo la cabeza");<br /> }<br /><br /> public void pensar(){<br /> System.out.println("Pensando.....");<br /> }<br /><br />}

package cl.jug.spring.basico.paso3;<br /><br />public interface Robot {<br /><br /> void moverRobot();<br /> <br />}

package cl.jug.spring.basico.paso3;<br /><br />import org.springframework.beans.factory.annotation.Autowired;<br />import org.springframework.beans.factory.annotation.Qualifier;<br />import org.springframework.stereotype.Component;<br /><br />import javax.annotation.PostConstruct;<br /><br />@Component("robot")<br />public class RobotImpl implements Robot{<br /><br /> @Autowired(required=true)<br /> @Qualifier("cabeza")<br /> private Cabeza cabeza;<br /><br /> @Autowired(required=true)<br /> @Qualifier("brazo")<br /> private Brazo brazoD;<br /><br /> @Autowired(required=true)<br /> @Qualifier("brazo")<br /> private Brazo brazoI;<br /><br /> @Autowired(required=true)<br /> @Qualifier("pierna")<br /> private Pierna piernaD;<br /><br /> @Autowired(required=true)<br /> @Qualifier("pierna")<br /> private Pierna piernaI;<br /><br /> @PostConstruct<br /> public void inicializarTipos(){<br /> brazoD.setTipo("derecho");<br /> brazoI.setTipo("izquierdo");<br /> piernaD.setTipo("derecha");<br /> piernaI.setTipo("izquierda");<br /> }<br /><br /> <br /> public void moverRobot(){<br /> cabeza.mover();<br /> brazoD.mover();<br /> brazoI.mover();<br /> piernaD.correr();<br /> piernaI.correr();<br /> }<br /><br /> <br /> public void setCabeza(Cabeza cabeza) {<br /> this.cabeza = cabeza;<br /> }<br /><br /> public void setBrazoD(Brazo brazoD) {<br /> this.brazoD = brazoD;<br /> }<br /><br /> public void setBrazoI(Brazo brazoI) {<br /> this.brazoI = brazoI;<br /> }<br /><br /> public void setPiernaD(Pierna piernaD) {<br /> this.piernaD = piernaD;<br /> }<br /><br /> public void setPiernaI(Pierna piernaI) {<br /> this.piernaI = piernaI;<br /> }<br /> <br />}

La anotación "@ Autowired" le informa a Spring, que deberá inyectar automáticamente la dependencia, basado en el tipo definido como Autowired (para nuestro caso, las piezas del robot).

Spring también nos permite definir que objeto será inyectado basándose no solamente en su tipo, sino también utilizando el nombre del bean, a través de la anotación "@ Qualifier".

Pero como le definimos un nombre a los beans? Utilizando la anotación "@Component". Con esta anotación, registramos un nuevo bean que se encuentra disponible para ser inyectado por el contenedor de Spring.

Con estas anotaciones, ya no es necesario definir los "Beans" en un XML.

Ahora, solamente nos queda decirle a Spring, que los bean se encuentran definidos utilizando anotaciones, para lo cual nuestro XML de configuración se reduce a esto:

<?xml version="1.0" encoding="UTF-8"?><br /><beans xmlns="http://www.springframework.org/schema/beans" xsi="http://www.w3.org/2001/XMLSchema-instance" p="http://www.springframework.org/schema/p" context="http://www.springframework.org/schema/context" schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd"><br /><br /> <context:annotation-config/><br /><br /> <context:component-scan package="cl.jug.spring.basico.paso3"> <br /><br /></beans>

Para nuestro test utilizaremos JUnit integrado a Spring:

package cl.jug.spring.basico.paso3;<br /><br />import org.springframework.test.AbstractDependencyInjectionSpringContextTests;<br />import org.springframework.beans.factory.annotation.Autowired;<br /><br />public class TestRobot extends AbstractDependencyInjectionSpringContextTests {<br /><br /> @Autowired <br /> private Robot robot;<br /><br /> @Override<br /> protected String[] getConfigLocations() {<br /> return new String[] { "spring-config2.xml" };<br /> }<br /><br /> public void testEjecutarRobot() {<br /> robot.moverRobot();<br /> }<br /><br /> public void setRobot(Robot robot) {<br /> this.robot = robot;<br /> }<br />}

Con este simple ejemplo ya podemos ver algunos de los conceptos básicos de Spring.

En el próximo post veremos las diversas opciones de configuración de los Beans utilizando XML y algunos conceptos básicos del “Core” como el "BeanFactory".

Si alguien quiere mas información sobre el paquete “JDBC”, José Miguel Selman está desarrollando una excelente serie de artículos introductorios que pueden encontrar aquí.

Primeros pasos con Spring Batch

Hace un tiempo atrás José Miguel Selman publico en su blog el lanzamiento oficial de la versión 1.0 de Spring Batch y desde aquella vez que he querido poder programar un simple ejemplo para meter mis manos en esta nueva funcionalidad que nos ofrece la gente de “SpringSource”, pero por motivos de tiempo (trabajo, clases, JUG, proyectos de investigación,…..etc) nunca he podido darme un tiempo, hasta hoy que me decidí a como de lugar programar mis primeras líneas en” Spring Batch” (mas bien no jugar PS3 :-( …....pero bueno….Lost Planet puede esperar).

En “Spring Batch” un Job es un proceso que se encuentra compuesto por uno o más Step. Para construir un Job utilizaremos una JobInstance, la cual nos permitirá definir un Job, asociándole un conjunto de propiedades llamadas JobParameters. Cada ejecución de una JobInstance será una JobExcecution.

Por ejemplo, supongamos que necesitamos cada cierto periodo de tiempo leer un información de un repositorio de datos (una base de datos, un chache, etc…), generar un archivo XML que represente a esa información e insertar este una cola de mensajería JMS. Este conjunto de tareas sería un Job el cual estaría compuesto de tres Step. Si además, parametrizamos este Job para que se ejecute cada cierto periodo de tiempo (una hora por ejemplo), cada periodo de tiempo seria una JobInstance y cada vez que se ejecute esta instancia (depende de la hora), sería una JobExecution. Este modelo propuesto por “Spring Batch” permite a los desarrolladores una gran flexibilidad respecto a cómo nuestros Job serán lanzados y ejecutados.

El responsable de ejecutar cada uno de los Job definidos, además del grupo de parámetros asociados a este será el JobLauncher. Por último, en muchos casos, necesitaremos algún lugar donde poder almacenar información en tiempo de ejecución relacionada con el proceso batch, para lo cual se utiliza un JobRepository.

Para cada Job es recomendable utilizar un archivo XML de contexto diferente (ya veo un modulo de procesos batch definido con Impala….full!!!). Sin embargo, necesitaremos un conjunto de beans que serán utilizados por cada uno de estos Job. Estos objetos los agruparemos en el applicationContext.xml, los cuales serán importados desde cada una de las definiciones de los Job.

Es Los objetos comunes son:

• JobLauncher: El cual será el responsable de iniciar un Job cargando cada uno de sus parámetros asociados. La implementación más básica se encuentra proveida por la clase SimpleJobLauncher, la cual se soporta en un TaskExecutor para iniciar cada uno de los Job. Si no se especifica el tipo de TaskExecutor se configurara un SyncTaskExecutor por defecto.
• JobRepository: Para el manejo del repositorio utilizaremos un SimpleJobRepository, la cual requerirá un conjunto de DAOs para almacenar la información.
• JobInstanceDAO, JobExecutionDAO y StepExecutionDAO: Estos DAO serán usados por el SimpleJobRepository para almacenar información relacionada con la ejecución de los Job. Para esto, “Spring Batch” provee dos tipos de implementación: basados en Map (se almacenan los datos en memoria) y en JDBC.

En el archivo applicactionContext.xml quedaria asi:

<br /><beans xmlns="http://www.springframework.org/schema/beans" xsi="http://www.w3.org/2001/XMLSchema-instance" schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"><br /><br /> <!-- DEFINICION DEL REPOSITORIO PARA LOS JOB --><br /> <bean id="jobRepository" class="org.springframework.batch.core.repository.support.SimpleJobRepository"><br /> <constructor-arg><br /> <bean class="org.springframework.batch.core.repository.dao.MapJobInstanceDao"><br /> </constructor-arg><br /> <constructor-arg><br /> <bean class="org.springframework.batch.core.repository.dao.MapJobExecutionDao"><br /> </constructor-arg><br /> <constructor-arg><br /> <bean class="org.springframework.batch.core.repository.dao.MapStepExecutionDao"><br /> </constructor-arg><br /> </bean><br /><br /> <!-- DEFINICION DEL LANZADOR DE LOS JOB AL CUAL SE LE INJECTA EL REPOSITORIO --><br /> <bean id="jobLauncher" class="org.springframework.batch.core.launch.support.SimpleJobLauncher"><br /> <property name="jobRepository" ref="jobRepository"><br /> </bean><br /><br /></beans><br />

Para programar nuestro ejemplo, la clase deberá implementar la interfaz Tasklet. Dentro de esta clase programaremos la lógica que deberá ejecutar un Job, que en nuestro caso será un mensaje por consola.

<br />package cl.jug;<br /><br />import org.springframework.batch.core.step.tasklet.Tasklet;<br />import org.springframework.batch.repeat.ExitStatus;<br /><br />public class EjemploTasklet implements Tasklet {<br /><br /> private String mensaje;<br /><br /> @Override<br /> public ExitStatus execute() throws Exception {<br /> System.out.print(mensaje);<br /> return ExitStatus.FINISHED;<br /> }<br /><br /> public void setMensaje(String mensaje) {<br /> this.mensaje = mensaje;<br /> }<br /><br />}<br />

Fíjense que el método “execute” retorna un ExitStatus para indicar el estado de ejecución del Tasklet.

Ahora solo nos queda definir nuestro primer Job en un archivo de contexto que llamaremos EjemploBasicoJob.xml. Dentro de este, utilizaremos la implementación de un SimpleJob la cual ejecutara todos los Step secuencialmente. Para poder definir un Tasklet dentro de un Job, deberemos utilizar un TaskletStep.

<br /><beans xmlns="http://www.springframework.org/schema/beans" xsi="http://www.w3.org/2001/XMLSchema-instance" schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd"><br /><br /> <import resource="applicationContext.xml"><br /><br /> <!-- DEFINICION DE CADA UNO DEL LOS PASOS A EJECUTAR --><br /> <bean id="paso1" class="cl.jug.EjemploTasklet"><br /> <property name="mensaje" value="Ejemplo de Spring Batch - "><br /> </bean><br /><br /> <bean id="paso2" class="cl.jug.EjemploTasklet"><br /> <property name="mensaje" value="http://www.jug.cl - "><br /> </bean><br /><br /> <bean id="paso3" class="cl.jug.EjemploTasklet"><br /> <property name="mensaje" value="jcoronel@jug.cl"><br /> </bean><br /><br /> <!-- DEFINICION DEL EJECUTOR DE LOS PASOS DE MANERA SECUENCIAL --><br /> <bean id="taskletStep" abstract="true" class="org.springframework.batch.core.step.tasklet.TaskletStep"><br /> <property name="jobRepository" ref="jobRepository"><br /> </bean><br /><br /> <!-- DEFINICION DEL JOB EL CUAL ESTA COMPUESTO DE TRES PASOS SECUENCIALES --><br /> <bean id="ejemploJob" class="org.springframework.batch.core.job.SimpleJob"><br /> <property name="name" value="ejemploJob"><br /> <property name="jobRepository" ref="jobRepository"><br /> <property name="steps"><br /> <list><br /> <bean parent="taskletStep"><br /> <property name="tasklet" ref="paso1"><br /> </bean><br /> <bean parent="taskletStep"><br /> <property name="tasklet" ref="paso2"><br /> </bean><br /> <bean parent="taskletStep"><br /> <property name="tasklet" ref="paso3"><br /> </bean><br /> </list><br /> </property><br /> </bean><br /><br /></beans><br />

“Spring Batch” provee muchas formas de ejecutar un Job. La más simple es utilizando la clase CommandLineJobRunner, al cual se puede ejecutar desde línea de comandos y recibe como parámetros iniciales el nombe del archivo de contexto XML donde está definido el Job y el nombre del bean del Job. En mi caso lo estoy ejecutando desde Eclipse, así que solo necesitao crear una nueva “Java Application” y en el “Main class” definir la clase CommandLineJobRunner.

Por último, se le debe pasar por parámetro el nombre del archivo XML de contexto donde se encuentra definido el Job y el nombre del bean del Job.

El codigo fuente desde este ejemplo lo pueden descargar desde aqui

Más información respecto a ejemplo más complejos lo pueden consultar en http://static.springframework.org/spring-batch/spring-batch-docs/reference/html/execution.html.

Nos vemos en el JUG DAY!!!!