SPRING JDBC

1. 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 SPRING JDBC

2. JDBC

3. INTRODUCCION Este trabajo ilustra los elementos esenciales del JDBC (Java DatabaseConnectivity) API (ApplicationProgram Interface). Aquí, se aprenderá a usar el API de JDBC básico para crear las tablas, insertar valores, consultar tablas, recuperar resultados, actualizar tablas, crear declaraciones preparadas, realizar transacciones y capturar excepciones y errores.

4. 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.

5. Conexión a la Base de Datos

7. Mecanismo JDBC El funcionamiento práctico de JDBC obliga a conocer los siguientes 5 procedimientos, a saber: • Establecer conexión. • Crear sentencia. • Ejecutar sentencia. • Procesar resultados. • Cerrar.

8. 1.- Establecer la conexión Tiene dos operaciones básicas. • DriverManager • Connection

9. 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.

10. Para trabajar con el Puente JDBC-ODBC: try {Class.forName(“sun.jdbc.odbc.JdbcOdbcDriver”);} catch (ClassNotFoundException cnfe) {System.err.println(“No ha podido encontrarse el driver de ODBC.”);}

11. 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”);}

12. Para trabajar con postgreSQL: try {Class.forName(“org.postgresql.Driver”);} catch (ClassNotFoundException cnfe) {System.err.println(“No ha podido encontrarse el driver de postgreSQL”);}

13. Para trabajar con Oracle: try {Class.forName(“oracle.jdbc.driver.OracleDriver”);} catch (ClassNotFoundException cnfe) {System.err.println(“No ha podido encontrarse el driver de Oracle”);}

14. 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.

15. Para trabajar con el Puente JDBC-ODBC con MsAccess (Windows XP): importjava.sql.*; publicstaticvoidconexion ( ) throwsException { try { // Carga el driver Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); // Define la cadena de conexión StringsourceURL = "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(ClassNotFoundExceptioncnfe) { System.err.println(cnfe); } catch(SQLExceptionsqle) { System.err.println(sqle); }; };

16. Para trabajar con MySQL. importjava.sql.*; publicstaticvoidconexion ( ) throwsException { try { // Carga el driver Class.forName("com.mysql.jdbc.Driver”); // Define la cadena de conexión StringsourceURL = "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(ClassNotFoundExceptioncnfe) { System.err.println(cnfe); } catch(SQLExceptionsqle) { System.err.println(sqle); }; };

17. Para trabajar con postgreSQL: importjava.sql.*; publicstaticvoidconexion ( ) throwsException { try { // Carga el driver Class.forName(“org.postgresql.Driver”); // Define la cadena de conexión Stringdatabase = “Bd”;Stringusername = “admin”;Stringpassword = “admin”; StringsourceURL = "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(ClassNotFoundExceptioncnfe) { System.err.println(cnfe); } catch(SQLExceptionsqle) { System.err.println(sqle); }; };

18. Para trabajar con Oacle XE (versión 10g). importjava.sql.*; publicstaticvoidconexion ( ) throwsException { try { // Carga el driver Class.forName("oracle.jdbc.driver.OracleDriver"); // Define la cadena de conexión StringsourceURL=“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(ClassNotFoundExceptioncnfe) { System.err.println(cnfe); } catch(SQLExceptionsqle) { System.err.println(sqle); }; };

19. 2.- Crear sentencia. Statement Un objeto Statement se usa para enviar sentencias SQL a una base de datos. Statement senten = con.createStatement();

20. 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

21. 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. PreparedStatementupdateSales = con.prepareStatement ( “UPDATE productos SET ventas = ? WHERE COD = ? ” );

22. 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. • Consulta – executeQuery() Es una operación SELECT que devuelve el resultado de una consulta encapsulado en un objeto de tipo ResultSet • Actualización – executeUpdate() Es una operación INSERT, UPDATE o DELETE que realiza una modificación sobre la base de datos

23. ResultSet resul = senten.executeQuery ( “ SELECT a, b, c FROM Table2″); Ó Int filas_afectadas = senten.executeUpdate(“UPDATE personas set nombre=’Marina’ where id=4″);

24. 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.

25. 5.-Cerrar. Es necesario cerrar adecuadamente la sentencia el ResultSet y la conexión. • senten.close(); • resul.close(); • con.close();

26. Conviene recordar: El mecanismo de funcionamiento básico JDBC, • Establecer conexión: Class.forName(“…”)  y DriverManager.getConnection • Crear sentencia: Statementsenten = connexion.createStatement(); • Ejecutar sentencia: executeUpdate o executeQuery • Procesar resultados: while, resul.first(), resul.last(), resul.beforeFirst(), resul.afterLast(), resul.absolute (intnum), resul.next(), resul.previous, resul.getRow(). • Cerrar: sentencia.close(), resultados.close(), conexion.close();

27. 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.

28. 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

29. 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.

30. 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.

31. 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.

32. 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.

33. 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.

34. 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.

35. 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

36. 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.

37. 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)

38. 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.

39. 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.

40. 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 ValueObject y ponerle los valores que vienen en la tupla actual, y luego poner ese ValueObject en una lista. • Cerrar el ResultSet. • Cerrar el PreparedStatement. • Cerrar la conexión. Ejemplo

41. 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 se encarga de todos aquellos detalles engorrosos de bajo nivel que pueden provocar que la API de JDBC sea muy tediosa.

42. 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 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

43. Spring-Jdbc Jerarquía de paquetes El paquete org.springframework.jdbc.objectcontiene clases que representan las consultas (queries) a los RDBMS, las actualizaciones (updates) y los procedimientos almacenados (storedprocedures) 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.

44. 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 (storedprocedures), 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

45. Spring-Jdbc JdbcTemplate (Ejemplos) Consultar por un String Consultar y rellenar un simple objeto de dominio. 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( "selectfirst_name, surnamefromt_actorwhere id = ?", new Object[]{new Long(1212)}, new RowMapper() { publicObjectmapRow(ResultSetrs, introwNum) throwsSQLException { Actor actor = new Actor(); actor.setFirstName(rs.getString("first_name")); actor.setSurname(rs.getString("surname")); return actor; } });

46. 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: publicintcountOfActorsByFirstName(StringfirstName) { Stringsql = "selectcount(0) from T_ACTOR wherefirst_name = :first_name"; SqlParameterSourcenamedParameters = new MapSqlParameterSource("first_name", firstName); returnnamedParameterJdbcTemplate.queryForInt(sql, namedParameters); }

47. 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) { Stringsql = "select id, first_name, last_namefrom T_ACTOR where id = ?"; ParameterizedRowMapper<Actor> mapper = new ParameterizedRowMapper<Actor>() { public Actor mapRow(ResultSetrs, introwNum) throwsSQLException { Actor actor = new Actor(); actor.setId(rs.getLong("id")); actor.setFirstName(rs.getString("first_name")); actor.setLastName(rs.getString("last_name")); return actor; } }; returnthis.simpleJdbcTemplate.queryForObject(sql, mapper, id); }

48. 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.

49. 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:

50. Spring-Jdbc • DataSource publicstaticvoidcrearDataSource() { DriverManagerDataSourceds = 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); }