Download Diapositiva 1 - Spring-JDBC

SPRING JDBC
Curso: Programación orientada a objetos
Facultad: Ing. Mecánica, Aeronáutica, automotriz y
Software
Especialidad: Ingeniería de Software
Profesor : Ing. Gustavo Coronel
Integrantes:
 Avila Herrera Melissa
 Pariona Felices Roberto
 Sánchez Reyes Susana
2010
JDBC
INTRODUCCION
Características
• JDBC es una biblioteca de clases e interfaces que
permite la conexión con base de datos utilizando
Java.
• La biblioteca JDBC dispone de una interfaz para
ejecutar instrucciones SQL que ofrece una
funcionalidad básica para el acceso a datos. las
clases e interfaces que componen el API de JDBC
son conceptos comunes de acceso a base de datos
para todas las bases de datos.
• JDBC se diseño como una interfaz de programación
de aplicaciones (API) orientado a objetos para
acceder (consultas) a bases de datos y es un
estándar.
• El API JDBC se diseño como una interfaz para
ejecutar consultas SQL y admite todos los dialectos
de SQL.
Conexión a la Base de Datos
Mecanismo JDBC
El funcionamiento práctico de JDBC obliga a
conocer los siguientes 5 procedimientos, a saber:
1.Establecer conexión.
2.Crear sentencia.
3.Ejecutar sentencia.
4.Procesar resultados.
5.Cerrar.
1.- Establecer la conexión
Tiene dos operaciones básicas.
a) DriverManager
b) Connection
a.- DriverManager
La clase DriverManager es la capa gestora de
JDBC, trabajando entre el usuario y el
controlador (driver). Se encarga de seguir el
rastro de los controladores que están
disponibles y establecer la conexión entre la
base de datos y el controlador apropiado.
Para trabajar con el Puente
JDBC-ODBC:
try {
Class.forName(“sun.jdbc.odbc.JdbcOdbcDriv
er”);
} catch (ClassNotFoundException cnfe) {
System.err.println(“No ha podido
encontrarse el
driver
de ODBC.”);
}
Para trabajar con MySQL:
try {
Class.forName(“com.mysql.jdbc.Driver”);
} catch (ClassNotFoundException cnfe) {
System.err.println(“No ha podido encontrarse el
driver de MySQL”);
}
Para trabajar con postgreSQL:
try {
Class.forName(“org.postgresql.Driver”);
} catch (ClassNotFoundException cnfe) {
System.err.println(“No ha podido encontrarse el
driver de postgreSQL”);
}
Para trabajar con Oracle:
try {
Class.forName(“oracle.jdbc.driver.Oracl
eDriver”);
} catch (ClassNotFoundException cnfe) {
System.err.println(“No ha podido
encontrarse el
driver
de Oracle”);
}
b.- Connection
Un objeto Connection representa una conexión a una
base de datos. Una sesión con una conexión incluye las
sentencias SQL que son ejecutadas y los resultados
que son devueltos a través de dicha conexión. Una
misma aplicación puede tener una o más conexiones
con una sola base de datos o puede tener conexiones
con varias bases de datos diferentes.
La forma estándar de establecer una conexión con una
base
de
datos
es
llamando
al
método
DriverManager.getConnection. Este método toma
como parámetro una cadena de caracteres que contiene
una URL. La clase DriverManage trata de localizar el
driver que pueda conectar con la base de datos
representada por esa URL.
Para trabajar con el Puente JDBC-ODBC con MsAccess (Windows
XP):
import java.sql.*;
public static void conexion ( ) throws Exception {
try {
// Carga el driver
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
// Define la cadena de conexión
String sourceURL = "jdbc:odbc:DSNSistema";
// Crea el objeto connection a través de DriverManager
Connection con = DriverManager.getConnection(sourceURL);
System.out.println("La conexion establecida es: "+ con);
} catch(ClassNotFoundException cnfe) {
System.err.println(cnfe);
} catch(SQLException sqle) {
System.err.println(sqle);
};
};
Para trabajar con MySQL.
import java.sql.*;
public static void conexion ( ) throws Exception {
try {
// Carga el driver
Class.forName("com.mysql.jdbc.Driver”);
// Define la cadena de conexión
String sourceURL = "jdbc:mysql://localhost/bd_pruebas”,
usuario, password";
// Crea el objeto connection a través de DriverManager
Connection con = DriverManager.getConnection(sourceURL);
System.out.println("La conexion establecida es: "+ con);
} catch(ClassNotFoundException cnfe) {
System.err.println(cnfe);
} catch(SQLException sqle) {
System.err.println(sqle);
};
};
Para trabajar con postgreSQL:
import java.sql.*;
public static void conexion ( ) throws Exception {
try {
// Carga el driver
Class.forName(“org.postgresql.Driver”);
// Define la cadena de conexión
String database = “Bd”;
String username = “admin”;
String password = “admin”;
String sourceURL = "jdbc:postgresql:”+database, username, password";
// Crea el objeto connection a través de DriverManager
Connection con = DriverManager.getConnection(sourceURL);
System.out.println("La conexion establecida es: "+ con);
} catch(ClassNotFoundException cnfe) {
System.err.println(cnfe);
} catch(SQLException sqle) {
System.err.println(sqle);
};
};
Para trabajar con Oacle XE (versión 10g).
import java.sql.*;
public static void conexion ( ) throws Exception {
try {
// Carga el driver
Class.forName("oracle.jdbc.driver.OracleDriver");
// Define la cadena de conexión
String sourceURL =“jdbc:oracle:thin:@localhost:1521:orcl”, “scott”,
“tiger”;
// Crea el objeto connection a través de DriverManager
Connection con = DriverManager.getConnection(sourceURL);
System.out.println("La conexion establecida es: "+ con);
} catch(ClassNotFoundException cnfe) {
System.err.println(cnfe);
} catch(SQLException sqle) {
System.err.println(sqle);
};
};
2.- Crear sentencia.
Statement
Un objeto Statement se usa para enviar sentencias SQL a una
base de datos.
Statement senten = con.createStatement();
En realidad el método createStatement
debe llevar dos parámetros enteros que
especifican el comportamiento del objeto
ResultSet u hoja de datos
public Statement
createStatement(int resultSetType,
int resultSetConcurrency) throws
SQLException
PreparedStatement
Un objeto PreparedStatement se usa para sentencias
SQL que toman uno o más parámetros como argumentos
de entrada (parámetros IN).
PreparedStatement tiene un grupo de métodos que fijan
los valores de los parámetros IN, los cuales son enviados
a la base de datos cuando se procesa la sentencia SQL.
PreparedStatement updateSales =
con.prepareStatement (
“UPDATE productos SET ventas = ? WHERE COD =
? ” );
3.-Ejecutar sentencia.
La sentencia SQL se ejecuta a través de los
métodos
executeQuery
o
executeUpdate
dependiendo de que no exista o exista modificación
de los datos respectivamente.
1. Consulta – executeQuery() Es una operación SELECT
que devuelve el resultado de una consulta
encapsulado en un objeto de tipo ResultSet
2. Actualización – executeUpdate() Es una operación
INSERT, UPDATE o DELETE que realiza una
modificación sobre la base de datos
ResultSet resul = senten.executeQuery ( “
SELECT a, b, c FROM Table2″);
Ó
Int filas_afectadas =
senten.executeUpdate(“UPDATE
personas
set nombre=’Marina’ where id=4″);
4.-Procesar resultados.
ResultSet
Un ResultSet contiene todos los registros (filas)
que satisfacen las condiciones impuestas en una
sentencia SQL y proporciona acceso a los datos
en dichos registros.
El método ResultSet.next() se usa para moverse al
siguiente registro del ResultSet, haciendo el
siguiente registro el registro actual.
5.-Cerrar.
Es necesario cerrar adecuadamente la sentencia el ResultSet y
la conexión.
• senten.close();
• resul.close();
• con.close();
Conviene recordar:
El mecanismo de funcionamiento básico JDBC,
• Establecer conexión:
Class.forName(“…”) y DriverManager.getConnection
• Crear sentencia:
Statement senten = connexion.createStatement();
• Ejecutar sentencia:
executeUpdate o executeQuery
• Procesar resultados:
while, resul.first(), resul.last(), resul.beforeFirst(),
resul.afterLast(),
resul.absolute
(int
num),
resul.next(), resul.previous, resul.getRow().
• Cerrar:
sentencia.close(),
resultados.close(),
conexion.close();
Spring Framework
El Spring Framework (conocido también como Spring) es un
framework de código abierto de desarrollo de aplicaciones para la
conocida plataforma JAVA. La primera versión fue escrita por
Rod Jonhson, quien lo lanzó primero con la publicación de su libro
Expert One-on-One Java EE Design and Development (Wrox
Press, octubre 2002).
A pesar de que Spring Framework no obliga a usar un modelo de
programación en particular, se ha popularizado en la comunidad de
programadores en Java al considerársele una alternativa y
sustituto del modelo de Enterprise JavaBean. Por su diseño el
framework ofrece mucha libertad a los desarrolladores en Java y
soluciones muy bien documentadas y fáciles de usar para las
prácticas comunes en la industria.
Spring Framework
Mientras que las características fundamentales de este
framework pueden emplearse en cualquier aplicación
hecha en Java, existen muchas extensiones y mejoras
para construir aplicaciones basadas en web por encima
de la plataforma empresarial de Java (Java Enterprise
Platform). Una de esas extensiones es el Spring JDBC.
El 29 de octubre del presente año se lanzó la versión
3.0.5
Introducción al Spring Framework
2.5
¿Por qué Spring?
Spring es único, por varias razones:
Se ocupa de aspectos importantes que otros frameworks
populares no. Spring se enfoca en proporcionar una manera de
administrar los objetos de negocio.
Spring es integral y modular. Spring tiene una arquitectura en
capas, lo que significa que puedes optar por utilizar casi cualquier
parte de ella de forma aislada, y aún así su arquitectura es
internamente consistente. Puedes optar por utilizar Spring sólo
para simplificar el uso de JDBC, por ejemplo, o puedes optar por
utilizar Spring para gestionar todos los objetos de tu negocio. Y
es fácil de introducir gradualmente Spring en proyectos
existentes.
Introducción al Spring Framework
2.5
Spring está diseñado desde cero para ayudarle a escribir código
que es fácil de probar. Spring es un framework ideal para probar
proyectos.
Spring es una tecnología de integración cada vez más importante,
su papel es reconocido por proveedores grandes y pequeños.
Spring está orientado a la mayoría de asuntos de infraestructura
de aplicaciones típicas. También va a lugares a los que otros
frameworks no van.
Beneficios de la arquitectura de
Spring
Algunos de los beneficios de Spring son los siguientes:
• Spring puede organizar efectivamente tus objetos
de nivel medio. Spring se encarga del shellcode que
quedaría si sólo utilizas Struts u otros frameworks
orientados a determinados APIs de J2EE. Y los
servicios de configuración de gestión de Spring
pueden ser utilizados en cualquier capa de la
arquitectura, en cualquier entorno de ejecución.
• Spring facilita la buena práctica de programación,
reduciendo el coste de la programación de
interfaces en lugar de clases a casi cero.
Beneficios de la arquitectura de
Spring
• Spring está diseñado para que las aplicaciones creadas con
ella dependen tan poco de su API como sea posible.
• Las aplicaciones creadas usando Spring son muy faciles de
probar. Para ciertos escenarios de pruebas, el Spring
Framework proporciona objetos simulados y clases de
apoyo de pruebas. Spring también proporciona una
exclusiva funcionalidad llamada "integration testing" en la
forma de Spring TestContext Framework, además JUnit
3.8 soporta clases que le permiten probar su código de
forma rápida y fácil, incluso mientras se accede a una base
de datos intermedia.
Abstracción JDBC y jerarquía de excepción de
acceso a datos
El acceso a datos es otra área donde Spring brilla.
JDBC ofrece una abstracción bastante buena de la base de datos subyacente, pero
es un API doloroso de usar. Algunos de los problemas incluyen:
•
•
La necesidad de manejo de error detallado para garantizar que ResultSet,
Statements y (lo más importante) Conexions, se cierren después de su uso. Esto
significa que el uso correcto de JDBC puede rápidamente dar lugar a una gran
cantidad de código. También es una fuente común de errores. Fugas de conexión
pueden llevar rápidamente a las aplicaciones a una carga baja.
La relativamente poco informativa SQLException. Tradicionalmente JDBC no
ofrece una jerarquía de excepción, pero produce una excepción de SQL en
respuesta a todos los errores. Descubrir lo que realmente salió mal (por ejemplo,
fue el problema un deadlock o una sentencia SQL invalida) consiste en examinar
el valor SQLSTATE y el código de error. El significado de estos valores varía
entre bases de datos.
, por lo que sus DAOs no son necesariamente ligados a JDBC debido a las excepciones
que pueden lanzar.
Abstracción JDBC y jerarquía de excepción de
acceso a datos
Spring aborda estos problemas de dos maneras:
• Al proporcionar API que mueven las excepciones tediosas y
propensas a errores del código de aplicación al framework.
El framework se encarga de toda la gestión de
excepciones, el código de aplicación se puede concentrar
en la emisión de SQL apropiado y la extracción de
resultados.
Abstracción JDBC y jerarquía de excepción de
acceso a datos
• Al proporcionar una jerarquía de excepciones significativa
del código de aplicación para trabajar en lugar de
SQLException. Cuando Spring obtiene en primer lugar una
conexión de un DataSource, examina los metadatos para
determinar el producto de base de datos. Spring utiliza
este conocimiento para mapear SQLExceptions y corregir
la excepción en su propia jerarquía descendiente de
org.springframework.dao.DataAccessException. Así, el
código puede trabajar con excepciones significativas, y no
es necesario preocuparse por SQLState propietario o los
códigos de error. El acceso a datos de Spring no son
excepciones JDBC específicas
Spring JDBC puede ayudar de varias maneras:
Usted nunca tendrá que escribir otra vez un bloque de finalización para usar
JDBC.
Las fugas de conexión serán cosa del pasado
Tendrá que escribir menos código en general, y ese código estará claramente
enfocado en las sentencias SQL necesarias.
Usted nunca tendrá que ahondar a través de la documentación del RDBMS para
averiguar qué oscuro código de error devuelve un nombre de columna erróneo. Su
aplicación no dependerá del código de control de errores específico de RDBMS.
Cualquier tecnología de persistencia que use, usted encontrará fácil de
implementar el patrón DAO sin lógica de negocio en función de cualquier API de
acceso a datos particular.
Usted se beneficiará de una mejor portabilidad (en comparación con JDBC crudo)
en áreas avanzadas como manipulación de BLOB y la invocación de procedimientos
almacenados que devuelven resultsets.
Todo esto equivale a ganancias sustanciales en productividad y menos errores.
Módulos principales de Spring
 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)
Spring JDBC (Acceso a datos)
El módulo de JDBC
Este módulo contiene varias características muy útiles,
pero la más poderosa es el JdbcTemplate.
Ejemplo clásico
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.
Ejemplo
 Cerrar el PreparedStatement.
 Cerrar la conexión.
Conclusión
• 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.
Spring-Jdbc
Jerarquía de paquetes
El framework de abstracción JDBC de Spring consiste
en cuatro diferentes paquetes core, dataSource, object
y support.
El paquete org.springframework.jdbc.core contiene
JdbcTemplate y varias interfaces para callback,
la
clase
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
Spring-Jdbc
JdbcTemplate (Ejemplos)
Consultar por un String
String surname = (String)
this.jdbcTemplate.queryForObject( "select surname
from t_actor where id = ?", new Object[]{new
Long(1212)}, String.class);
Consultar y rellenar un simple objeto de dominio.
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;
} });
Spring-Jdbc
• 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:
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);
}
Spring-Jdbc
• 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.
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); }
Spring-Jdbc
DataSource
Para 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
DataSource
La 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
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
SQLExceptionTranslator
Es 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.
Conclusión
 Aspectos a mejorar en el ejemplo:
SQLException: excepción genérica
Captura de excepciones para no hacer nada
 ¿Cómo lo mejora Spring?
 Mapeo de SQLException a excepciones específicas
Subclases de org.springframework.dao.DataAccessException
 Uso de unchecked exceptions
DataAccessException
es
una
subclase
java.lang.RuntimeException
 Se pueden capturar si se desea, pero no es obligatorio
 Automatiza la gestión de conexiones
de
Se 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 Wiki
http://spring-jdbc.wikispaces.com/
“A LEER EN CANTIDADES INSDUSTRIALES”
FIN
DE LA PRESENTACION
“A LEER EN CANTIDADES
INSDUSTRIALES”
Bibliografía
http://www.xmind.net/share/lshimokawa/spring-
jdbc/
http://www.comunidadjava.org/?q=node/421
http://www.javadocexamples.com/java_source/o
rg/springframework/prospring/ticket/db/Sample
BatchTests.java.html
http://www.comunidadjava.org/?q=node/421
http://chuwiki.chuidiang.org/index.php?title=Eje
mplo_sencillo_con_SpringFramework_DAO
Spring-Jdbc
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 :
Ejemplo
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.
Spring-Jdbc
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.