SPRING JDBCCurso: Programación orientada a objetos
Facultad: Ing. Mecánica, Aeronáutica, automotriz y Software
Especialidad: Ingeniería de Software
Integrantes:
Avila Herrera MelissaPariona Felices RobertoSánchez Reyes Susana
2010
Spring Core (Inversión del control (IoC) / Inyección de
dependencias (DI)) Spring AOP (Programación orientada a aspectos) Spring JDBC (Acceso a datos) Spring MVC (desarrollo Web según el patrón MVC) Spring Remoting (distribución) Spring Transaction Abstraction (Gestión de transacciones) •Otros: Spring TestContext (pruebas), Spring JMX (gestión), Spring Security (seguridad), Spring Web Flow (control de flujos en aplicaciones Web)
Módulos principales de Spring
El módulo de JDBCEste módulo contiene varias características muy
útiles, pero la más poderosa es el JdbcTemplate.
Spring JDBC (Acceso a
datos)
Tomemos como ejemplo el ya clásico ciclo para leer datos de una tabla:Obtener un DataSource de algún lugar, ya sea por JNDI en un contenedor, o bien creándolo por código en aplicaciones independientes.Obtener una conexión a la base de datos, por medio del DataSource.Crear un PreparedStatement con el query a realizar.
Ejemplo clásico
Si el query trae parámetros, configurarlos uno por uno.
Ejecutar el query para obtener un ResultSet.Recorrer el ResultSet, haciendo algo con los
objetos; un ejemplo simple es crear una instancia de alguna clase de Value Object y ponerle los valores que vienen en la tupla actual, y luego poner ese Value Object en una lista.
Cerrar el ResultSet.Cerrar el PreparedStatement.Cerrar la conexión.
Ejemplo clásico
Ejemplo
• Todo lo anterior tiene que estar dentro de uno o varios try-catch por si ocurre alguna excepción, cerrar los objetos que tengamos.
• Es algo muy tedioso de programar, sobre todo cuando se quiere obtener una lista corta de objetos que se van a presentar en alguna página web o en una interfaz y dichos objetos pueden ser simples mapas con los nombres de las columnas como llaves.
Conclusión
Jerarquía de paquetesEl framework de abstracción JDBC de Spring consiste en cuatro diferentes paquetes core, dataSource, object y support.
Spring-Jdbc
El paquete org.springframework.jdbc.core contiene la clase JdbcTemplate y varias interfaces para callback,
El paquete org.springframework.datasource contiene clases de utilería para acceso fácil a los DataSource, y varias implementaciones de DataSource que pueden ser utilizadas para pruebas o para correr código JDBC sin modificar fuera de un contenedor J2EE
Spring-Jdbc
Jerarquía de paquetes
El paquete org.springframework.jdbc.object contiene clases que representan las consultas (queries) a los RDBMS, las actualizaciones (updates) y los procedimientos almacenados (stored procedures) en objetos reusables .
Y por último, el paquete org.springframework.jdbc.support es donde se encuentra la traducción de excepciones SQLException así como algunas clases de utilería. Las excepciones arrojadas durante el procesamiento de JDBC son traducidas a excepciones definidas en el paquete org.springframework.dao.
Spring-Jdbc
Usando las clases principales de JDBC para controlar el procesamiento de JDBC y el manejo de errores.•JdbcTemplate:Se encarga de ejecutar las funciones comúnes de JDBC como la creación y ejecución de statements. Esta clase ejecuta los queries (consultas) SQL, las actualizaciones (updates) y las llamadas a procedimientos almacenados (stored procedures), realizando la iteración sobre ResultSets y extrayendo los parametros retornados. También captura las excepciones de JDBC y las traduce en una jerarquía de excepciones más genérica e informativa definida en el paquete org.springframework.dao
JdbcTemplate (Ejemplos)Consultar por un String
Consultar y rellenar un simple objeto de dominio.
Spring-Jdbc
String surname = (String) this.jdbcTemplate.queryForObject( "select surname from t_actor where id = ?", new Object[]{new Long(1212)}, String.class);
String surname = (String) this.jdbcTemplate.queryForObject( "select surname from t_actor where id = ?", new Object[]{new Long(1212)}, String.class);
Actor actor = (Actor) this.jdbcTemplate.queryForObject( "select first_name, surname from t_actor where id = ?", new Object[]{new Long(1212)}, new RowMapper() { public Object mapRow(ResultSet rs, int rowNum) throws SQLException { Actor actor = new Actor(); actor.setFirstName(rs.getString("first_name")); actor.setSurname(rs.getString("surname")); return actor; } });
Actor actor = (Actor) this.jdbcTemplate.queryForObject( "select first_name, surname from t_actor where id = ?", new Object[]{new Long(1212)}, new RowMapper() { public Object mapRow(ResultSet rs, int rowNum) throws SQLException { Actor actor = new Actor(); actor.setFirstName(rs.getString("first_name")); actor.setSurname(rs.getString("surname")); return actor; } });
• NamedParameterJdbcTemplate:La clase NamedParameterJdbcTemplate añade soporte a los
statements JDBC mediante parámetros nombrados (a diferencia de los statements JDBC que usan solo argumentos '?' para su sustitución). Ejem:
Spring-Jdbc
public int countOfActorsByFirstName(String firstName) {
String sql = "select count(0) from T_ACTOR where first_name = :first_name";
SqlParameterSource namedParameters = new MapSqlParameterSource("first_name", firstName);
return namedParameterJdbcTemplate.queryForInt(sql, namedParameters); }
public int countOfActorsByFirstName(String firstName) {
String sql = "select count(0) from T_ACTOR where first_name = :first_name";
SqlParameterSource namedParameters = new MapSqlParameterSource("first_name", firstName);
return namedParameterJdbcTemplate.queryForInt(sql, namedParameters); }
• SimpleJdbcTemplate: La clase SimpleJdbcTemplate es un envolvente de un JdbcTemplate clásico que toma ventaja de las características de Java 5 como son los argumentos variables.
Spring-Jdbc
public Actor findActor(long id) {
String sql = "select id, first_name, last_name from T_ACTOR where id = ?"; ParameterizedRowMapper<Actor> mapper = new ParameterizedRowMapper<Actor>() {
public Actor mapRow(ResultSet rs, int rowNum) throws SQLException { Actor actor = new Actor(); actor.setId(rs.getLong("id")); actor.setFirstName(rs.getString("first_name")); actor.setLastName(rs.getString("last_name")); return actor; } };
return this.simpleJdbcTemplate.queryForObject(sql, mapper, id); }
public Actor findActor(long id) {
String sql = "select id, first_name, last_name from T_ACTOR where id = ?"; ParameterizedRowMapper<Actor> mapper = new ParameterizedRowMapper<Actor>() {
public Actor mapRow(ResultSet rs, int rowNum) throws SQLException { Actor actor = new Actor(); actor.setId(rs.getLong("id")); actor.setFirstName(rs.getString("first_name")); actor.setLastName(rs.getString("last_name")); return actor; } };
return this.simpleJdbcTemplate.queryForObject(sql, mapper, id); }
DataSourcePara poder trabajar con datos de una base de datos, uno
necesita obtener una conexión a la misma. La manera en que Spring hace esto es mediante un DataSource. Un DataSource es parte de la especificación JDBC y puede verse como una fábrica de conexiones. Permite al contenedor o al framework ocultar el pool de conexiones y el manejo de transaciones del código de aplicación.
Spring-Jdbc
DataSourceLa clase DriverManagerDataSource trabaja de la misma manera en que usualmente se obtiene una conexión JDBC. Se tiene que especificar el nombre calificado de la clase del driver JDBC que se va a utilizar para que el DriverManager la cargue. Posteriormente se provee una url de conexión que varía dependiendo de los drivers JDBC. Uno tiene que consultar la documentación del driver para encontrar el valor correcto a usar. Finalmente uno provee el nombre de usuario y la contraseña usadas para conectarse a la base de datos. Ejemplo:
Spring-Jdbc
• DataSource
Spring-Jdbc
public static void crearDataSource() {
DriverManagerDataSource ds = new DriverManagerDataSource(); ds.setDriverClassName("oracle.jdbc.driver.OracleDriver"); ds.setUrl("jdbc:oracle:thin:@localhost:1521:XE"); ds.setUsername("demo02"); ds.setPassword("demo02"); template = new JdbcTemplate(ds); }
public static void crearDataSource() {
DriverManagerDataSource ds = new DriverManagerDataSource(); ds.setDriverClassName("oracle.jdbc.driver.OracleDriver"); ds.setUrl("jdbc:oracle:thin:@localhost:1521:XE"); ds.setUsername("demo02"); ds.setPassword("demo02"); template = new JdbcTemplate(ds); }
Spring-Jdbc
SQLExceptionTranslatorEs una interface para ser implementado por las clases,
puede traducir entre SQLExceptions y las excepciones de Spring derivadas de org.springframework.org.dao.DataAccessException.
Las implementaciones pueden ser genéricas (por ejemplo, mediante el uso de códigos de SQLState para JDBC) o propietarias (por ejemlo, usando códigos de error de Oracle) para mayor precisión.
Aspectos a mejorar en el ejemplo: SQLException: excepción genérica Captura de excepciones para no hacer nada ¿Cómo lo mejora Spring?
Conclusión
Mapeo de SQLException a excepciones específicasSubclases de org.springframework.dao.DataAccessException
Uso de unchecked exceptionsDataAccessException es una subclase de
java.lang.RuntimeException Se pueden capturar si se desea, pero no es obligatorio
Automatiza la gestión de conexionesSe declara una fuente de datos y Spring la gestiona No se accede directamente a las conexiones, sino que se
utiliza un JdbcTemplate Usualmente un org.springframework.jdbc.core.JdbcTemplate
Mapeo de SQLException a excepciones específicasSubclases de org.springframework.dao.DataAccessException
Uso de unchecked exceptionsDataAccessException es una subclase de
java.lang.RuntimeException Se pueden capturar si se desea, pero no es obligatorio
Automatiza la gestión de conexionesSe declara una fuente de datos y Spring la gestiona No se accede directamente a las conexiones, sino que se
utiliza un JdbcTemplate Usualmente un org.springframework.jdbc.core.JdbcTemplate
El Wikihttp://spring-jdbc.wikispaces.com/
http://www.xmind.net/share/lshimokawa/spring-jdbc/
http://www.comunidadjava.org/?q=node/421 http://www.javadocexamples.com/java_source
/org/springframework/prospring/ticket/db/SampleBatchTests.java.html
http://www.comunidadjava.org/?q=node/421 http://chuwiki.chuidiang.org/index.php?
title=Ejemplo_sencillo_con_SpringFramework_DAO
Bibliografía
Spring JDBC ofrece un objeto llamado JdbcTemplate (El equivalente Spring a la clase Connection ), el cual se configura con un DataSource Entonces el componente que necesita obtener estos datos (por ejemplo un DAO) puede simplemente tener una propiedad llamada jdbcTemplate, por ejemplo:
Primero se obtiene el equivalente Spring a una conexión con base de datos. Aunque hay muchas formas de hacerlo, incluyendo ficheros de configuración, una forma más inmediata, directamente en código seria :
Spring-Jdbc
Ejemplo
Una vez que se obtiene la conexión, con el método query() de JdbcTemplate podemos hacer la consulta. A este método: Le pasamos un String con la sentencia SQL de select. Le pasamos una clase RowMapper encargada de: instanciar una clase Persona, leer una fila del ResultSet resultante y devolver dicha clase Persona. Devuelve una Collection rellena de Persona.
Ejemplo
El JdbcTemplate tiene varios métodos para leer datos, por ejemplo para obtener un solo dato o un solo registro, así como para modificar (INSERT, UPDATE, DELETE).Lo que el JdbcTemplate hace es todo lo que se menciono antes: Abre una conexión, crea un PreparedStatement con el SQL y los parámetros que se le da, lee los datos y los pone en una lista, cierra todo y los devuelve.
Spring-Jdbc
Además, cualquier excepción de SQL que ocurra la convierte a un DataAccessException (hay toda una jerarquía de clases) pero es de tipo RuntimeException, así que se puede incluso quitar el try-catch y dejar que quien invoque el método se encargue de lidiar con cualquier excepción.
Spring-Jdbc
Los paquetes de Spring • org.springframework.jdbc y• org.springframework.core.simple
Es donde vienen la mayoría de las clases que intervienen en esto, aunque como pueden ver, tienen que usar solamente una o dos, pero es importante conocer las excepciones que pueden arrojarse y esas vienen en org.springframework.dao.
Spring-Jdbc