Retomando el proyecto, descárgalo aquí, solo tenemos un esqueleto de una aplicación que ya es ejecutable pero que aun no hace nada.
Las librerías que estamos usando actualmente son:
- Spring (4.2.3.RELEASE).
- Hibernate (4.3.11).
- H2 (1.4.190).
- Jackson (2.4.3).
La arquitectura que estamos manejando seria muy similar a la siguiente imagen.
Como en toda aplicación lo mas importante es la base de datos,en nuestro caso es una base de datos H2, comencemos a declarar la conexión a ella.
Registraremos un bean de Spring llamado DriverManagerDataSource, que es una simple implementación de la interfaz estándar DataSource, la cual nos permitirá conectarnos a nuestra base de datos de una manera muy sencilla.
Primero deberemos abrir nuestro archivo mvc-dispatcher-servlet.xml, aquí declararemos la configuración para nuestro datasource.
Crearemos una etiqueta llamada <bean></bean> y le agregamos dos atributos llamados id="" y class="", el atributo id lo llamaremos DataSource, este atributo nos ayudara a identificar nuestro bean en el archivo para las siguientes configuraciones y en el atributo class especificaremos la clase de Spring que estaremos utilizando(org.springframework.jdbc.datasource.DriverManagerDataSource).
Ahora que ya tenemos declarado nuestro bean es momento de especificarle algunas de sus propiedades, para ello crearemos 4 etiquetas <property />, dentro de la etiqueta bean del datasource, con dos atributos llamados name="" y value="".
Cada una de estas etiquetas representa una propiedad de la clase DriverManagerDataSource de Spring que contendrá la conexión a nuestra base de datos , las cuales son driverClassName (driver de JDBC para nuestra base de datos), url (dirección de nuestra base de datos), username (usuario) y password (contraseña), de esta forma si algún día necesitamos cambiar nuestra base de datos, solo tendremos que modificar estos parámetros por los correspondientes a la nueva base de datos.
Bien el driver de nuestra base de datos es org.h2.Driver,mas información aquí, la url será jdbc:h2:mem:test;DB_CLOSE_DELAY=-1, la información aquí, el usuario sera sa y el password lo dejaremos vacío.
Después de esto tendremos ya preparada nuestra conexión a la base de datos , pero aun hace falta agregar algunas configuraciones mas para la clase LocalContainerEntityManagerFactoryBean que nos ayudara para obtener objetos EntityManager los cuales tienen la función de persistir información, crear consultas y mas cosas a nuestra base de datos.
También sera necesario configurar las transacciones mediante la clase JpaTransactionManager que nos provee una forma transparente de acceder a recursos de múltiples transacciones en una sola transacción.
Registraremos un nuevo bean con el id entityManagerFactory y su clase sera org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean , en el declararemos 5 propiedades, la primera de ellas se llama persistenceUnitName que sera nuestra unidad de persistencia y la nombraremos persistenceUnit (el nombre puede ser de su elección).
La segunda propiedad se llamara packagesToScan en ella diremos en que paquete se encontraran nuestras clases entidad, las cuales serán la representación de nuestras tablas a clases de Java, en nuestro caso el paquete se llamara com.todo.model, pero a diferencia de las propiedades anteriores está NO contendrá un atributo value, en su lugar agregaremos una etiqueta <list></list> y dentro de ella una etiqueta <value></value> y una vez mas dentro de ella el nombre de nuestro paquete, está configuración nos evitará tener que crear y mantener el archivo persistence.xml.
Puede parecer algo tedioso y aburrido configurar Spring, pero a la larga nos ayudara mucho en el desarrollo y cuando nos familiaricemos con este fichero todo será mas sencillo.
Debo mencionar que los proyectos de Spring se pueden configurar sin necesidad de ficheros XML con la ayuda de anotaciones,mas información aquí.
La siguiente propiedad se llamda dataSource y está etiqueta NO contendrá el atributo value, en su lugar usaremos el atributo ref al cual le pasaremos el id de nuestro bean dataSource, el cual es dataSource.
Ahora toca agregar una propiedad llamada jpaVendorAdapter, está propiedad tampoco incluirá el atributo value, debido a que tiene una declaración de un bean dentro de ella, así que agregaremos una etiqueta <bean></bean> la cual apunta al adaptador de Spring para Hibernate que es una clase llamada HibernateJpaVendorAdapter.
En la declaración de este bean agregaremos 2 propiedades mas, una con el nombre de databasePlatform, en está propiedad especificaremos el dialecto de Hibernate que debe utilizar en nuestra base de datos, para H2 el dialecto es org.hibernate.dialect.H2Dialect.
Para fines de desarrollo en la segunda propiedad le pediremos a Hibernate que muestre las consultas de SQL que esta ejecutando mediante la propiedad showSql a la cual le pasaremos el valor de true, más información de las propiedades de configuración de Hibernate aquí.
Después de la propiedad jpaVendorAdapter agregaremos otra propiedad relacionada con Hibernate llamada jpaProperties, recordemos que Hibernate es nuestro proveedor de JPA, aquí especificaremos una etiqueta llamada <props></props> y dentro de esta etiqueta agregaremos otra etiqueta llamada <prop></prop> y en ella agregaremos un atributo llamado key con el valor hibernate.hbm2ddl.auto y dentro de la etiqueta escribiremos create-drop.
Con esta propiedad estamos indicando que cuando inicie la aplicación se deben crear las tablas nuevamente en base a nuestra unidad de persistencia, es decir, Hibernate borrara el esquema de tablas y lo creara otra vez de acuerdo al contenido de nuestras entidades.
Ya configuramos la conexión a nuestra base de datos así como la creación de nuestras tablas y ahora toca configurar las transacciones.
Las transacciones en Spring se configuran agregando un nuevo bean en el XML el cual apunta a la clase JpaTransactionManager,este bean tendra como identificador el nombre de transactionManager y su clase sera org.springframework.orm.jpa.JpaTransactionManager ,dentro de este bean solamente agregaremos una nueva propiedad llamada entityManagerFactory y tendra un atributo llamado ref para hacer referencia a nuestro bean entityManagerFactory.
Muy bien, con lo anterior estamos configurando el administrador de transacciones de Spring y ahora configuraremos la anotación @Transactional para una administración de transacciones mucho mas fluido y sencillo agregando una etiqueta llamada <tx:annotation-driven /> con un atributo transaction-manager al que le pasaremos el id de nuestro bean transactionManager.
Ahora podremos hacer uso de la anotación @Transactional en nuestros métodos y clases para indicar que su ejecución debe ir dentro de una transacción, mas información aquí.
Ya configuramos todo lo relacionado con nuestra base de datos y ahora toca configurar las anotaciones de Spring MVC, para crear de una forma mas sencilla nuestros beans a la hora de desarrollar, esto lo hacemos agregando la etiqueta <mvc:annotation-driven />.
Por ultimo debemos decirle a Spring en que paquete debe buscar nuestras clases de Java anotadas como componentes de Spring(@Controller,@Service, etc), esto lo hacemos agregando la etiqueta <context:component-scan /> con un atributo llamado base-package al cual le pasaremos el valor de com.todo, el cual es la raíz de todas nuestras clases de Java.
Una vez mas aparentemente no hemos hecho nada, nuestra aplicación se inicia pero aun no hay funcionalidad programada.
El archivo mvc-dispatcher-servlet.xml, deberiá verse así
El proyecto de Eclipse se puede descargar aquí y el repositorio del proyecto esta aquí.