Tema 5

  • 140 views
Uploaded on

 

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Be the first to comment
    Be the first to like this
No Downloads

Views

Total Views
140
On Slideshare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
6
Comments
0
Likes
0

Embeds 0

No embeds

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
    No notes for slide

Transcript

  • 1. II Curso Online JAVA-J2EE TEMA 5 ORM, Persistencia de DatosAutor: PCYTA / Centro de Excelencia de Software Libre de Castilla-La ManchaVersión: 1.0Fecha: Revisado 26-02-2008 22:46Licencia: CC-by-sa 2.5
  • 2. 0 LicenciaUsted es libre de: Copiar, distribuir y comunicar públicamente la obra Hacer obras derivadasBajo las condiciones siguientes: Reconocimiento. Debe reconocer los créditos de la obra de la manera especificada por el autor o el licenciador (pero no de una manera que sugiera que tiene su apoyo o apoyan eluso que hace de su obra). Compartir bajo la misma licencia. Si altera o transforma esta obra, o genera una obra derivada, sólo puede distribuir la obra generada bajo una licencia idéntica a ésta. • Al reutilizar o distribuir la obra, tiene que dejar bien claro los términos de la licencia de esta obra. • Alguna de estas condiciones puede no aplicarse si se obtiene el permiso del titular de los derechos de autor • Nada en esta licencia menoscaba o restringe los derechos morales del autor.Para ver la licencia visite:http://creativecommons.org/licenses/by-sa/2.5/es/legalcode.es6 de febrero de 2008 Tema 5 2
  • 3. UNIDAD II. ORM, Persistencia de Datos0 Licencia............................................................................................................................................ 21 SQL...................................................................................................................................................52 JDBC................................................................................................................................................ 6 2.1 Introducción.............................................................................................................................. 6 2.2 Conexión a una Base de Datos ................................................................................................ 6 2.3 Creación y Ejecución de una Sentencia ................................................................................... 7 2.4 Creación y Ejecución de una Sentencia Preparada ("PreparedStatement") .............................8 2.5 Transaccionalidad .................................................................................................................... 93 Instalacion de MySQL....................................................................................................................114 Ejemplo de JDBC en Aplicaciones JAVA...................................................................................... 215 Ejemplo de JDBC en Aplicaciones J2EE....................................................................................... 286 Frameworks.................................................................................................................................... 40 6.1 Introducción............................................................................................................................ 40 6.2 JDO......................................................................................................................................... 40 6.3 Hibernate ................................................................................................................................416 de febrero de 2008 Tema 5 3
  • 4. INTRODUCCIÓNComo veíamos durante temas anteriores, uno de los modelos a seguir más habituales a la hora dedesarrollar aplicaciones es el modelo de tres capas.Estas capas eran: • capa de presentación • capa de lógica de negocio • capa de datosLas dos primeras ya hemos visto como desarrollarlas mediante el empleo de tecnologías comoHTML, JavaScript, CSS, JSPs, Servlets, EJBs (lo veremos en el siguiente tema), etc. En este temanos vamos a centrar en algunas de las tecnologías que se suelen emplear a la hora de desarrollarla capa de datos.Object-Relational Mapping (abreviado como ORM, O/RM y O/R Mapping) es una técnica deprogramación para mapear datos de lenguajes de programación orientados a objetos (comoJava) a bases de datos relacionales (como Oracle, MySQL, DB2, etc.).Sigamos con nuestro ejemplo de la tienda virtual. Tenemos el concepto usuario, que tiene asociadosdatos como nombre, dirección y dni. Para implementar esto en nuestra tienda virtual tendríamos quetener una clase "Usuario" con esos campos y tendríamos que tener una tabla "Usuarios" dondealmacenar esos datos. Y por último, deberíamos implementar la funcionalidad necesaria pararelacionar los campos de base de datos con los campos de la clase "Usuario". Esta funcionalidadpara "mapear" campos de base de datos con campos de objetos se realiza mediante la técnicaORM.La técnica ORM es un modelo a seguir, existiendo un gran número de entornos que nos ayudan ala hora de aplicar esta técnica. En los siguientes apartados de este tema veremos algunos de ellos yvarias tecnologías útiles a la hora de manipular la capa de datos.6 de febrero de 2008 Tema 5 4
  • 5. 1 SQLSQL (Structured Query Language) es un lenguaje diseñado principalmente para lamanipulación de datos en bases de datos relacionales y modificación de esquemas de bases dedatos (tablas, índices, vistas, etc.).Este lenguaje fue estandarizado por las organizaciones ANSI e ISO y hoy en día es el empleadoen las distintas bases de datos (Oracle, DB2, MySQL, PostgreSQL, etc.).Antes de seguir con el curso, es importante que conozcáis algo de SQL. En caso de no ser así,antes de continuar, estudiad el lenguaje SQL (al menos a un nivel básico) ya que esteconocimiento es prácticamente indispensable para continuar con el tema. Para este estudio visitadenlaces como http://www.programacion.com/bbdd/tutorial/sql/ para ver SQL genérico y miradhttp://dev.mysql.com/doc/refman/5.0/en/sql-syntax.html para ver SQL con los comandosespecíficos de MySQL.Por otro lado, en el caso de que sí lo conozcáis, tampoco es mala idea hacer un repaso al segundoenlace de los antes indicados ya que explica cosas que son propias de MySQL, las cuales noconoceréis si no habéis trabajado nunca con ella.El segundo enlace situado arriba es un manual de SQL para MySQL ya que esta base de datos es laque usaremos. Aunque SQL es un estándar, cada base de datos suele introducir algunasvariantes tanto en tipos de datos como en ciertas sentencias, pero siempre manteniendo labase de SQL.6 de febrero de 2008 Tema 5 5
  • 6. 2 JDBC2.1 IntroducciónJDBC (Java Database Connectivity) es un API que permite la ejecución de operaciones sobrebases de datos desde el lenguaje de programación Java.El API JDBC es una especificación del interfaz que debe emplear el programador que quiereoperar sobre la base de datos. Cada distribuidor de bases de datos tiene que ofrecer a losdesarrolladores que las van a emplear una implementación de ese API(también llamadodriver).En nuestro ejemplo de la tienda virtual vamos a usar MySQL como sistema de gestión de bases dedatos, de modo que tenemos que instalar MySQL y, para conectarnos a él y operar mediante JDBC,tenemos que emplear la implementación del API que los creadores de MySQL nosproporcionen. Esta implementación, en el caso de MySQL, no es más que un jar.En el resto del tema veremos los pasos a seguir para conectarse a una base de datos y operar sobreella. Más adelante pondremos un ejemplo en el que se instalará el sistema de gestión de base dedatos (MySQL), se creará una base de datos de ejemplo con unas tablas y luego realizaremosmediante JDBC algún acceso a la misma.2.2 Conexión a una Base de DatosImaginemos que nos proporcionan una base de datos con sus tablas. Lo primero que deberíamosrealizar para trabajar con ella es conectarnos. Para ello debemos realizar dos pasos, la carga deldriver y la conexión.- Carga del driver: Esta tarea es bastante sencilla. Escribiendo la siguiente línea es suficiente:Class.forName("clase del driver");La documentación del driver nos especificará el nombre de la clase a utilizar. En el caso deMySQL, según la documentación, sería:Class.forName("com.mysql.jdbc.Driver");Una vez cargado el driver, ya podemos realizar la conexión. El "jar" que contiene la clase del driver debe estar en el ClassPath.6 de febrero de 2008 Tema 5 6
  • 7. - Realizar la conexión: Para realizar la conexión deberíamos escribir una línea de código como lasiguiente.Connection con = DriverManager.getConnection(url, "miLogin", "miPassword");Lo complicado de este punto es saber que url proporcionar. La url a emplear normalmente vendráexplicada en la documentación de sistema de gestión de base de datos que estemos utilizando. Ennuestro caso, para MySQL, sería algo así:Connection con = DriverManager.getConnection("jdbc:mysql://localhost/test", "root","password"); "test" es una base de datos que viene con la instalación inicial de mysql, "root" es el usuario administrador de la base de datos y "password" es el password que fijamos en la instalación para ese usuario.2.3 Creación y Ejecución de una SentenciaUn objeto de la clase Statement (definida en el API JDBC) es el que envía nuestras sentencias SQLal controlador de la base de datos. Por lo tanto, para lanzar una sentencia SQL simplementecreamos un objeto Statement y lo ejecutamos pasándole por parámetro la sentencia SQL. Si lasentencia SQL es un SELECT (no modifica datos), el método a ejecutar es executeQuery. Si lasentencia SQL crea o modifica tablas o su contenido, empleamos executeUpdate.Statement stmt = con.createStatement();stmt.executeQuery(SENTENCIA SQL DE TIPO SELECT);stmt.executeUpdate(SENTENCIA SQL QUE CREA O MODIFICA TABLAS O SUCONTENIDO); El objeto "con" es la conexión creada en el apartado anterior.Un detalle importante es que "executeUpdate(…)" devuelve un "int" con el número de líneasmodificadas mientras que "executeQuery(…)" devuelve un "ResultSet" que contiene el conjuntode registros que devuelve la sentencia de tipo "select" que se le pasa por parámetro.Evidentemente, una sentencia sql de tipo "select" puede devolver miles de registros con lo que el"ResultSet" no contiene todo los resultados, sino que contiene un "cursor" el cual se recorrecon las funciones que ofrece "ResultSet". A continuación vemos un ejemplo que muestra estefuncionamiento:ResultSet rs = stmt.executeQuery(SENTENCIA SQL DE TIPO SELECT);while (rs.next()) { System.out.println(rs.getString(1));6 de febrero de 2008 Tema 5 7
  • 8. }En el código anterior, se supone que la "SENTENCIA SQL" debe devolver un primer campo de tipo"String". Si este primer dato fuera un número entero deberíamos usar "rs.getInt(1)". Si, por ejemplo,la "SENTENCIA SQL" devolviera como tercer campo un número con decimales, usaríamosrs.getDouble(3); Los métodos que ofrece el interfaz "java.sql.ResultSet" es mucho más amplia para recorrer resultados y obtener los distintos tipos existentes. Para una mayor información mirar http://java.sun.com/j2se/1.5.0/docs/api/java/sql/ResultSet.htmlCon esto tenemos la idea principal de como trabajar sobre una base de datos con java. Ahoraveremos algunos otros conceptos importantes y, más adelante, realizaremos un par de ejemplos muysencillos que os servirán de base para los desarrollos que tengáis que realizar. 2.4 Creación y Ejecución de una Sentencia Preparada("PreparedStatement")Algunas veces es más conveniente o eficiente utilizar objetos "PreparedStatement" para enviarsentencias SQL a la base de datos en vez de los antes vistos "Statement". Este tipo especial desentencias extiende el interfaz "Statement".Es más conveniente cuando queremos ejecutar muchas veces un objeto "Statement". En esecaso, si usamos "PreparedStatement" reduciremos el tiempo de ejecución.La característica principal de un objeto "PreparedStatement" es que, al contrario que un objeto"Statement", se le entrega una sentencia SQL cuando se crea. La ventaja de esto es que, en lamayoría de los casos, esta sentencia SQL se enviará al controlador de la base de datosinmediatamente donde será compilada. Como resultado, el objeto "PreparedStatement" no sólocontiene una sentencia SQL, sino una sentencia SQL que ha sido precompilada. Esto significa quecuando se ejecuta la PreparedStatement, el controlador de base de datos puede ejecutarla sin tenerque compilarla primero.Aunque los objetos "PreparedStatement" se pueden utilizar con sentencias SQL sin parámetros,probablemente nosotros utilizaremos más frecuentemente sentencias con parámetros. La ventajade utilizar sentencias SQL que utilizan parámetros es que podemos utilizar la misma sentencia ysuministrar distintos valores cada vez que la ejecutemos. A continuación vemos código que muestrael uso de un "PreparedStatement".PreparedStatement pstmt = con.prepareStatement("SELECT * FROM NOMBRE_TABLAWHERE NOMBRE_CAMPO1=? AND NOMBRE_CAMPO2=?");pstmt.setString(1,"valor_campo1");pstmt.setInt(2,78);ResultSet rs = pstmt.executeQuery();6 de febrero de 2008 Tema 5 8
  • 9. Cómo podemos deducir a partir del ejemplo, el primer argumento de un método setXXX indica que"?" queremos asignar, y el segundo argumento el valor que queremos ponerle.En este momento ya hemos visto como usar una base de datos en JAVA, que es lo principal quedebemos saber. Aún así, todavía hay un aspecto muy importante a la hora de trabajar sobre bases dedatos, la transaccionalidad. Este asunto lo veremos en el siguiente apartado. Tened en cuenta que todo el código escrito hasta el momento, y el que veréis en el siguiente apartado, emplea métodos que lanzan excepciones. No las hemos puesto en el código de ejemplo para no confundir, pero no os preocupéis porque en los ejemplos veréis este código con el control de excepciones apropiado.2.5 TransaccionalidadComo bien conocemos, las operaciones sobre bases de datos tienen un aspecto muy importante, latransaccionalidad. Para gestionarla, una de las principales herramientas de las que disponemoses la propiedad booleana denominada "AutoCommit" que tienen las conexiones que creamos auna base de datos.Si una conexión tiene "AutoCommit" a valor true, automáticamente se ejecutará una sentencia"Commit" tras cada operación de actualización en base de datos. En el caso de que "AutoCommit"esté asignada a "false", nosotros tendremos que realizar el "Commit" de forma explícita. Acontinuación vemos un ejemplo de asignación del valor de "AutoCommit"://con es la conexión obtenida anteriormentecon.setAutoCommit(false);Imaginemos ahora un ejemplo sobre nuestra tienda virtual. Hemos realizado una venta con lo quetenemos que ejecutar dos operaciones, por un lado la inserción de un nuevo pedido en la tabla depedidos y por otro lado actualizar el almacén eliminando del stock los productos vendidos en elpedido. Evidentemente para que la base de datos no quede inconsistente, estas dos operaciones setienen que ejecutar, no nos vale, por ejemplo, que se ejecute la primera y la segunda falle. Pararesolver este problema, una solución sencilla es fijar el "AutoCommit" a "false", ejecutar lasoperaciones, hacer el "Commit" y finalmente establecer de nuevo el AutoCommit a "true".Acontinuación se muestra el código que realizaría esas operaciones://con es la conexión obtenida anteriormentecon.setAutoCommit(false);Statement stmt = con.createStatement();stmt.executeUpdate(SENTENCIA SQL DE INSERCIÓN DEL PEDIDO);stmt.executeUpdate(SENTENCIA SQL DE AJUSTE DE STOCK);con.commit();con.setAutoCommit(true);6 de febrero de 2008 Tema 5 9
  • 10. Pero imaginemos que se ejecuta correctamente la primera sentencia SQL y la segunda falla(lanzando una excepción), en este caso deberíamos hacer un "rollback" para que se deshagan lasoperaciones anteriores. A continuación se muestra un ejemplo de cómo quedaría el código:con.setAutoCommit(false);try { Statement stmt = con.createStatement(); stmt.executeUpdate(SENTENCIA SQL DE INSERCIÓN DEL PEDIDO); stmt.executeUpdate(SENTENCIA SQL DE AJUSTE DE STOCK); con.commit();} catch (SQLException sqle) { con.rollback();}con.setAutoCommit(true);Con esto hemos visto la utilidad de las transacciones para lograr que varias operaciones sobre basede datos se ejecuten de forma atómica, que es uno de los principios básicos del trabajo sobre basede datos.6 de febrero de 2008 Tema 5 10
  • 11. 3 Instalacion de MySQLEn este momento ya sabemos SQL y sabemos programar en Java para trabajar sobre bases de datosmediante JDBC. Pero, evidentemente, necesitamos una base de datos sobre la que hacer nuestraspruebas y aplicaciones. Sistemas de Gestión de Bases de Datos Relacionales existen muchos(Oracle, DB2, MySQL, etc.) cada uno con sus características. No confundir "Sistema de Gestión de Bases de Datos Relacionales" con "Base de Datos Relacional". El primero es la aplicación donde se crean y gestionan las bases de datos. El segundo es el "ente" en el que se especifican y almacenan todos los datos. Aún así, es muy habitual emplear la expresión "Base de Datos" para ambos conceptos.Para este curso hemos decidido emplear MySQL 5.0 por varias razones: - Tiene versiones gratuitas. - Es sencillo de instalar y usar. - Es ampliamente utilizado incluso en entornos en producción.Para instalar la base de datos, lo que debemos hacer es descargar el fichero instalador (descárgalo deaquí), descomprimirlo y ejecutarlo. Para tener la instalación que vamos a utilizar en el curso, siguelos siguientes pasos:Pulsa "Next".6 de febrero de 2008 Tema 5 11
  • 12. Selecciona "Typical" y pulsa "Next".Pulsa "Install".6 de febrero de 2008 Tema 5 12
  • 13. Pulsa "Next".Pulsa "Next".6 de febrero de 2008 Tema 5 13
  • 14. Marca la casilla que te llevará a configurar la base de datos y pulsa "Next".Pulsa "Next".6 de febrero de 2008 Tema 5 14
  • 15. Marca "Detailed Configuration" y pulsa "Next".Selecciona "Developer Machine" y pulsa "Next".6 de febrero de 2008 Tema 5 15
  • 16. Selecciona "Multifunctional Database" y pulsa "Next"Pulsa "Next".6 de febrero de 2008 Tema 5 16
  • 17. Selecciona "Decisión Support" y pulsa "Next".Marca las dos opciones y no cambies el puerto. Después pulsa "Next".6 de febrero de 2008 Tema 5 17
  • 18. Selecciona "Standard Character Set" y pulsa "Next".Indica que se instale como servicio y que se arranque automáticamente. Así no tendrás que levantarla base de datos cada vez que se arranques el ordenador. Pulsa "Next".6 de febrero de 2008 Tema 5 18
  • 19. Establece una contraseña, por ejemplo "password", y no habilites el acceso como root desde otrasmáquinas. Pulsa "Next".Pulsa "Execute".6 de febrero de 2008 Tema 5 19
  • 20. Pulsa "Finish" y ya tenemos el Sistema de Gestión de Bases de Datos instalado.En el siguiente apartado crearemos una base de datos sencilla y haremos una aplicación sencilla quetrabaje sobre esa base de datos.6 de febrero de 2008 Tema 5 20
  • 21. 4 Ejemplo de JDBC en Aplicaciones JAVAHasta el momento hemos visto en qué consiste la técnica ORM y hemos visto la utilización básicade JDBC. Con estos conceptos y con los conocimientos de SQL que tenemos, ya estamos listos parahacer nuestra primera aplicación que se comunique con base de datos a través del API JDBC.Este ejemplo demuestra como conectar una aplicación JAVA (sin usar J2EE). La idea que vamos aseguir es crear una base de datos con una tabla que tenga unos campos. Después crearemos unaaplicación JAVA que se conecte a esa base de datos, que inserte unos cuantos registros, que luegolos consulte, los escriba en pantalla y luego los elimine.Para ello, lo primero que haremos será crear la base de datos sobre la MySQL que instalamos antesen el tema. Para hacerlo, conectémonos a ella desde una ventana de MS-DOS, situándonos en eldirectorio "bin" de nuestra instalación de MySQL y ejecutando la instrucción "mysql -u root -p" eintroduciendo el password de la base de datos como vemos en la imagen:Una vez dentro de la consola de MySQL ejecutemos los comandos que se muestran en la imagenpara crear una base de datos, para activar su uso y para crear una tabla en ella.6 de febrero de 2008 Tema 5 21
  • 22. Con esto ya tenemos creada una base de datos llamada "jdbcdbjava" con una tabla llamada"mitabla" con dos campos de tipo texto llamados "nombre" y "apellidos".Para salir de la consola de mysql escribe el comando "exit" y pulsa enter. Así volveremos a laventana de MS-DOS. Ya podemos cerrar esta ventana ya que no nos hará falta.Ahora vamos a hacer el programa java que se conectará y operará sobre ella. Para ello sigamos lossiguientes pasos:Crea un proyecto Java tal y como se vé en la siguiente imagen.6 de febrero de 2008 Tema 5 22
  • 23. Selecciona Java - Java Project y pulsa Next.6 de febrero de 2008 Tema 5 23
  • 24. Inserta los datos tal y como se muestran en la imagen superior y pulsa Next.En la pantalla siguiente, pulsa Add External JARs y selecciona el jar del driver de mysql (si no lotienes o no estás seguro pincha aquí para descargar el driver). Finalmente te debe quedar la pantallacomo muestra la siguiente imagen.6 de febrero de 2008 Tema 5 24
  • 25. Cuando hayas seleccionado el driver, pincha Finish.Una vez creado el proyecto, creemos una clase con el método "main" como se muestra en lasiguiente imagen:6 de febrero de 2008 Tema 5 25
  • 26. Pincha en Finish.Meter el código apropiado en la clase para que quede como sigue (es suficiente si sustituyes elcontenido de la clase con el siguiente):import java.sql.Connection;import java.sql.DriverManager;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;public class MiClase {6 de febrero de 2008 Tema 5 26
  • 27. public static void main(String[] args) { System.out.println("inicio"); try { Class.forName("com.mysql.jdbc.Driver"); Connection con = DriverManager.getConnection("jdbc:mysql://localhost/jdbcdbjava", "root", "password"); Statement stmt = con.createStatement(); stmt.executeUpdate("insert into mitabla values (Toñito,Garcia)"); stmt.executeUpdate("insert into mitabla values (Pepito,Pérez López)"); ResultSet rs = stmt.executeQuery("select * from mitabla"); while (rs.next()) System.out.println("Nombre: " + rs.getString(1) + ", Apellidos: " + rs.getString(2)); stmt.executeUpdate("delete from mitabla"); rs = stmt.executeQuery("select count(*) from mitabla"); while (rs.next()) System.out.println("Número de registros tras el borrado: " + rs.getInt(1)); } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (SQLException e) { e.printStackTrace(); } System.out.println("fin"); }}Ejecuta la clase pinchando en el editor con el botón derecho, después Run As - Java Application. Enla consola el resultado que debemos obtener es el siguiente:inicioNombre: Toñito, Apellidos: GarciaNombre: Pepito, Apellidos: Pérez LópezNúmero de registros tras el borrado: 0finPues ya hemos visto un ejemplo sencillo de uso de JDBC. Ahora llega el momento de queexperimentes. Prueba con "PreparedStatement", con transacciones, crea campos de tipos distintos acadenas de texto (fechas, valores enteros, decimales, etc.).6 de febrero de 2008 Tema 5 27
  • 28. 5 Ejemplo de JDBC en Aplicaciones J2EEEn una aplicación Web. Perfectamente podríamos meter el código del ejemplo anterior en unservlet de modo que se ejecutara cuando es llamado, pero ésta no es la forma más correcta dehacerlo ya que el rendimiento no es el apropiado. Veamos el porqué.PROBLEMA: Una de las operaciones más lentas al trabajar con bases de datos es crear laconexión. La razón es que cuando se establece una conexión, el sistema de gestión de bases dedatos (en nuestro ejemplo MySQL) tiene que realizar una serie de operaciones muy costosas.Además, en la parte java, se debe cargar el driver, crear un objeto de tipo conexión, inicializarla,abrirla, etc. Por lo tanto, si metiéramos ese código en el servlet, todas estas operaciones seejecutarían en cada llamada al servlet.SOLUCIÓN: La forma que se emplea para resolver esta problemática es la definición de un"pool" de conexiones. Esto es tan sencillo como definir un conjunto de conexiones ya establecidasy guardarlas en un "pool" que mantendrá nuestro servidor de aplicaciones (Tomcat en nuestro caso).Por lo tanto, nuestra aplicación, en lugar de crear la conexión como en el ejemplo anterior, lo quehará será pedirle al servidor de aplicaciones que nos dé una y la utilizará, consiguiendo así unaoptimización muy importante y básica en las aplicaciones actuales. Tras su utilización, la aplicaciónla devuelve al servidor para que la vuelva a entregar en el momento que nuestra aplicación, u otra,se la pida de nuevo al servidor.Una vez visto esto, las tareas a realizar para crear este ejemplo son los siguientes:- Crear el pool de conexiones. Esto se hace mediante la creación de un DataSource que es elinterfaz mediante el cual se accede a un pool de conexiones.- Crear la aplicación Web con un servlet en el que meteremos el código que hará el trabajo conbase de datos (ya veremos los cambios a introducir para emplear el DataSource)- Probar la aplicación.Pues empecemos con el ejemplo. Creemos primero una aplicación Web. Para ello sigamos lossiguientes pasos.6 de febrero de 2008 Tema 5 28
  • 29. Selecciona en el cuadro de diálogo de "New Project" el tipo "Web-Dynamic Web Project". Luegopulsa Next.6 de febrero de 2008 Tema 5 29
  • 30. Pon el nombre que se muestra en la imagen anterior y pulsa Next.6 de febrero de 2008 Tema 5 30
  • 31. Asegurate de que las opciones seleccionadas son las que se muestran arriba y pulsa Next.6 de febrero de 2008 Tema 5 31
  • 32. Pulsa Finish.Con esto ya tenemos la aplicación Web pero está vacía. En la aplicación creemos un servlet llamado"CursoServlet" en el paquete "miServlet". Para ello creemos un paquete como se ve en la siguienteimagen:6 de febrero de 2008 Tema 5 32
  • 33. Pulsa Finish6 de febrero de 2008 Tema 5 33
  • 34. Asigna los valores de la imagen y pulsa Finish.Con esto ya habremos creado el servlet en el paquete que queremos.En este servlet deberíamos meter el código que pedirá al servidor de aplicaciones la conexión delpool pero primero creemos el pool mediante la definición de un datasource. Para ello, creemos elfichero context.xml dentro del directorio META-INF que será el fichero que leerá el servidor deaplicaciones. Mediante este fichero le decimos al servidor que cree el datasource. El contenido delfichero context.xml debe ser el siguiente:<Context path="/cursoJDBCWeb" docBase="cursoJDBCWeb"debug="5" reloadable="true" crossContext="true"><Resource name="jdbc/mysqlDS" auth="Container"type="javax.sql.DataSource"maxActive="100" maxIdle="30" maxWait="10000"username="root" password="password"driverClassName="com.mysql.jdbc.Driver"url="jdbc:mysql://localhost/jdbcdbjava"/></Context>Al leer este fichero el servidor entiende, de forma resumida, lo siguiente:- En el contexto de aplicación "/cursoJDBCWeb" (nuestro contexto) se define un recurso (etiqueta6 de febrero de 2008 Tema 5 34
  • 35. resource).- El nombre del recurso es "jdbc/mysqlDS" (nombre del recurso que solicitaremos mediante JNDI).- El recurso es de tipo (type) Datasource.- El Datasource usará como driver la clase "com.mysql.jdbc.Driver", que deberá encontrarse en eldirectorio lib del servidor tal y como dice la documentación de MySQL.- La URL de conexión será "jdbc:mysql://localhost/jdbcdbjava" y usará como usuario "root" y sucontraseña es "password".- El resto de parámetros son de configuración y optimización pero escapan de los objetivos delcurso.Con este fichero ya tenemos definido el datasource que nos crea el pool de conexiones, solo nosfalta, para que el servidor encuentre la clase del driver, meter el fichero "mysql-connector-java-5.0.7-bin.jar " (lo debéis tener en vuestro disco ya que se ha usado anteriormente en el tema)en el directorio de librerías de tomcat (por ejemplo, "C:apache-tomcat-6.0.14lib") tal y como dicela documentación de MySQL.Pues ya tenemos preparado el servidor para que cree el datasource al arrancar la aplicación. Ahoratenemos que meter el código para usarlo. Para ello, modificamos el servlet para que quede como elsiguiente código:package miServlet;import java.io.IOException;import java.sql.Connection;import java.sql.ResultSet;import java.sql.SQLException;import java.sql.Statement;import javax.naming.Context;import javax.naming.InitialContext;import javax.naming.NamingException;import javax.servlet.ServletException;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import javax.sql.DataSource;/*** Servlet implementation class for Servlet: CursoServlet**/public class CursoServlet extends javax.servlet.http.HttpServlet implementsjavax.servlet.Servlet { static final long serialVersionUID = 1L; /* (non-Java-doc) * @see javax.servlet.http.HttpServlet#HttpServlet() */ public CursoServlet() {6 de febrero de 2008 Tema 5 35
  • 36. super();}/* (non-Java-doc)* @see javax.servlet.http.HttpServlet#doGet(HttpServletRequest request,HttpServletResponse response)*/protected void doGet(HttpServletRequest request, HttpServletResponseresponse) throws ServletException, IOException { System.out.println("Entrada en el servlet"); try { Context ctx = null; try { ctx = new InitialContext(); } catch (NamingException e) { e.printStackTrace(); } if(ctx == null ) throw new ServletException("Boom - No Context"); DataSource ds = null; try { ds = (DataSource)ctx.lookup("java:comp/env/jdbc/mysqlDS"); } catch (NamingException e) { e.printStackTrace(); } if (ds == null) throw new ServletException("Boom - No Datasource"); Connection con = ds.getConnection(); Statement stmt = con.createStatement(); stmt.executeUpdate("insert into mitabla values (Toñito,Garcia)"); stmt.executeUpdate("insert into mitabla values (Pepito,Pérez López)"); ResultSet rs = stmt.executeQuery("select * from mitabla"); while (rs.next()) System.out.println("Nombre: " + rs.getString(1) + ", Apellidos: " + rs.getString(2)); stmt.executeUpdate("delete from mitabla"); rs = stmt.executeQuery("select count(*) from mitabla"); while (rs.next())6 de febrero de 2008 Tema 5 36
  • 37. System.out.println("Número de registros tras el borrado: " + rs.getInt(1)); } catch (SQLException e) { e.printStackTrace(); } System.out.println("Salida del servlet"); }}Lo más reseñable es la forma en que se consigue la conexión con la base de datos. Si en el ejemplode aplicación java se cargaba el driver y se le pedía la conexión, en J2EE, para aprovechar laoptimización del pool, debemos buscar por JNDI el datasource y a ese datasource le debemos pedirla conexión.Por ahora ya tenemos el datasource creado y el código que lo usa, ahora nos falta definir el servlet yel datasource en el fichero web.xml y después probar. Para ello, el fichero web.xml debe quedar delsiguiente modo:<?xml version="1.0" encoding="UTF-8"?><web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns="http://java.sun.com/xml/ns/javaee"xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"xsi:schemaLocation="http://java.sun.com/xml/ns/javaeehttp://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" id="WebApp_ID"version="2.5"> <display-name>cursoJDBCWeb</display-name> <servlet> <servlet-name>CursoServlet</servlet-name> <servlet-class>miServlet.CursoServlet</servlet-class></servlet><servlet-mapping> <servlet-name>CursoServlet</servlet-name> <url-pattern>/CursoServlet</url-pattern></servlet-mapping><welcome-file-list> <welcome-file>index.html</welcome-file> <welcome-file>index.htm</welcome-file> <welcome-file>index.jsp</welcome-file> <welcome-file>default.html</welcome-file> <welcome-file>default.htm</welcome-file> <welcome-file>default.jsp</welcome-file></welcome-file-list><resource-ref> <description>Conexion a MySQL</description> <res-ref-name>jdbc/mysqlDS</res-ref-name> <res-type>javax.sql.DataSource</res-type> <res-auth>Container</res-auth>6 de febrero de 2008 Tema 5 37
  • 38. </resource-ref></web-app>Ya ha llegado el momento de probarlo, para ello añadamos el proyecto al tomcat del siguientemodo:6 de febrero de 2008 Tema 5 38
  • 39. Añadir el proyecto y pinchar FinishY ahora… arranquemos el servidor de aplicaciones, recemos y abramos un navegador dondepediremos esta url: http://localhost:8080/cursoJDBCWeb/CursoServletEl resultado deberá ser una pantalla en blanco ya que no hemos añadido nada de presentación perolo importante es que se ejecutará el código que hemos introducido en el servlet sacando por laconsola del servidor las siguientes líneas:Entrada en el servletNombre: Toñito, Apellidos: GarciaNombre: Pepito, Apellidos: Pérez LópezNúmero de registros tras el borrado: 0Salida del servletComo podemos ver, se insertaron los dos registros y luego se borraron.Al igual que en el ejemplo anterior, sería interesante que ahora hagáis pruebas similares al ejemplode JDBC sobre Java.6 de febrero de 2008 Tema 5 39
  • 40. 6 Frameworks6.1 IntroducciónCon lo visto hasta el momento en el tema, ya somos capaces de trabajar sobre una base de datosconsiguiendo así que los datos que maneja nuestra aplicación se persistan. Realmente lo queestamos haciendo es mapear los datos de nuestros objetos de modelo de negocio en una base dedatos relacional.La tarea del mapeo de objetos a base de datos dentro de un proyecto de cierta envergadura esuna de las más laboriosas y más aún si no usamos la tecnología y técnica apropiadas. Acometereste trabajo empleando solamente el API de JDBC es muy complicado debido a la interrelación deentidades, control de restricciones en los datos, etc. Y además, todo se complica en los cambios derequisitos o en el mantenimiento de la aplicación, cuando aparecen nuevos objetos del modelo denegocio, o cuando los ya existentes cambian sus campos.Para intentar facilitar este mapeo de objetos a base de datos han aparecido infinidad detecnologías, patrones, frameworks, etc. En este tema vamos a ver, a modo de introducción, dos delas principales soluciones que existen (Hibernate y JDO).6.2 JDOEl API Java Data Objects (JDO) es un modelo de abstracción de persistencia basado eninterfaces. La tecnología JDO, desde el punto de vista del programador, es útil para persistir elmodelo de negocio en una base de datos. JDO es un modelo que tiene varias implementaciones.Los beneficios que nos proporciona JDO son los siguientes:- Facilidad de uso: Los programadores se centran en el modelo de objetos de la aplicacióndelegando la persistencia del mismo a la implementación de JDO que emplee.- Portabilidad: Las aplicaciones escritas siguiendo el API JDO pueden ser ejecutadas con lasdiferentes implementaciones sin necesidad de recompilar o cambiar código.- Independencia sobre la base de datos: Las aplicaciones escritas con el API JDO sonindependientes de la base de datos sobre la que se realice la persistencia.- Rendimiento: Las aplicaciones que emplean el API JDO pueden delegar en éste la optimizaciónde las operaciones de persistencia.- Integración con EJBs: Las aplicaciones que emplean JDO pueden aprovechar los beneficios delos EJBs como, por ejemplo, procesamiento remoto, coordinación distribuida de transacciones y6 de febrero de 2008 Tema 5 40
  • 41. seguridad.6.3 HibernateTrabajar con software orientado a objetos y bases de datos relacionales puede ser un gran problema,llegando a consumir gran parte del tiempo de desarrollo en las aplicaciones actuales. Para ello, aligual que otros muchos frameworks, Hibernate proporciona al programador un entorno quefacilita mucho el desarrollo en este tipo de aplicaciones.Hibernate es una herramienta que implementa la técnica ORMapping en entornos Java.Hibernate no solo se encarga de mapear clases Java en tablas de bases de datos, además tambiénse encarga de gestionar los tipos de datos de Java a los tipos del Sistema de Gestión de Base deDatos que se emplee (Oracle, MySQL, DB2, etc.).Además, Hibernate proporciona funcionalidades para la manipulación de datos, reduciendo engran medida el esfuerzo necesario para el desarrollo de las aplicaciones actuales.Por otro lado, Hibernate no siempre es la solución apropiada. Por ejemplo, Hibernate no es lamejor solución cuando las aplicaciones se basan en procedimientos almacenados en base de datospara implementar la lógica de negocio.Otra de las grandes ventajas es que Hibernate te aisla del Sistema de Gestion de Base de Datos.Por ejemplo, el desarrollador puede hacer su aplicación sobre Hibernate y éste se encarga de utilizarel "dialecto SQL" apropiado sobre la base de datos que situemos bajo él.Para una mayor información sobre este framework que implementa la técnica ORM visitarhttp://www.hibernate.org/152.html6 de febrero de 2008 Tema 5 41