II Curso Online JAVA-J2EE
TEMA 5
ORM, Persistencia de Datos
Autor: PCYTA / Centro de Excelencia de Software Libre de Castilla-La Mancha Versión: 1.0
Fecha: Revisado 26-02-2008 22:46 Licencia: CC-by-sa 2.5
0 Licencia
Usted es libre de:
C
opiar, 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 el uso 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:
UNIDAD II. ORM, Persistencia de Datos
0 Licencia... 2
1 SQL...5
2 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 ... 9
3 Instalacion de MySQL... 11
4 Ejemplo de JDBC en Aplicaciones JAVA... 21
5 Ejemplo de JDBC en Aplicaciones J2EE... 28
6 Frameworks... 40
6.1 Introducción... 40
6.2 JDO... 40
INTRODUCCIÓN
Como veíamos durante temas anteriores, uno de los modelos a seguir más habituales a la hora de desarrollar aplicaciones es el modelo de tres capas.
Estas capas eran:
• capa de presentación
• capa de lógica de negocio
• capa de datos
Las dos primeras ya hemos visto como desarrollarlas mediante el empleo de tecnologías como HTML, JavaScript, CSS, JSPs, Servlets, EJBs (lo veremos en el siguiente tema), etc. En este tema nos vamos a centrar en algunas de las tecnologías que se suelen emplear a la hora de desarrollar la capa de datos.
Object-Relational Mapping (abreviado como ORM, O/RM y O/R Mapping) es una técnica de programación para mapear datos de lenguajes de programación orientados a objetos (como Java) a bases de datos relacionales (como Oracle, MySQL, DB2, etc.).
Sigamos con nuestro ejemplo de la tienda virtual. Tenemos el concepto usuario, que tiene asociados datos como nombre, dirección y dni. Para implementar esto en nuestra tienda virtual tendríamos que tener una clase "Usuario" con esos campos y tendríamos que tener una tabla "Usuarios" donde almacenar esos datos. Y por último, deberíamos implementar la funcionalidad necesaria para relacionar los campos de base de datos con los campos de la clase "Usuario". Esta funcionalidad para "mapear" campos de base de datos con campos de objetos se realiza mediante la técnica ORM.
La técnica ORM es un modelo a seguir, existiendo un gran número de entornos que nos ayudan a la hora de aplicar esta técnica. En los siguientes apartados de este tema veremos algunos de ellos y varias tecnologías útiles a la hora de manipular la capa de datos.
1 SQL
SQL (Structured Query Language) es un lenguaje diseñado principalmente para la
manipulación de datos en bases de datos relacionales y modificación de esquemas de bases de datos (tablas, índices, vistas, etc.).
Este lenguaje fue estandarizado por las organizaciones ANSI e ISO y hoy en día es el empleado en 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 este
conocimiento es prácticamente indispensable para continuar con el tema. Para este estudio visitad enlaces como http://www.programacion.com/bbdd/tutorial/sql/ para ver SQL genérico y mirad
http://dev.mysql.com/doc/refman/5.0/en/sql-syntax.html para ver SQL con los comandos específicos de MySQL.
Por otro lado, en el caso de que sí lo conozcáis, tampoco es mala idea hacer un repaso al segundo enlace de los antes indicados ya que explica cosas que son propias de MySQL, las cuales no conoceré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 la que usaremos. Aunque SQL es un estándar, cada base de datos suele introducir algunas
variantes tanto en tipos de datos como en ciertas sentencias, pero siempre manteniendo la base de SQL.
2 JDBC
2.1 Introducción
JDBC (Java Database Connectivity) es un API que permite la ejecución de operaciones sobre bases de datos desde el lenguaje de programación Java.
El API JDBC es una especificación del interfaz que debe emplear el programador que quiere operar sobre la base de datos. Cada distribuidor de bases de datos tiene que ofrecer a los desarrolladores que las van a emplear una implementación de ese API(también llamado driver).
En nuestro ejemplo de la tienda virtual vamos a usar MySQL como sistema de gestión de bases de datos, 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 nos
proporcionen. 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 sobre ella. Más adelante pondremos un ejemplo en el que se instalará el sistema de gestión de base de datos (MySQL), se creará una base de datos de ejemplo con unas tablas y luego realizaremos mediante JDBC algún acceso a la misma.
2.2 Conexión a una Base de Datos
Imaginemos que nos proporcionan una base de datos con sus tablas. Lo primero que deberíamos realizar para trabajar con ella es conectarnos. Para ello debemos realizar dos pasos, la carga del driver 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 de MySQL, según la documentación, sería:
Class.forName("com.mysql.jdbc.Driver");
Una vez cargado el driver, ya podemos realizar la conexión.
- Realizar la conexión: Para realizar la conexión deberíamos escribir una línea de código como la siguiente.
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. En nuestro 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 Sentencia
Un objeto de la clase Statement (definida en el API JDBC) es el que envía nuestras sentencias SQL al controlador de la base de datos. Por lo tanto, para lanzar una sentencia SQL simplemente creamos un objeto Statement y lo ejecutamos pasándole por parámetro la sentencia SQL. Si la sentencia SQL es un SELECT (no modifica datos), el método a ejecutar es executeQuery. Si la sentencia 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 SU CONTENIDO);
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íneas modificadas mientras que "executeQuery(…)" devuelve un "ResultSet" que contiene el conjunto de 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 recorre con las funciones que ofrece "ResultSet". A continuación vemos un ejemplo que muestra este funcionamiento:
ResultSet rs = stmt.executeQuery(SENTENCIA SQL DE TIPO SELECT); while (rs.next()) {
}
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íamos
rs.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.html
Con esto tenemos la idea principal de como trabajar sobre una base de datos con java. Ahora
veremos algunos otros conceptos importantes y, más adelante, realizaremos un par de ejemplos muy sencillos 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 enviar sentencias SQL a la base de datos en vez de los antes vistos "Statement". Este tipo especial de sentencias extiende el interfaz "Statement".
Es más conveniente cuando queremos ejecutar muchas veces un objeto "Statement". En ese caso, 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 la mayoría de los casos, esta sentencia SQL se enviará al controlador de la base de datos
inmediatamente donde será compilada. Como resultado, el objeto "PreparedStatement" no sólo contiene una sentencia SQL, sino una sentencia SQL que ha sido precompilada. Esto significa que cuando se ejecuta la PreparedStatement, el controlador de base de datos puede ejecutarla sin tener que 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 ventaja de utilizar sentencias SQL que utilizan parámetros es que podemos utilizar la misma sentencia y suministrar distintos valores cada vez que la ejecutemos. A continuación vemos código que muestra el uso de un "PreparedStatement".
PreparedStatement pstmt = con.prepareStatement("SELECT * FROM NOMBRE_TABLA WHERE NOMBRE_CAMPO1=? AND NOMBRE_CAMPO2=?");
pstmt.setString(1,"valor_campo1"); pstmt.setInt(2,78);
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 que debemos saber. Aún así, todavía hay un aspecto muy importante a la hora de trabajar sobre bases de datos, 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 Transaccionalidad
Como bien conocemos, las operaciones sobre bases de datos tienen un aspecto muy importante, la transaccionalidad. Para gestionarla, una de las principales herramientas de las que disponemos es la propiedad booleana denominada "AutoCommit" que tienen las conexiones que creamos a una 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. A
continuación vemos un ejemplo de asignación del valor de "AutoCommit": //con es la conexión obtenida anteriormente
con.setAutoCommit(false);
Imaginemos ahora un ejemplo sobre nuestra tienda virtual. Hemos realizado una venta con lo que tenemos que ejecutar dos operaciones, por un lado la inserción de un nuevo pedido en la tabla de pedidos y por otro lado actualizar el almacén eliminando del stock los productos vendidos en el pedido. Evidentemente para que la base de datos no quede inconsistente, estas dos operaciones se tienen que ejecutar, no nos vale, por ejemplo, que se ejecute la primera y la segunda falle. Para resolver este problema, una solución sencilla es fijar el "AutoCommit" a "false", ejecutar las operaciones, hacer el "Commit" y finalmente establecer de nuevo el AutoCommit a "true".A continuación se muestra el código que realizaría esas operaciones:
//con es la conexión obtenida anteriormente con.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();
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 las operaciones 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 base de datos se ejecuten de forma atómica, que es uno de los principios básicos del trabajo sobre base de datos.
3 Instalacion de MySQL
En este momento ya sabemos SQL y sabemos programar en Java para trabajar sobre bases de datos mediante JDBC. Pero, evidentemente, necesitamos una base de datos sobre la que hacer nuestras pruebas 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 de
aquí), descomprimirlo y ejecutarlo. Para tener la instalación que vamos a utilizar en el curso, sigue los siguientes pasos:
Selecciona "Typical" y pulsa "Next".
Pulsa "Next".
Marca la casilla que te llevará a configurar la base de datos y pulsa "Next".
Marca "Detailed Configuration" y pulsa "Next".
Selecciona "Multifunctional Database" y pulsa "Next"
Selecciona "Decisión Support" y pulsa "Next".
Selecciona "Standard Character Set" y pulsa "Next".
Indica que se instale como servicio y que se arranque automáticamente. Así no tendrás que levantar la base de datos cada vez que se arranques el ordenador. Pulsa "Next".
Establece una contraseña, por ejemplo "password", y no habilites el acceso como root desde otras máquinas. Pulsa "Next".
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 que trabaje sobre esa base de datos.
4 Ejemplo de JDBC en Aplicaciones JAVA
Hasta el momento hemos visto en qué consiste la técnica ORM y hemos visto la utilización básica de JDBC. Con estos conceptos y con los conocimientos de SQL que tenemos, ya estamos listos para hacer 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 a seguir es crear una base de datos con una tabla que tenga unos campos. Después crearemos una aplicación JAVA que se conecte a esa base de datos, que inserte unos cuantos registros, que luego los 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 antes en el tema. Para hacerlo, conectémonos a ella desde una ventana de MS-DOS, situándonos en el directorio "bin" de nuestra instalación de MySQL y ejecutando la instrucción "mysql -u root -p" e introduciendo 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 imagen para crear una base de datos, para activar su uso y para crear una tabla en ella.
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 la ventana 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 los siguientes pasos:
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 lo tienes o no estás seguro pincha aquí para descargar el driver). Finalmente te debe quedar la pantalla como muestra la siguiente imagen.
Cuando hayas seleccionado el driver, pincha Finish.
Una vez creado el proyecto, creemos una clase con el método "main" como se muestra en la siguiente imagen:
Pincha en Finish.
Meter el código apropiado en la clase para que quede como sigue (es suficiente si sustituyes el contenido 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 {
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. En la consola el resultado que debemos obtener es el siguiente:
inicio
Nombre: Toñito, Apellidos: Garcia Nombre: Pepito, Apellidos: Pérez López Número de registros tras el borrado: 0 fin
Pues ya hemos visto un ejemplo sencillo de uso de JDBC. Ahora llega el momento de que
experimentes. Prueba con "PreparedStatement", con transacciones, crea campos de tipos distintos a cadenas de texto (fechas, valores enteros, decimales, etc.).
5 Ejemplo de JDBC en Aplicaciones J2EE
En una aplicación Web. Perfectamente podríamos meter el código del ejemplo anterior en un servlet de modo que se ejecutara cuando es llamado, pero ésta no es la forma más correcta de hacerlo 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 la conexión. La razón es que cuando se establece una conexión, el sistema de gestión de bases de datos (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 se ejecutarí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 establecidas y 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 que hará será pedirle al servidor de aplicaciones que nos dé una y la utilizará, consiguiendo así una optimización muy importante y básica en las aplicaciones actuales. Tras su utilización, la aplicación la 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 el interfaz 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 con base 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 los siguientes pasos.
Selecciona en el cuadro de diálogo de "New Project" el tipo "Web-Dynamic Web Project". Luego pulsa Next.
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 siguiente imagen:
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 del pool pero primero creemos el pool mediante la definición de un datasource. Para ello, creemos el fichero context.xml dentro del directorio META-INF que será el fichero que leerá el servidor de aplicaciones. Mediante este fichero le decimos al servidor que cree el datasource. El contenido del fichero 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>
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 el directorio 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 su contraseña es "password".
- El resto de parámetros son de configuración y optimización pero escapan de los objetivos del curso.
Con este fichero ya tenemos definido el datasource que nos crea el pool de conexiones, solo nos falta, 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.14\lib") tal y como dice la documentación de MySQL.
Pues ya tenemos preparado el servidor para que cree el datasource al arrancar la aplicación. Ahora tenemos que meter el código para usarlo. Para ello, modificamos el servlet para que quede como el siguiente 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 implements javax.servlet.Servlet {
static final long serialVersionUID = 1L; /* (non-Java-doc)
* @see javax.servlet.http.HttpServlet#HttpServlet() */
super(); }
/* (non-Java-doc)
* @see javax.servlet.http.HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
*/
protected void doGet(HttpServletRequest request, HttpServletResponse response) 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));
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 ejemplo de aplicación java se cargaba el driver y se le pedía la conexión, en J2EE, para aprovechar la optimización del pool, debemos buscar por JNDI el datasource y a ese datasource le debemos pedir la conexión.
Por ahora ya tenemos el datasource creado y el código que lo usa, ahora nos falta definir el servlet y el datasource en el fichero web.xml y después probar. Para ello, el fichero web.xml debe quedar del siguiente 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/javaee http://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>
</resource-ref> </web-app>
Ya ha llegado el momento de probarlo, para ello añadamos el proyecto al tomcat del siguiente modo:
Añadir el proyecto y pinchar Finish
Y ahora… arranquemos el servidor de aplicaciones, recemos y abramos un navegador donde pediremos esta url: http://localhost:8080/cursoJDBCWeb/CursoServlet
El resultado deberá ser una pantalla en blanco ya que no hemos añadido nada de presentación pero lo importante es que se ejecutará el código que hemos introducido en el servlet sacando por la consola del servidor las siguientes líneas:
Entrada en el servlet
Nombre: Toñito, Apellidos: Garcia Nombre: Pepito, Apellidos: Pérez López Número de registros tras el borrado: 0 Salida del servlet
Como 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 ejemplo de JDBC sobre Java.
6 Frameworks
6.1 Introducción
Con lo visto hasta el momento en el tema, ya somos capaces de trabajar sobre una base de datos consiguiendo así que los datos que maneja nuestra aplicación se persistan. Realmente lo que estamos haciendo es mapear los datos de nuestros objetos de modelo de negocio en una base de datos relacional.
La tarea del mapeo de objetos a base de datos dentro de un proyecto de cierta envergadura es una de las más laboriosas y más aún si no usamos la tecnología y técnica apropiadas. Acometer este trabajo empleando solamente el API de JDBC es muy complicado debido a la interrelación de entidades, control de restricciones en los datos, etc. Y además, todo se complica en los cambios de requisitos o en el mantenimiento de la aplicación, cuando aparecen nuevos objetos del modelo de negocio, o cuando los ya existentes cambian sus campos.
Para intentar facilitar este mapeo de objetos a base de datos han aparecido infinidad de tecnologías, patrones, frameworks, etc. En este tema vamos a ver, a modo de introducción, dos de las principales soluciones que existen (Hibernate y JDO).
6.2 JDO
El API Java Data Objects (JDO) es un modelo de abstracción de persistencia basado en interfaces. La tecnología JDO, desde el punto de vista del programador, es útil para persistir el modelo 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ón delegando la persistencia del mismo a la implementación de JDO que emplee.
- Portabilidad: Las aplicaciones escritas siguiendo el API JDO pueden ser ejecutadas con las diferentes implementaciones sin necesidad de recompilar o cambiar código.
- Independencia sobre la base de datos: Las aplicaciones escritas con el API JDO son independientes 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ón de las operaciones de persistencia.
seguridad.
6.3 Hibernate
Trabajar 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, al igual que otros muchos frameworks, Hibernate proporciona al programador un entorno que facilita 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én se encarga de gestionar los tipos de datos de Java a los tipos del Sistema de Gestión de Base de Datos que se emplee (Oracle, MySQL, DB2, etc.).
Además, Hibernate proporciona funcionalidades para la manipulación de datos, reduciendo en gran 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 la mejor solución cuando las aplicaciones se basan en procedimientos almacenados en base de datos para 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 utilizar el "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 visitar
