Tutorial holamundo con Spring MVC, Hibernate y aspectos.

0. Índice de
contenidos.

• 1. Entorno.
• 2. Introducción.
• 3. Preparación del entorno en eclipse con Maven.
• 4. Configuración Spring MVC, Hibernate y Aspectos.
• 5. Creando la lógica de la aplicación.
• 6. Ejemplo test para el dao.
• 7. Conclusiones

1. Entorno

Este tutorial está escrito usando el siguiente entorno:

• Hardware: Portátil Mac Book Pro 17″ (2,93 Ghz Intel Core 2 Duo, 8 GB DDR3)
• Sistema Operativo: Mac OS X Mavericks 10.9
• Spring Framework 3.0
• IDE: Eclipse Kepler + plugin m2e

2. Introducción.

En este tutorial vamos a hacer un holamundo para probar las distintas tecnologías como son Spring MVC, maven para gestionar las dependencias fácilmente, Hibernate para persistencia, crearemos un aspecto a modo de holamundo para ver cómo funciona y por último crearemos un test de prueba con JUnit.

Para el ejemplo, vamos a crear una base de datos en la que vamos a tener unos libros y los vamos a mostrar por pantalla, y teniendo una opción para introducir nuevos libros.

3. Preparación del entorno en eclipse con Maven.

EL primer paso para empezar el tutorial, es crear un nuevo proyecto en eclipse. Voy a suponer que ya está instalado todo lo necesario como maven y el plugin de Spring.

En este tutorial podemos ver cómo crear el proyecto para SpringMVC.

El pom de nuestro proyecto maven va a ser el siguiente, para que se descargen las dependencias necesarias:

	<!--

	/pom.xml

	 -->

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.autentia.libreria</groupId>
	<artifactId>libreria</artifactId>
	<version>1.0.0-SNAPSHOT</version>
	<packaging>war</packaging>

	<properties>
		<spring.version>3.2.3.RELEASE</spring.version>
		<hibernate.version>4.2.2.Final</hibernate.version>
		<javax_servlet.version>2.5</javax_servlet.version>
		<jstl.version>1.2</jstl.version>
		<hsql.version>2.2.9</hsql.version>
		<aspectj.version>1.7.3</aspectj.version>
		<junit.version>4.11</junit.version>
	</properties>

	<dependencies>
		<!-- Spring -->
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-webmvc</artifactId>
			<version>${spring.version}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-orm</artifactId>
			<version>${spring.version}</version>
		</dependency>
				<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-test</artifactId>
			<version>${spring.version}</version>
		</dependency>

		<!-- Hibernate -->
		<dependency>
			<groupId>org.hibernate</groupId>
			<artifactId>hibernate-core</artifactId>
			<version>${hibernate.version}</version>
		</dependency>

		<!-- Java EE -->
		<dependency>
			<groupId>javax.servlet</groupId>
			<artifactId>servlet-api</artifactId>
			<version>${javax_servlet.version}</version>
			<scope>provided</scope>
		</dependency>
		<dependency>
			<groupId>jstl</groupId>
			<artifactId>jstl</artifactId>
			<version>${jstl.version}</version>
		</dependency>

		<!-- Hypersonic Database -->
		<dependency>
			<groupId>org.hsqldb</groupId>
			<artifactId>hsqldb</artifactId>
			<version>${hsql.version}</version>
			<scope>runtime</scope>
		</dependency>

		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjrt</artifactId>
			<version>${aspectj.version}</version>
		</dependency>
		<dependency>
			<groupId>org.aspectj</groupId>
			<artifactId>aspectjweaver</artifactId>
			<version>${aspectj.version}</version>
		</dependency>

		<!-- JUnit -->
		<dependency>
			<groupId>junit</groupId>
			<artifactId>junit</artifactId>
			<version>${junit.version}</version>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<version>3.1</version>
				<configuration>
					<source>1.6</source>
					<target>1.6</target>
				</configuration>
			</plugin>
		</plugins>
	</build>

</project>

Y al final del tutorial el proyecto tiene que tener una estructura como la siguiente:

Y otra cosa a tener en cuenta es que la aplicación correrá bajo un tomcat, que se sale del tutorial explicar cómo instalarlo en eclipse, aunque no tiene ninguna complicación.

4. Configuración Spring MVC, Hibernate y Aspectos.

Para empezar nos creamos en la ruta: /webapp/WEB-INF/ un archivo xml que en mi caso le he llamado servlet-context.xml que será donde estén todas las beans y configuraciones de hibernate y aspectos. Al ser un pequeño ejemplo no se ha modularizado que es lo conveniente.

Voy a comentar en el mismo código las cosas más significativas:

	<!--

	src/main/webapp/WEB-INF/servlet-context.xml

	 -->


<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
	xmlns:beans="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
    http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
    http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">



	<!-- Con esto Spring MVC reconoce las anotaciones como RequestMapping que nos harán falta más tarde.-->
	<mvc:annotation-driven/>

	<bean
		class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/WEB-INF/" />
		<property name="suffix" value=".jsp" />
	</bean>

	<!-- Escanea el classpath buscando anotaciones (eg: @Service, @Repository etc) -->
	<context:component-scan base-package="com.autentia.libreria.*" />


	<!-- Configuración de la base de datos embebida. -->
	<!-- libros.sql es el archivo que contiene el script de la base de datos. -->
	<jdbc:embedded-database id="dataSource" type="HSQL">
		<jdbc:script location="classpath:persistence/libros.sql" />
	</jdbc:embedded-database>

	<!-- Hibernate Session Factory -->
	<bean id="mySessionFactory"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="packagesToScan">
			<array>
				<value>com.autentia.libreria</value>
			</array>
		</property>
		<property name="hibernateProperties">
			<value>
				hibernate.dialect=org.hibernate.dialect.HSQLDialect
			</value>
		</property>
	</bean>

 
 	<!-- Para reconocer aspectos -->
	<aop:aspectj-autoproxy/>

	<!-- Bean donde se encuentra el aspecto, para que lo incluya Spring -->
	<bean id="imprimeLog" class="com.autentia.libreria.aspects.LoggerAspect" />
	 

	<!-- Hibernate Transaction Manager -->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate4.HibernateTransactionManager">
		<property name="sessionFactory" ref="mySessionFactory" />
	</bean>

	<!-- Activates annotation based transaction management -->
	<tx:annotation-driven transaction-manager="transactionManager" />

 </beans>

Ahora vamos a explicar de la misma manera el fichero web.xml, que se encuentra en la misma ruta que el anterior y es en el que configuraremos los servlets.

	<!--

	src/webapp/WEB-INF/web.xml

	 -->



<web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">


<!-- Aquí lo importante es el DispatcherServlet, que coge la configuración del fichero servlet-context.xml que definimos antes. -->
	<servlet>
		<servlet-name>appServlet</servlet-name>
		<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
		<init-param>
			<param-name>contextConfigLocation</param-name>
			<param-value>/WEB-INF/servlet-context.xml</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>

	<!-- Aquí indicamos la ruta donde el dispatcher estará escuchando, en este caso la raíz de la web(/). -->

	<servlet-mapping>
		<servlet-name>appServlet</servlet-name>
		<url-pattern>/</url-pattern>
	</servlet-mapping>

</web-app>

Con esto tenemos la configuración mínima para funcionar, nos queda crear nuestras clases, el script de la base de datos, el aspecto y la vista que lo haremos en la siguiente sección.

5. Creando la lógica de la aplicación.

Vamos a empezar con las clases de persistencia, primeramente creamos el POJO Libro con las anotaciones de Hibernate.

	/* 

	src/main/java/com/autentia/libreria/domain/Libro.java 

	*/

	//Con entity y table estamos diciendo cómo se mapea la clase en la base de datos.
	@Entity
	@Table(name = "Libro")
	public class Libro {
	
	//Id indica a hibernate que es la primary key
	//Indica con qué columna de la base de datos se corresponde cada variable.
	//Es buena práctica llamar a las variables igual que la columna en base de datos.
	@Id
	@Column(name="id")
	private Integer id;
	
	@Column(name="titulo")
	private String titulo;
	
	@Column(name="isbn")
	private String isbn;
	
	@Column(name="autor")
	private String Autor;

	/*

	Adds getters and setters...
	
	*/

}

Ahora vamos a definir el dao, que será muy sencillo, como toda la aplicación.

	/* 

	src/main/java/com/autentia/libreria/persistence/Dao.java 

	*/

	//Repository indica a Spring que es un beans y que forma parte del modelo. 
	//Es equivalente a @Component, pero viene bien especificar a que parte pertenece.
	@Repository
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public class Dao {

	//Autowired indica a Spring que sessionFactory tiene que inyectarlo
	@Autowired
	private SessionFactory sessionFactory;

	//Transaccional indica que la transacción o se completa entera o se hace rollback
	//En los select no es necesario, pero ya que se delega Hibernate a Spring hace falta.
	@Transactional
	public List<Libro> findAll() {
		
		Session session = sessionFactory.getCurrentSession();
		List pizzas = session.createQuery("from Libro").list();
		return pizzas;
	}
	
	@Transactional
	public void insertBook(Libro libro) {
		
		sessionFactory.getCurrentSession().save(libro);
	
	}
}

Ya que estamos con la parte de persistencia, ahora dejo el script de creación de la base de datos y algún dato de ejemplo.

-- src/main/resources/persistence/libros.sql

	CREATE  TABLE LIBRO (
  id INT NOT NULL ,
  titulo VARCHAR(45) NOT NULL ,
  isbn VARCHAR(50) ,
  autor VARCHAR(50) ,
  PRIMARY KEY (id) );
  
  
INSERT INTO libro VALUES ('0','Java','1234','Manuel');
INSERT INTO libro VALUES ('1','C','4567','Ricardo');
INSERT INTO libro VALUES ('2','Python','1010','Jaime');
  

No voy a explicar nada del script ya que es básico. Ahora seguimos con la parte de vista. Primero describiré el service, que será llamado por el controller de la vista y por último describiré la vista, para dejar para el final el aspecto.

En el servicio vamos a implementarlo con una interfaz, que es como se debe hacer todo, pero al ser un ejemplo sencillo solo contaremos con esta interfaz, en vuestras manos dejo implementar correctamente los demás métodos.

	/*

src/main/java/com/autentia/libreria/service/LibroService.java 

	*/

	public interface LibroService {
	  
	  public List<Libro> findAll();
	  
	  public void insert(Libro libro); 

}

Y ahora la implementación del servicio, que implementará la interfaz que acabamos de crear.

	/*

src/main/java/com/autentia/libreria/service/impl/LibroServiceImpl.java 

	*/

@Service
public class LibroServiceImpl implements LibroService {
	
	@Autowired 
	  private Dao dao;
	  
	  public List<Libro> findAll(){
		  return dao.findAll();
	  }
	  
	  public void insert(Libro libro){
		  dao.insertBook(libro);
	  }

}

El controlador será el siguiente:

/*

src/main/java/com/autentia/libreria/controller/LibroController.java 

*/

//Igual que hemos visto antes con repository, pero esta vez para la parte de controlador.
//RequestMapping forma parte de las anotaciones de springMVC que su funcionamiento se basa en recoger las peticiones
//que se hacen a la url relativa, en este caso la raíz, e indica a Spring que esta es la clase que maneja la vista.
@Controller
@RequestMapping("/")
public class LibroController {

	//empezamos en 3 por no complicar la clase sacando de la base de datos el siguiente id, y al ser un holamundo sabemos cuantos datos hay.
	  private static int num = 3;
	   
	  @Autowired
	  private LibroService libroService;
	   
	  //Aquí ademá estamos diciendo que el método usado es por petició GET.
	  @RequestMapping(method = RequestMethod.GET)
	  public String list(Model model) {

	  //la función del método es rellenar las variables libros y libro, una con la lista de libros 
	  //sacados de la base de datos, y libro para que pueda ser rellenada con los datos del formulario.

	    List<Libro> libros = libroService.findAll();
	    model.addAttribute("libros", libros);
	    model.addAttribute("libro", new Libro());
	    return "index";
	  }
	  
	  @RequestMapping("/addBook")
	  public String addBook(@ModelAttribute("libro") Libro libro) {
		  libro.setId(num);
		  num++;
		  libroService.insert(libro);
		  return "redirect:/";
	  }
}

Una vez explicado el controlador, vamos a hacer una vista muy simple para mostrar la información.

	<!--

	src/webapp/WEB-INF/index.jsf

	 -->
	...
	
	<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
	<%@taglib uri="http://www.springframework.org/tags/form" prefix="form"%>
	
	...
	
	<body>
    <h1>Lista de libros</h1>
    <ul>

		<!-- Lista con todos los libros que hay en la base de datos, 
			los saca de la variable libros. -->

        <c:forEach var="p" items="${libros}">
            <li>Titulo: ${p.titulo} - Autor:  ${p.autor} - ISBN: ${p.isbn}</li>
        </c:forEach>
    </ul>

    <!-- formulario en el que se recogen los datos para crear un nuevo libro,
    y al mandar llama a /addbook que será mapeado por nuestro método insertBook 
    que definimos en LibroController. -->
    
    <form:form method="post" action="addBook" commandName="libro">
  
    <table>
    <tr>
        <td><form:label path="titulo">Titulo:</form:label></td>
        <td><form:input path="titulo" /></td>
    </tr>
    <tr>
        <td><form:label path="autor">Autor:</form:label></td>
        <td><form:input path="autor" /></td>
    </tr>
    <tr>
        <td><form:label path="isbn" >ISBN:</form:label></td>
        <td><form:input path="isbn" /></td>
    </tr>
    <tr>
        <td colspan="2">
            <input type="submit" />
        </td>
    </tr>
</table> 
</form:form>
    
    
</body>

Y ya sólo nos queda definir el aspecto que será una clase java en la cual simplemente se llama a imprimir en la salida estandar cada vez que se ejecuta un método que se llama list().

/*

src/main/java/com/autentia/libreria/aspects/LoggerAspect.java 

*/

//Indicamos que es un aspecto
@Aspect
public class LoggerAspect {
	
	//variable que indica numero de veces que se ha llamado
	private static int veces = 1;

	//Aquí hay varias partes, la anotación Before indica que se tiene que ejecutar antes de el pointcut que indiquemos dentro
	//El pointcut es un punto en el programa en el que poder ejecutar un aspecto, en este caso hemos indicado nuestro pointcut como cualquier
	//método que se llamado desde cualquier parte que se llame list(), con al menos un parámetro.
	@Before("execution(* list(..))")
	public void imprimirlog(){
		System.out.println("Se ha llamado a método list : " + veces);
		veces++;
	}
	
}

Con esto hemos terminado de definir La lógica de nuestro programa. En resumen, tenemos una base de datos con varios libros, gestionada por hibernate. Spring MVC nos muestra la vista y controla las variables que aparecen en la vista y que la rellenan. Y tenemos un aspecto que se ejecuta cada vez que el método list() es llamado.

En la siguiente parte veremos cómo hacer un pequeño ejemplo de test, que no probaremos todo, sólo la base de datos como ejemplo.

6. Ejemplo test para el dao.

Ahora vamos a realizar tres simples test, en el primero comprobamos que en la base de datos existen 3 libros, los cuales introducimos con el script libros.sql. En el segundo probamos que se realiza el insert correctamente. Y en el último comprobamos que se borran libros correctamente.

/*

	src/test/java/libreria/Tests.java

*/

//Con RunWith indicamos que sea Spring quien gestione los test y nos provea de funcionalidades de Spring como la DI y las anotaciones.
//En contextConfiguration ponemos la ruta donde está nuestro xml con la configuración que necesitamos.
//Es un XML distinto debido a que no nos hace falta levantar todo lo que habíamos levantado en la aplicación.
//Más adelante pondré el XML servlet-context-test.xml.
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:spring/servlet-context-test.xml" })
public class Tests {

	@Resource
	private Dao dao;

	List<Libro> libros;

	Libro libro;

	private static final int LIBROSBD = 3;

	//Con before estamos configurando que este método sea invocado antes de los test
	//Aquí pondremos la inicialización de las instancias que necesitemos en los test.
	//Como ejemplo vamos a crearnos un Libro.
	@Before
	public void setUp() {
		libro = new Libro();
		libro.setId(5);
		libro.setAutor("Carlos");
		libro.setTitulo("HTML");
		libro.setIsbn("5555");
	}


	//Empezamos con los test, cada test tiene que tener la anotación de Test
	//En este primer Test probamos que haya 3 libros en la base de datos, que son los libros que introducimos con el script
	@Test
	public void testBBDD() {
		libros = dao.findAll();
		Assert.assertTrue("Comprobar que en la base de datos hay 3 libros",
				libros.size() == LIBROSBD);
	}

	//En este test probamos a introducir un libro y le volvemos a sacar de la base de datos para comprobar que es correcto
	@Test
	public void testInsert() {

		dao.insertBook(libro);
		libros = dao.findAll();
		Assert.assertTrue("Comprueba que hay un libro mas",
				libros.size() == LIBROSBD + 1);

		Libro libroAux = libros.get(LIBROSBD);

		Assert.assertTrue("Comprueba que coincide id.",
				libro.getId() == libroAux.getId());
		Assert.assertTrue("Comprueba que coincide el autor.",
				libro.getAutor() == libroAux.getAutor());
		Assert.assertTrue("Comprueba que coincide el titulo.",
				libro.getTitulo() == libroAux.getTitulo());
		Assert.assertTrue("Comprueba que coincide el ISBN.",
				libro.getIsbn() == libroAux.getIsbn());

		dao.deleteBook(libroAux);
	}

	//En este test comprobamos que se borra de la base de datos correctamente.
	@Test
	public void testDelete() {

		dao.insertBook(libro);

		libros = dao.findAll();
		Assert.assertTrue("Comprueba que hay un libro mas.",
				libros.size() == LIBROSBD + 1);

		dao.deleteBook(libro);

		libros = dao.findAll();
		Assert.assertTrue("Comprueba que vuelve a haber los libros iniciales.",
				libros.size() == LIBROSBD);
	}
}

Ahora vamos con el XML que hemos reducido para levantar únicamente lo que necesitamos para los test.

	<!--

	src/test/resources/spring/servlet-context-test.xml

	 -->

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:beans="http://www.springframework.org/schema/beans"
	xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
	xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd
    http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd">



	<!-- Escanea el classpath buscando anotaciones (eg: @Service, @Repository etc) -->
	<context:component-scan base-package="com.autentia.libreria.*" />



	<jdbc:embedded-database id="dataSource" type="HSQL">
		<jdbc:script location="classpath:persistence/libros.sql" />
	</jdbc:embedded-database>

	<!-- Hibernate Session Factory -->
	<bean id="mySessionFactory"
		class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="packagesToScan">
			<array>
				<value>com.autentia.libreria</value>
			</array>
		</property>
		<property name="hibernateProperties">
			<value>
				hibernate.dialect=org.hibernate.dialect.HSQLDialect
			</value>
		</property>
	</bean>
	

	<!-- Hibernate Transaction Manager -->
	<bean id="transactionManager"
		class="org.springframework.orm.hibernate4.HibernateTransactionManager">
		<property name="sessionFactory" ref="mySessionFactory" />
	</bean>

	<!-- Activates annotation based transaction management -->
	<tx:annotation-driven transaction-manager="transactionManager" />


</beans>

Como podemos ver hemos quitado la parte de MVC y aspectos ya que no se van a probar en los Test.

Sólo queda decir que para ejecutarlo, por ejemplo, se pulsa en el botón derecho sobre la clase y la ruta : RunAs –> JUnit Test, y vemos que los tres test pasan correctamente. En la siguiente imagen lo muestro.

7. Conclusiones.

El objetivo del tutorial es mostrar un pequeño ejemplo de todo el sistema mvc, con los spring e hibernate como base, y añadiendo aspectos y tests, para que sea un punto de partida para hacer cosas más interesantes.

Dejo el código del proyecto aquí para que lo podáis descargar.

Para cualquier duda o aclaración, en los comentarios.

Un saludo.