Integración Spring y Hibernate

Ejercicio: Integración Spring y Hibernate
Ejercicio
Integración Spring y Hibernate
Curso de Spring Framework
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Objetivo del Ejercicio
•El
objetivo del ejercicio es crear un proyecto que integre los
frameworks de Spring y Hibernate. Al finalizar deberemos ver la
siguiente salida:
Curso de Spring Framework
2
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Diagrama de Clases
•Este
es el Diagrama de Clases del Ejercicio, donde se pueden
observar la capa de datos y la capa de negocio implementada por
Hibernate y Spring respectivamente.
Curso de Spring Framework
3
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 1. Crear un proyecto Maven
Creamos un nuevo proyecto Maven:
Curso de Spring Framework
4
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 1. Crear un proyecto Maven (cont)
Filtramos los wizards y escribimos maven, seleccionando un nuevo
proyecto Maven
Curso de Spring Framework
5
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 1. Crear un proyecto Maven (cont)
Creamos un proyecto simple de Maven
Curso de Spring Framework
6
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 1. Crear un proyecto Maven (cont)
Escribimos los valores por siguientes:
Curso de Spring Framework
7
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 2. Configuración del Proyecto
Indicamos que no excluya ningún archivo en resources:
Curso de Spring Framework
8
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 3. Agregar dependencias al archivo pom.xml
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>3.1.1.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>3.1.1.RELEASE</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.10</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>3.1.1.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>3.1.1.RELEASE</version>
</dependency>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.14</version>
</dependency>
<dependency>
<groupId>cglib</groupId>
<artifactId>cglib</artifactId>
<version>2.2.2</version>
<scope>runtime</scope>
</dependency>
Curso de Spring Framework
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>3.1.1.RELEASE</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjrt</artifactId>
<version>1.6.11</version>
</dependency>
<dependency>
<groupId>org.aspectj</groupId>
<artifactId>aspectjweaver</artifactId>
<version>1.6.11</version>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
<artifactId>h2</artifactId>
<version>1.0.20070304</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-entitymanager</artifactId>
<version>4.1.2.Final</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-orm</artifactId>
<version>3.1.1.RELEASE</version>
</dependency>
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 4. Agregar el archivo log4j
Crear el archivo para el manejo de logging llamado log4j.properties
Este archivo lo depositaremos en src/main/resources en nuestro
proyecto recién creado.
Curso de Spring Framework
10
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 4. Agregar el archivo log4j (cont)
Agregar el siguiente contenido:
# Set root logger level to DEBUG and its only appender to A1.
log4j.rootLogger=INFO, A1
# A1 is set to be a ConsoleAppender.
log4j.appender.A1=org.apache.log4j.ConsoleAppender
# A1 uses PatternLayout.
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n
#Habilitamos el log de jdbc en Spring
log4j.category.org.springframework.jdbc.core=INFO
#Habilitamos el log de transacciones en Spring
log4j.logger.org.springframework.transaction=INFO
Curso de Spring Framework
11
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 5. Crear el archivo esquema.sql
Crear el archivo esquema.sql y depositarlo en src/test/resources:
Curso de Spring Framework
12
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 5. Crear el archivo esquema.sql (cont)
Agregar el siguiente contenido al archivo llamado esquema.sql:
drop table if exists persona;
create table persona (
id_persona identity primary key,
nombre varchar(50) not null,
ape_paterno varchar(50) not null,
ape_materno varchar(50),
email varchar(50) not null unique
);
Curso de Spring Framework
13
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 6. Crear el archivo datos.sql
Crear el archivo datos.sql y depositarlo en src/test/resources:
Curso de Spring Framework
14
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 6. Crear el archivo datos.sql (cont)
Agregar el siguiente contenido al archivo llamado datos.sql:
insert into persona (nombre, ape_paterno, email) values ('Admin', 'admin',
'[email protected]');
insert into persona (nombre, ape_paterno, email) values ('Juan', 'Perez',
'[email protected]');
insert into persona (nombre, ape_paterno,
'Rodriguez', '[email protected]');
Curso de Spring Framework
email)
values
('Juan',
15
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 7. Creación del archivo datasource-test.xml
Crear el archivo datasource-test.xml (es de tipo SpringBean Definition
file) y depositarlo en src/test/resources :
Curso de Spring Framework
16
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 7. Creación del archivo datasource-test.xml(cont)
Agregar los namespaces de beans, jdbc y p al archivo datasourcetest.xml:
Curso de Spring Framework
17
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 7. Creación del archivo datasource-test.xml(cont)
Agregar la siguiente configuración al archivo datasource-test.xml:
<jdbc:embedded-database id="dataSource" type="H2">
<jdbc:script location="classpath:esquema.sql" />
<jdbc:script location="classpath:datos.sql" />
</jdbc:embedded-database>
<bean id="sessionFactory"
class="org.springframework.orm.hibernate4.LocalSessionFactoryBean"
p:dataSource-ref="dataSource">
<property name="packagesToScan">
<list>
<value>mx.com.gm.capadatos.domain</value>
</list>
</property>
<property name="hibernateProperties">
<value>
hibernate.format_sql=true
hibernate.show_sql=true
hibernate.dialect=org.hibernate.dialect.H2Dialect</value>
</property>
</bean>
<bean id="transactionManager"
class="org.springframework.orm.hibernate4.HibernateTransactionManager"
p:sessionFactory-ref="sessionFactory" />
Curso de Spring Framework
18
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 8. Creación archivo applicationContext.xml
Crear el archivo applicationContext.xml (es de tipo SpringBean
Definition file) y depositarlo en src/main/resources :
Curso de Spring Framework
19
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 8. Creación archivo applicationContext.xml (cont)
Agregar los namespaces
applicationContext.xml:
Curso de Spring Framework
de
beans
y
context
al
archivo
20
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 8. Creación archivo applicationContext.xml (cont)
Agregar el siguiente contenido al archivo applicationContext.xml:
<tx:annotation-driven/>
<context:component-scan base-package="mx.com.gm.capaservicio" />
<context:component-scan base-package="mx.com.gm.capadatos" />
Curso de Spring Framework
21
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 9. Agregar la clase Persona
Agregamos la siguiente clase Persona.java:
package mx.com.gm.capadatos.domain;
import
import
import
import
import
javax.persistence.Column;
javax.persistence.Entity;
javax.persistence.GeneratedValue;
javax.persistence.GenerationType;
javax.persistence.Id;
@Entity
public class Persona {
@Id
@GeneratedValue(strategy=GenerationType.IDENTITY)
@Column(name = "id_persona")
private long idPersona;
private String nombre;
@Column(name = "ape_paterno")
private String apePaterno;
@Column(name = "ape_materno")
private String apeMaterno;
private String email;
public Persona() {
}
public Persona(long idPersona) {
this.idPersona = idPersona;
}
public long getIdPersona() {
return idPersona;
}
public void setIdPersona(long idPersona) {
this.idPersona = idPersona;
}
Curso de Spring Framework
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getApePaterno() {
return apePaterno;
}
public void setApePaterno(String apePaterno) {
this.apePaterno = apePaterno;
}
public String getApeMaterno() {
return apeMaterno;
}
public void setApeMaterno(String apeMaterno) {
this.apeMaterno = apeMaterno;
}
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 9. Agregar la clase Persona (cont)
Anexar el siguiente código a la clase Persona.java:
@Override
public String toString() {
return "Persona [idPersona=" + idPersona + ",
nombre=" + nombre
+ ", apePaterno=" + apePaterno + ",
apeMaterno=" + apeMaterno
+ ", email=" + email + "]";
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result
+ ((apeMaterno
== null) ? 0
apeMaterno.hashCode());
result = prime * result
+ ((apePaterno
== null) ? 0
apePaterno.hashCode());
result = prime * result + ((email == null) ?
: email.hashCode());
result = prime * result + (int) (idPersona
(idPersona >>> 32));
result = prime * result + ((nombre == null) ?
: nombre.hashCode());
return result;
}
Curso de Spring Framework
:
:
0
^
@Override
public boolean equals(Object obj) {
if (this == obj) {return true;}
if (obj == null) {return false;}
if (getClass() != obj.getClass()) {return false;}
Persona other = (Persona) obj;
if (apeMaterno == null) {
if (other.apeMaterno != null) {return false;}
} else if (!apeMaterno.equals(other.apeMaterno)) {return
false;}
if (apePaterno == null) {
if (other.apePaterno != null) {return false;}
} else if (!apePaterno.equals(other.apePaterno)) {return
false;}
if (email == null) {
if (other.email != null) {return false;}
} else if (!email.equals(other.email)) {return false;}
if (idPersona != other.idPersona) {return false;}
if (nombre == null) {
if (other.nombre != null) {return false;}
} else if (!nombre.equals(other.nombre)) {return false;}
return true;
}
}
0
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 10. Agregar la interface PersonaDao
Agregamos la siguiente interface PersonaDao.java:
package mx.com.gm.capadatos;
import java.util.List;
import mx.com.gm.capadatos.domain.Persona;
public interface PersonaDao {
void insertPersona(Persona persona);
void updatePersona(Persona persona);
void deletePersona(Persona persona);
Persona findPersonaById(long idPersona);
List<Persona> findAllPersonas();
long contadorPersonas();
Persona getPersonaByEmail(Persona persona);
}
Curso de Spring Framework
24
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 11. Agregar la clase PersonaDaoImpl
Agregar la clase PersonaDaoImpl.java:
package mx.com.gm.capadatos;
import java.util.List;
public void updatePersona(Persona persona) {
currentSession().update(persona);
}
import mx.com.gm.capadatos.domain.Persona;
import
import
import
import
import
import
org.hibernate.Session;
org.hibernate.SessionFactory;
org.hibernate.criterion.Example;
org.hibernate.criterion.Projections;
org.springframework.beans.factory.annotation.Autowired;
org.springframework.stereotype.Repository;
@Repository
public class PersonaDaoImpl implements PersonaDao {
private SessionFactory sessionFactory;
@Autowired
public PersonaDaoImpl(SessionFactory sessionFactory) {
this.sessionFactory = sessionFactory;
}
/*
* Se necesita de una transaccion activa por ello la prueba
unitaria utiliza @Transactional
*/
private Session currentSession() {
return sessionFactory.getCurrentSession();
}
public void insertPersona(Persona persona) {
currentSession().saveOrUpdate(persona);
}
Curso de Spring Framework
public void deletePersona(Persona persona) {
currentSession().delete(persona);
}
public Persona findPersonaById(long idPersona) {
return (Persona) currentSession().get(Persona.class, idPersona);
}
@SuppressWarnings("unchecked")
public List<Persona> findAllPersonas() {
return currentSession().createQuery("from Persona").list();
}
public long contadorPersonas() {
Long
contador
=
(Long)
currentSession().createCriteria(Persona.class).setProjection(Projections.
rowCount()).uniqueResult();
return contador.longValue();
}
public Persona getPersonaByEmail(Persona persona) {
Example personaEjemplo = Example.create(persona);
return
(Persona)
currentSession().createCriteria(Persona.class).add(personaEjemplo).unique
Result();
}
}
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 12. Crear la clase TestPersonaDaoImpl.java
Crear la clase JUnit llamada TestPersonaDaoImpl.java y agregar el
siguiente código:
package test;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNull;
import java.util.List;
import mx.com.gm.capadatos.PersonaDao;
import mx.com.gm.capadatos.domain.Persona;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import
org.springframework.test.context.junit4.SpringJUnit4ClassRunner
;
import
org.springframework.transaction.annotation.Transactional;
@Test
@Transactional
public void deberiaMostrarPersonas() {
try {
System.out.println();
logger.info("Inicio del test deberiaMostrarPersonas");
List<Persona> personas = personaDao.findAllPersonas();
int contadorPersonas = 0;
for (Persona persona : personas) {
logger.info("Persona: " + persona);
contadorPersonas++;
}
// Segun el numero de personas recuperadas, deberia ser el
mismo de
// la tabla
assertEquals(contadorPersonas,
personaDao.contadorPersonas());
logger.info("Fin del test deberiaMostrarPersonas");
} catch (Exception e) {
logger.error("Error JBDC", e);
}
}
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations
=
{"classpath:datasourcetest.xml",
"classpath:applicationContext.xml"})
public class TestPersonaDaoImpl {
private
static
Log
LogFactory.getLog("TestPersonasDaoImpl");
@Autowired
private PersonaDao personaDao;
logger
Curso de Spring Framework
=
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 12. Crear la clase TestPersonaDaoImpl.java (cont)
Anexar el siguiente código a la clase TestPersonaDaoImpl.java:
@Test
@Transactional
public void deberiaEncontrarPersonaPorId() {
try {
System.out.println();
logger.info("Inicio
del
test
deberiaEncontrarPersonaPorId");
int idPersona = 1;
Persona
persona
=
personaDao.findPersonaById(idPersona);
// Segun la persona recuperada, deberia ser la
misma que el registro
// 1
assertEquals("Admin", persona.getNombre());
// Imprimimos todo el objeto
logger.info("Persona recuperada (id=" + idPersona +
"): " + persona);
logger.info("Fin
del
test
deberiaEncontrarPersonaPorId");
} catch (Exception e) {
logger.error("Error JBDC", e);
}
}
@Test
@Transactional
public void deberiaInsertarPersona() {
try {
System.out.println();
logger.info("Inicio del test deberiaInsertarPersona");
// El script de datos tiene 3 registros
assertEquals(3, personaDao.contadorPersonas());
Persona persona = new Persona();
persona.setNombre("Carlos");
persona.setApePaterno("Romero");
persona.setApeMaterno("Esparza");
persona.setEmail("[email protected]");
personaDao.insertPersona(persona);
// Recuperamos a la persona recien insertada por su email
persona = personaDao.getPersonaByEmail(persona);
logger.info("Persona insertada: " + persona);
// Deberia haber ya cuatro personas
assertEquals(4, personaDao.contadorPersonas());
logger.info("Fin del test deberiaInsertarPersona");
} catch (Exception e) {
logger.error("Error JBDC", e);
}
}
Curso de Spring Framework
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 12. Crear la clase TestPersonaDaoImpl.java (cont)
Anexar el siguiente código a la clase TestPersonaDaoImpl.java:
@Test
@Transactional
public void deberiaActualizarPersona() {
try {
System.out.println();
logger.info("Inicio del test deberiaActualizarPersona");
int idPersona = 1;
Persona persona = personaDao.findPersonaById(idPersona);
logger.info("Persona a modificar (id=" + idPersona + "): "
+ persona);
@Test
@Transactional
public void deberiaEliminarPersona() {
try {
System.out.println();
logger.info("Inicio del test deberiaEliminarPersona");
// Buscamos eliminar la persona con id = 2
int idPersona = 2;
Persona persona = personaDao.findPersonaById(idPersona);
logger.info("Persona a eliminar (id=" + idPersona + "): " + persona);
// Actualizamos el nombre y apeMaterno
persona.setNombre("Administrador");
persona.setApeMaterno("Sistemas");
// Eliminamos la persona recuperada
personaDao.deletePersona(persona);
persona = personaDao.findPersonaById(idPersona);
personaDao.updatePersona(persona);
// Deberia de regresar nulo al buscar la persona 2
assertNull(persona);
// Volvemos a leer el usuario
persona = personaDao.findPersonaById(idPersona);
// Imprimimos todo el objeto
logger.info("Nuevo listado de personas:");
List<Persona> personas = personaDao.findAllPersonas();
int contadorPersonas = 0;
for (Persona persona2 : personas) {
logger.info("Persona: " + persona2);
contadorPersonas++;
}
// Segun el numero de personas recuperadas, deberia ser el mismo de
// la tabla
assertEquals(contadorPersonas, personaDao.contadorPersonas());
logger.info("Fin del test deberiaEliminarPersona");
System.out.println();
} catch (Exception e) {
logger.error("Error JBDC", e);
}
// Segun la persona recuperada, deberia ser la misma que el
registro
// 1
assertEquals("Administrador", persona.getNombre());
// Imprimimos todo el objeto
logger.info("Persona modificada (id=" + idPersona + "): " +
persona);
logger.info("Fin del test deberiaActualizarPersona");
} catch (Exception e) {
logger.error("Error JBDC", e);
}
}
}
}
Curso de Spring Framework
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 13: Ejecutar la Prueba
•
Ejecutamos la clase TestPersonaDaoImpl.java como una prueba de
JUnit y observamos el siguiente resultado:
Curso de Spring Framework
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 14. Agregar la interface PersonaService
Agregamos la siguiente interface PersonaService.java:
package mx.com.gm.capaservicio;
import java.util.List;
import mx.com.gm.capadatos.domain.Persona;
public interface PersonaService {
public List<Persona> listarPersonas();
public Persona recuperarPersona(Persona persona);
public void agregarPersona(Persona persona);
public void modificarPersona(Persona persona);
public void eliminarPersona(Persona persona);
}
Curso de Spring Framework
30
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 15. Agregar la clase PersonaServiceImpl
Agregar la clase PersonaServiceImpl.java:
package mx.com.gm.capaservicio;
import
import
import
import
import
import
import
java.util.List;
mx.com.gm.capadatos.PersonaDao;
mx.com.gm.capadatos.domain.Persona;
org.springframework.beans.factory.annotation.Autowired;
org.springframework.stereotype.Service;
org.springframework.transaction.annotation.Propagation;
org.springframework.transaction.annotation.Transactional;
@Service("personaService")
@Transactional
public class PersonaServiceImpl implements PersonaService {
@Autowired
private PersonaDao personaDao;
public List<Persona> listarPersonas() {
return personaDao.findAllPersonas();
}
public Persona recuperarPersona(Persona persona) {
return personaDao.findPersonaById(persona.getIdPersona());
}
public void agregarPersona(Persona persona) {
personaDao.insertPersona(persona);
}
public void modificarPersona(Persona persona) {
personaDao.updatePersona(persona);
}
public void eliminarPersona(Persona persona) {
personaDao.deletePersona(persona);
}
}
Curso de Spring Framework
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 16. Crear la clase TestPersonaServiceImpl.java
Crear la clase JUnit llamada TestPersonaServiceImpl.java y agregar el
siguiente código:
package test;
import static org.junit.Assert.assertEquals;
import java.util.List;
import mx.com.gm.capadatos.PersonaDao;
import mx.com.gm.capadatos.domain.Persona;
import mx.com.gm.capaservicio.PersonaService;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import
org.springframework.test.context.junit4.SpringJUnit4ClassRunner
;
import
org.springframework.transaction.annotation.Transactional;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations
=
{"classpath:datasourcetest.xml",
"classpath:applicationContext.xml"})
public class TestPersonaServiceImpl {
private
static
Log
LogFactory.getLog("TestPersonasServiceImpl");
@Autowired
private PersonaService personaService;
@Autowired
private PersonaDao personaDao;
logger
Curso de Spring Framework
=
@Test
@Transactional
public void deberiaMostrarPersonas() {
try {
System.out.println();
logger.info("Inicio del test deberiaMostrarPersonas");
int contadorPersonas = this.desplegarPersonas();
// Segun el numero de personas recuperadas,
// deberia ser el mismo de la tabla
assertEquals(contadorPersonas,
personaDao.contadorPersonas());
logger.info("Fin del test deberiaMostrarPersonas");
System.out.println();
} catch (Exception e) {
logger.error("Error Servicio", e);
}
}
private int desplegarPersonas() {
List<Persona> personas = personaService.listarPersonas();
int contadorPersonas = 0;
for (Persona persona : personas) {
logger.info("Persona: " + persona);
contadorPersonas++;
}
return contadorPersonas;
}
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 16. Crear la clase TestPersonaServiceImpl.java (cont)
Anexar el siguiente código a la clase TestPersonaServiceImpl.java:
@Test
@Transactional
public void testOperaciones() {
try {
System.out.println();
logger.info("Inicio del test testOperaciones");
Persona persona1 = new Persona();
@Test
@Transactional
public void testCompruebaOperaciones() {
try {
System.out.println();
logger.info("Fin del test testCompruebaOperaciones");
// Deberia haber 3 personas
// El caso anterior aplicó rollBack por
// el uso de AbstractTransactionalJUnit4SpringContextTests
//persona1.setNombre("Andrea11111111111111111111111111111111111
11111111111111111");
persona1.setNombre("Andrea");
persona1.setApePaterno("Lara");
persona1.setEmail("[email protected]");
personaService.agregarPersona(persona1);
assertEquals(3, personaDao.contadorPersonas());
this.desplegarPersonas();
logger.info("Fin del test testCompruebaOperaciones");
System.out.println();
} catch (Exception e) {
logger.error("Error Servicio", e);
}
// Deberia haber 4 personas
assertEquals(4, personaDao.contadorPersonas());
// Actualizamos la persona con id=1
Persona
persona2
personaService.recuperarPersona(new Persona(1));
persona2.setNombre("Administrador");
personaService.modificarPersona(persona2);
}
=
}
this.desplegarPersonas();
logger.info("Fin del test testOperaciones");
System.out.println();
} catch (Exception e) {
logger.error("Error Servicio", e);
}
}
Curso de Spring Framework
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Ejercicio: Integración Spring y Hibernate
Paso 17: Ejecutar la Prueba
•
Ejecutamos la clase TestPersonaServiceImpl.java como una prueba
de JUnit y observamos el siguiente resultado:
Curso de Spring Framework
© Derechos
© Derechos
Reservados
Reservados
GlobalGlobal
Mentoring
Mentoring
2011 2012
Curso de Spring Framework
www.globalmentoring.com.mx
Pasión por la tecnología Java
© Derechos Reservados Global Mentoring 2012