Ejercicio 13€¦ · Ejercicio: Spring JDBCv2. Ejercicio 13. SPRING JDBC VERSIÓN2. Objetivo del Ejercicio. Ejercicio: Spring JDBCv2. El objetivo del ejercicio es agregar los casos

Ejercicio: Spring JDBC v2

Ejercicio 13SPRING JDBC VERSIÓN 2

Ejercicio: Spring JDBC v2Objetivo del Ejercicio

El objetivo del ejercicio es agregar los casos de alta, baja, cambios yselección de datos de la tabla personas a nuestro proyecto Spring JDBC.Al finalizar deberemos ver la siguiente salida:

Paso 1. Creación archivo applicationContext.xml

Crear el archivo applicationContext.xml (es de tipo SpringBeanDefinition file) y depositarlo en src/main/resources :

Ejercicio: Spring JDBC v2

Agregar los namespaces de beans y context al archivo applicationContext.xml:

Paso 1. Creación archivo applicationContext.xml (cont)

Paso 1. Creación archivo applicationContext.xml (cont)

Agregar el siguiente contenido al archivo applicationContext.xml:

<context:component-scan base-package="mx.com.gm.jdbc" />

Paso 2. Agregar la clase Persona

package es.upv.lemus.jdbc;public class Persona {

private Long idPersona;private String nombre;private String apellidoPaterno;private String apellidoMaterno;private String email;

public Persona() {}public Persona(long idPersona, String nombre, String apellidoPaterno, String

apellidoMaterno, String email) {super();this.idPersona = idPersona;this.nombre = nombre;this.apellidoPaterno = apellidoPaterno;this.apellidoMaterno = apellidoMaterno;this.email = email;

}}

Paso 3. Agregar la clase PersonaRowMapper

Agregamos la siguiente clase PersonaRowMapper.java:package es.upv.lemus.jdbc;import java.sql.ResultSet;import java.sql.SQLException;import org.springframework.jdbc.core.RowMapper;

public class PersonaRowMapper implements RowMapper<Persona> {

@Overridepublic Persona mapRow(ResultSet rs, int rowNum) throws SQLException {

Persona persona = new Persona();persona.setIdPersona(rs.getLong("id_persona"));persona.setNombre(rs.getString("nombre"));persona.setApellidoPaterno(rs.getString("apellido_paterno"));persona.setApellidoMaterno(rs.getString("apellido_materno"));persona.setEmail(rs.getString("email"));return persona;

}}

Paso 4. Agregar la interface PersonaDao

Agregamos la siguiente interfacePersonaDao.java:

package es.upv.lemus.jdbc;

import java.util.List;

public interface PersonaDao {void insertPersona(Persona persona);void updatePersona(Persona persona);void deletePersona(Persona persona);Persona findPersonaById(long idPersona);List<Persona> findAllPersonas();int contadorPersonasPorNombre(Persona persona);int contadorPersonas();Persona getPersonaByEmail(Persona persona);

}

Paso 5. Agregar la clase PersonaDaoImpl

package es.upv.lemus.jdbc;


public class PersonaDaoImpl implements PersonaDao{@Overridepublic void insertPersona(Persona persona) {}@Overridepublic void updatePersona(Persona persona) {}@Overridepublic void deletePersona(Persona persona) {}@Overridepublic Persona findPersonaById(long idPersona) {

return null;}

@Overridepublic List<Persona> findAllPersonas() {

return null;}@Overridepublic int contadorPersonasPorNombre(Persona persona) {

return 0;}@Overridepublic int contadorPersonas() {

return 0;}@Overridepublic Persona getPersonaByEmail(Persona persona) {

return null;}

}

Paso 6. Agregar código a la clase PersonaDaoImpl

Agregar las siguientes definiciones a la clase PersonaDaoImpl.java:private NamedParameterJdbcTemplate namedParameterJdbcTemplate;

private JdbcTemplate jdbcTemplate;

@Autowiredpublic void setDataSource(DataSource dataSource) {

// No es común que se utilicen las 2 plantillas, sin embargo si es posible// La diferencia es el manejo de parámetros por indice o por nombre this.jdbcTemplate = new JdbcTemplate(dataSource);

this.namedParameterJdbcTemplate = new NamedParameterJdbcTemplate(dataSource);}

// Query con Parametros por nombre// Omitimos la PK ya que es autoincrementableprivate static final String SQL_INSERT_PERSONA = "INSERT INTO PERSONA (nombre, ape_paterno, ape_materno, email) values (:nombre,

:apePaterno, :apeMaterno, :email)";

// Query con Parametros por indice// private static final String SQL_INSERT_PERSONA =// "insert into persona (username, password, fullname, email, update_by_email) values (?, ?, ?, ?, ?)";// Parametros por nombre

private static final String SQL_UPDATE_PERSONA = "UPDATE PERSONA set nombre = :nombre, ape_paterno = :apePaterno, ape_materno =:apeMaterno, email = :email WHERE id_persona = :idPersona";

private static final String SQL_DELETE_PERSONA = "DELETE FROM PERSONA WHERE id_persona = :idPersona";

private static final String SQL_SELECT_PERSONA = "SELECT id_persona, nombre, ape_paterno, ape_materno, email FROM PERSONA";

// Parametros por indiceprivate static final String SQL_SELECT_PERSONA_BY_ID = SQL_SELECT_PERSONA + " WHERE id_persona = ?";

Paso 7. Código del método findAllPersonas()

Agregar el siguiente código al método findAllPersonas() de la clase PersonaDaoImpl.java:

//Esta consulta es equivalente//String sql = "SELECT * FROM PERSONA";RowMapper<Persona> personaRowMapper = ParameterizedBeanPropertyRowMapper.newInstance(Persona.class); return this.jdbcTemplate.query(SQL_SELECT_PERSONA, personaRowMapper);

Paso 8. Código del método contadorPersonas()

Agregar el siguiente código al método contadorPersonas() de la clase PersonaDaoImpl.java:

String sql = "SELECT count(*) FROM PERSONA";

return this.jdbcTemplate.queryForInt(sql);

// Esta es otra opcion si no tuvieramos jdbcTemplate// return this.namedParameterJdbcTemplate.getJdbcOperations().queryForInt(sql);

Paso 9. Crear la clase TestPersonasDaoImpl.java

Crear la clase JUnit llamada TestPersonasDaoImpl.java y agregar el siguiente código:

package test;

import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNull;


import mx.com.gm.jdbc.Persona; import mx.com.gm.jdbc.PersonaDao;

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;

@RunWith(SpringJUnit4ClassRunner.class)@ContextConfiguration(locations = {"classpath:datasource-test.xml",

"classpath:applicationContext.xml"})public class TestPersonasDaoImpl {

private static Log logger = LogFactory.getLog("TestPersonasDaoImpl");

@Autowiredprivate PersonaDao personaDao;

}

Paso 10. Agregar el método a TestPersonasDaoImpl.java

Agregar el método deberiaMostrarPersonas a la clase TestPersonasDaoImpl.java:

@Testpublic 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);}

}

Paso 11: Ejecutar la Prueba

• Ejecutamos la clase TestPersonasDaoImpl.java como una pruebade JUnit y observamos el siguiente resultado:

Paso 12. Código del método contadorPersonasPorNombre()

Agregar el siguiente código al método contadorPersonasPorNombre() de la clase PersonaDaoImpl.java:

String sql = "SELECT count(*) FROM PERSONA WHERE nombre = :nombre";

// Permite evitar crear un MAP de parametros y utilizar directamente el objeto persona// los atributos que coincidan con el nombre de los parametros por nombre del query// seran utilizados y proporcionados como atributos al querySqlParameterSource namedParameters = new BeanPropertySqlParameterSource(persona);

// Unicamente retorna un valor el metodo queryForIntreturn this.namedParameterJdbcTemplate.queryForInt(sql, namedParameters);


Agregar el método testContarPersonasPorNombre a la clase TestPersonasDaoImpl.java:

@Testpublic void testContarPersonasPorNombre() {

try {System.out.println();logger.info("Inicio del test Contar Personas por nombre");

String nombre = "Juan";Persona personaEjemplo = new Persona();personaEjemplo.setNombre(nombre);

int noPersonasEncontradas = personaDao.contadorPersonasPorNombre(personaEjemplo);

logger.info("Numero de personas encontradas por nombre '" + nombre + "': " + noPersonasEncontradas);

assertEquals(2, noPersonasEncontradas);

logger.info("Fin del test Contar Personas por nombre");

} catch (Exception e) { logger.error("Error JBDC", e);

}}



Paso 15. Código del método findPersonaById()

Persona persona = null;

try {

//Utilizamos la clase PersonaRowMapper

persona = jdbcTemplate.queryForObject(SQL_SELECT_PERSONA_BY_ID, new PersonaRowMapper(), idPersona);

} catch (EmptyResultDataAccessException e) {

persona = null;

}

return persona;

// Esta es otra forma sin utilizar la clase PersonaRowMapper

// BeanPropertyRowMapper<Persona> personaRowMapper = BeanPropertyRowMapper.newInstance(Persona.class);

// return jdbcTemplate.queryForObject(SQL_SELECT_PERSONA_BY_ID, personaRowMapper, idPersona);

Agregar el siguiente código al método findPersonaById() de la clase PersonaDaoImpl.java:


Agregar el método deberiaEncontrarPersonaPorId a la clase TestPersonasDaoImpl.java:

@Testpublic 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 objetologger.info("Persona recuperada (id=" + idPersona + "): " + persona);

logger.info("Fin del test deberiaEncontrarPersonaPorId");} catch (Exception e) { logger.error("Error JBDC",

e);}

}



Paso 18. Código del método getPersonaByEmail()

Agregar el siguiente código al método getPersonaByEmail() de la clase PersonaDaoImpl.java:

String sql = "SELECT * FROM PERSONA WHERE email = :email";SqlParameterSource namedParameters = new BeanPropertySqlParameterSource(persona);

//Si no se tiene el objeto RowMapper, se puede utilizar la siguiente linea para crear este objeto//RowMapper<Persona> personaRowMapper = ParameterizedBeanPropertyRowMapper.newInstance(Persona.class);return this.namedParameterJdbcTemplate.queryForObject(sql, namedParameters, new PersonaRowMapper());

Paso 19. Código del método insertPersona()

Agregar el siguiente código al método insertPersona() de la clase PersonaDaoImpl.java:

SqlParameterSource parameterSource = new BeanPropertySqlParameterSource(persona); this.namedParameterJdbcTemplate.update(SQL_INSERT_PERSONA, parameterSource);


Agregar el método deberiaInsertarPersona a la clase TestPersonasDaoImpl.java:

@Testpublic 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) {


}

mailto:[email protected]



Paso 22. Código del método updatePersona()

Agregar el siguiente código al método updatePersona() de la clase PersonaDaoImpl.java:

SqlParameterSource parameterSource = new BeanPropertySqlParameterSource(persona); this.namedParameterJdbcTemplate.update(SQL_UPDATE_PERSONA, parameterSource);


Agregar el métododebería ActualizarPersona a laclaseTestPersonasDaoImpl.java:

@Test//@Ignorepublic 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);

//Actualizamos el nombre y apeMaterno persona.setNombre("Administrador"); persona.setApeMaterno("Sistemas");

personaDao.updatePersona(persona);//Volvemos a leer el usuariopersona = personaDao.findPersonaById(idPersona);//Segun la persona recuperada, deberia ser la misma que el registro 1 assertEquals("Administrador", persona.getNombre());

//Imprimimos todo el objetologger.info("Persona modificada (id=" + idPersona + "): " + persona);

logger.info("Fin del test deberiaActualizarPersona");} catch (Exception e) {


}



Paso 25. Código del método deletePersona()

Agregar el siguiente código al método deletePersona() de la clase PersonaDaoImpl.java:

SqlParameterSource parameterSource = new BeanPropertySqlParameterSource(persona); this.namedParameterJdbcTemplate.update(SQL_DELETE_PERSONA, parameterSource);

Agregar el método deberiaEliminarPersona a la claseTestPersonasDaoImpl.java:

@Testpublic 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);

//Eliminamos la persona recuperada personaDao.deletePersona(persona);

persona = personaDao.findPersonaById(idPersona);

//Deberia de regresar nulo al buscar la persona 2 assertNull(persona);

//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);

}}



Ejecutamos la clase TestPersonasDaoImpl.java como una pruebade JUnit y observamos el siguiente resultado:

Ejercicio 13€¦ · Ejercicio: Spring JDBCv2. Ejercicio 13. SPRING JDBC VERSIÓN2. Objetivo del Ejercicio. Ejercicio: Spring JDBCv2. El objetivo del ejercicio es agregar los casos

Documents