Base de datos

Unidad 2Conexin JDBC en Aplicaciones Web

Enrique Lpez DurnDepartamento de Sistemas y Computacin

Contenido

2.1. Tipos de controladores e integracin del driverJDBC 2.2. Creacin de recursos JDBC/JNDI 2.3 Creacin del pool de conexiones 2.4 Persistencia de base de datos con EMF

2.1. Tipos de controladores e integracin del driverJDBC


JDBC (Java DataBase Connectivity) es una API estndar que permite lanzar consultas a una BD Relacional.

El desarrollador siempre trabaja con los paquetes java.sql y javax.sql Forman parte de Java SE

javax.sql formaba parte de Java EE, pero se movi a JavaSE (desde la versin 1.4 de Java SE)

Contienen un buen nmero de interfaces y algunas clases concretas, que conforman la API de JDBC

Para poder conectarse a la BD y lanzar consultas, es preciso tener un driver adecuado para ella Un driver es un fichero .jar que contiene una implementacin

de todas las interfaces de la API de JDBC El driver lo proporciona el fabricante de la BD o un tercero Nuestro cdigo nunca depende del driver, dado que siempre

trabaja contra los paquetes java.sql y javax.sql


Clases principales e interfaces para usar JDBC:

javax.sql.DataSource: Es una interfaz de JDBC para obtener conexiones a una BD.Java.sql.Connection: Este objeto representa una conexin fsica con una BD. La comunicacin entre la BD y el objeto conexin, es por un driver.Java.sql.Statement: La interfaz statement prove un mtodo para que el desarrollador ejecute sentencias a una BD.Java.sql.ResultSet: El objeto ResultSet tiene el resultado de una sentencia SQL,


EJECUCION DE SENTENCIAS Interfaz Connection

Representa una conexin a la BD prepareStatement: permite construir objetos preparedStatement para lanzar consultas

Interfaz PreparedStatement Contiene la consulta SQL parametrizada que se va a lanzar Parmetros: los caracteres ? que aparecen en la consulta Dispone de mtodos setXXX para dar valor a los parmetros

Los parmetros se numeran de 1 en adelante executeUpdate

Permite lanzar consultas SQL de actualizacin (e.g. INSERT, UPDATE, DELETE, etc.) Devuelve el nmero de filas afectadas por la actualizacin

executeQuery Permite lanzar consultas SQL de lectura (e.g. SELECT)

Cuando se lanza la consulta, el driver sustituye y formatea los parmetros correctamente En InsertExample, la consulta que se lanza en la primera iteracin del bucle es: INSERT INTO TutAccount (accId, balance)

VALUES ('user-1', 100.0) En el ejemplo, el driver entrecomilla el valor accId (porque es una cadena de caracteres)

SQLException Los mtodos de la API de JDBC reportan cualquier error lanzando esta excepcin (checked)


La interfaz ResultSet representa todas las filas que han concordado con la consulta de bsqueda

Iteracin sobre las filas La implementacin de ResultSet mantiene un cursor,

inicialmente posicionado antes de la primera fila Si no quedan filas por leer, next devuelve false En otro caso, avanza el cursor en una posicin y devuelve true

Dispone de mtodos getXXX para acceder a los valores de lascolumnas de la fila en la que est posicionado el cursor

Dado que el nmero de filas que pueden concordar con una consulta puede ser muy grande, los drivers suelen implementar ResultSet de manera que se van trayendo bloques de filas de la BD a medida que se va necesitando E.g. una invocacin a next puede originar que se traiga un bloque

de n filas, de manera que las siguientes n-1 invocaciones posteriores a next no acceden a la BD


OBTENCION DE CONEXIONES. La clase ConnectionManager proporcionada en el ejemplo facilita

la obtencin de conexiones con la API bsica de JDBC Dispone de un inicializador static

NOTA: un inicializador static en una clase Java es un bloque de cdigo que se ejecuta cuando se carga la clase en memoria (y no cada vez que se crea una instancia de dicha clase)

El inicializador static de ConnectionManager carga el driver JDBC en memoria Class.forName(DRIVER_CLASS_NAME);

NOTA: La clase Class, del paquete por defecto (java.lang), dispone del mtodo esttico forName, que a partir del nombre completo de una clase, permite cargar su cdigo en memoria


Especificar DRIVER JDBC Todo driver JDBC debe especificar cul es la clase (clase driver) que

implementa la interfaz java.sql.Driver

En el caso de MySQL es com.mysql.jdbc.Driver La clase driver tiene la obligacin de incluir un inicializador static que

registra el driver en el registro de drivers: java.sql.DriverManager java.sql.DriverManager dispone del mtodo esttico getConnection que

permite obtener una conexin a la BD a partir de Una URL (formato especificado en la documentacin del driver) que

indica la mquina en la que corre la BD y el nombre del esquema El identificador y contrasea de un usuario que tenga permisos de

acceso En una aplicacin real, para que no sea necesario modificar el cdigo

cuando se cambia de gestor de BD (e.g. de MySQL a JavaDB), el nombre de la clase driver, la URL, el usuario y la contrasea se deben leer de un fichero de configuracin


LIBERACION DE RECURSOS Las interfaces ResultSet, PreparedStatement y Connection

disponen del mtodo close() En principio, ...

Cuando se cierra una conexin, se cierran todos sus PreparedStatement asociados

Cuando se cierra un PreparedStatement, se cierran todos sus ResultSet asociados

La implementacin de la interfaz Connection debe redefinir finalize para que invoque a close en caso de que el desarrollador no lo haya hechoNOTA: finalize es un mtodo definido en Object ; el recolector de basura lo invoca antes de eliminar un objeto de memoria

En resumen, se crea la ilusin de que nunca es necesario cerrar las conexiones explcitamente


TIPOS DE SQL y JAVAResultSet y PreparedStatement proporcionan

mtodos getXXX y setXXX Cul es la correspondencia

entre tipos Java y tipos SQL? Idea bsica: un dato de tipo

Java se puede almacenar en una columna cuyo tipo SQL sea consistente con el tipo Java

Las BBDD suelen emplear nombres distintos para los tipos que proporcionan No afecta al cdigo Java

(excepto que cree tablas, lo que en general, no debe hacerse)


DATASOURCES Interfaz javax.sql.DataSource

Entre otros, dispone del mtodo getConnection DataSource dataSource = ... Connection connection = dataSource.getConnection(); Cuando se utiliza esta interfaz, el desarrollador no tiene que cargar

explcitamente el driver JDBC y especificar la URL, el usuario y la contrasea para pedir la conexin

Los servidores de aplicaciones Java y algunos frameworks ofrecen implementaciones de la interfaz DataSource A nivel de implementacin utilizan DriverManager.getConnection para

obtener las conexiones, aunque como veremos ms adelante, la estrategia puede ser compleja

Utilizan ficheros de configuracin para especificar, como mnimo, el nombre de la clase driver, la URL, el usuario y la contrasea

Tanto con Spring (framework capa modelo) como con Jetty y Tomcat (servidores de aplicaciones) configuraremos objetos DataSource para acceder a la BD

2.2. Creacin de recursos JDBC/JNDI

Los recursos JDBC se crean como parte de implementar una instancia de JNDI (Java Naming and Directory Interface) en nuestras aplicaciones web.

Se crear una conexin JDBC a una Base de Datos MySQL, utilizando JNDI, para esto se realiznr los siguientes pasos: Instalar Controlador JDBC en tomcat Definir los requerimientos de recursos. Desarrollar la clase Java que implementa el DataSource. Configurar el recurso en el Tomcat.

Probar la clase con una llamada desde una JSP.


Instalar Controlador JDBC en tomcat Descargamos la biblioteca (mysql-connector-java-5.1.26.tar.gz) desde su pgina web, la descomprimimos y copiamos en el directorio $CATALINA_HOME/lib. Solo el archivo jar.

Definir los requerimientos de recursos.Modificar el descriptor de deployment de la aplicacin web (/WEB-INF/web.xml) para declarar el nombre JNDI que buscar el DataSource preconfigurado. Por convencin todos los nombres JDNI deberan llamarse de la forma:

jdbc/nombre_jdni


#nano $CATALINA_HOME/webapps/WebApp/WEB/INF/web.xml

1)2) 3) Descripcion del recurso4) 5) 6) jdbc/CatalogoDB7) 8) 9) javax.sql.DataSource10) 11) 12) Container13) 14)


Desarrollar la clase Java que implementa el DataSource

.

package test.db;import java.sql.Connection;import javax.naming.Context;import javax.naming.InitialContext;import javax.sql.DataSource;/* Clase para realizar la conexion a BD por medio de jndi */public class DBConn {public String getConnection() throws Exception{ String name = "java:/comp/env/jdbc/CatalogoDB"; Context ctx = null; DataSource ds = null; Connection conn = null; try { ctx = new InitialContext(); ds = (DataSource) ctx.lookup(name); conn = ds.getConnection(); // Devolvemos el nombre del Catalogo que accesamos return conn.getCatalog(); } catch (Exception e) { throw new Exception("Error al localizar el DataSource, " + name +, e); } }}


Configurar el recurso en el Tomcat.Para definir el recurso en Tomcat, especificamente en el archivo de Contexto ($CATALINA_HOME/conf/context.xml) por medio del elemento


Probar la clase con una llamada desde una JSP.

Conectando a BD

Nombre de la Base de Datos:

2.3 Creacin del pool de conexiones

Problema Servidor de aplicaciones que recibe muchas peticiones HTTP por minuto Es posible pedir una conexin a la BD con DriverManager.getConnection o

el mtodo getConnection de un objeto DataSource DriverManager.getConnection pide una conexin directamente a la BD

Es una operacin lenta => se convierte en cuello de botella En una implementacin bsica de DataSource, el mtodo getConnection

tambin invoca DriverManager.getConnection Adems, con cualquiera de los dos mtodos, si en ese momento la BD ya no

admite ms conexiones (porque se supera el mximo permitido), los mtodos getConnection devuelven una excepcinSolucin: pool de conexiones

Los servidores de aplicaciones Java proporcionan implementaciones de DataSource que utilizan la estrategia pool de conexiones

El objeto DataSource gestiona un conjunto de conexiones que previamente ha solicitado a la BD

El desarrollador slo trabaja contra la interfaz DataSource La estrategia es transparente al desarrollador


Esquema


ConnectionPool Se crea, cuando pide n conexiones a la BD (usando

DriverManager.getConnection) y las almacena en una lista GetConnection

Si quedan conexiones libres en la lista, elige una, la marca como usada, y devuelve un objeto ConnectionProxy que la contiene

En otro caso, deja durmiendo (wait) al thread llamador ReleaseConnection

Devuelve la conexin a la lista, la marca como libre, y notifica (notifyAll) a los posibles threads que esperan por una conexin

ConnectionProxy Proxy de la conexin real

Close Usa releaseConnection para devolver la conexin real al pool

Finalize Si no se ha llamado a ConnectionProxy.close, lo llama

Resto de operaciones Delegan en la conexin real


ConnectionPool Observaciones

Cuando el desarrollador invoca getConnection sobre el objeto DataSource

Si hay una conexin libre => se le devuelve rpidamente de la lista (no se accede a BD)

Si no hay ninguna conexin libre => el thread llamador se queda dormido hasta que haya una

La conexiones reales no se cierran (se devuelven al pool) Cadas de la BD

Si la BD se cae, las conexiones del pool se invalidan aunque se vuelva a rearrancar la BD (porque los sockets subyacentes ya no son vlidos)

Para hacer frente a este problema, la implementacin de getConnection puede comprobar si la conexin que devuelve es correcta (est viva)

Opcin 1: haciendo uso de una API especfica del fabricante del driver Opcin 2: lanzando una consulta poco costosa a la BD (si no secproduce

una SQLException, la conexin es correcta)


Configuracin y creacin del ConnectionPoolAdems de la configuracin bsica de un DataSource, se puede especificar el nm. de conexiones a la BD al inicio, la consulta de comprobacin de conexin activa,etc.

package modelo;import java.sql.*;import java.util.*;public class ConnectionPool { private Hashtable connections; private int increment; private String dbURL, user, password; public ConnectionPool(String dbURL,String user,String password, String driverClassName,int initialConnections,int increment) throws SQLException, ClassNotFoundException {

Class.forName (driverClassName); // Cargar el driver this.dbURL = dbURL; this.user = user;this.password = password; this.increment = increment;connections = new Hashtable();for(int i = 0; i < initialConnections; i++) { connections.put(DriverManager.getConnection(dbURL,user, password),

Boolean.FALSE);}

}::::


Creacin del ConnectionPool (Continuacin)package modelo;public class ConnectionPool { :::: public Connection getConnection() throws SQLException { Connection con = null; Enumeration cons = connections.keys(); synchronized (connnections) {

while(cons.hasMoreElements()) { con = (Connection)cons.nextElement();

Boolean b = (Boolean)connections.get(con); if (b == Boolean.FALSE) { try { con.setAutoCommit(true);}

catch(SQLException e) { con = DriverManager.getConnection(dbURL, user, password);

} connections.put(con, Boolean.TRUE); return con;}

}}

for(int i = 0; i < increment; i++) {connections.put(DriverManager.getConnection(dbURL, user, password),Boolean.FALSE);

} return getConnection(); }::::


Creacin del ConnectionPool (Continuacin 2)

package modelo;public class ConnectionPool { :::: public void returnConnection(Connection returned) {

Connection con;Enumeration cons = connections.keys();while (cons.hasMoreElements()) {

con = (Connection)cons.nextElement();if (con == returned) {

connections.put(con, Boolean.FALSE);break;

}}

} }//fin de ConnectionPool


package controlador;import java.io.IOException;import java.io.PrintWriter;import java.sql.Connection;import java.sql.Statement;import javax.servlet.ServletConfig;import javax.servlet.ServletException;import javax.servlet.UnavailableException;import javax.servlet.annotation.WebServlet;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import modelo.ConnectionPool;@WebServlet(name = "OrderHandlerPool", urlPatterns = {"/OrderHandlerPool"})public class OrderHandlerPool extends HttpServlet { private ConnectionPool pool; @Override

public void init(ServletConfig config) throws ServletException {super.init(config);

Try { pool = new ConnectionPool("jdbc:mysql://localhost:3306/noticias", "root", "root", com.mysql.jdbc.Driver", 10, 5);

}catch (Exception e) { throw new UnavailableException(this, "Couldn't create connection pool");}

}

2.3 Creacin del pool de conexiones Servlet que usa el ConnectionPool.

protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { response.setContentType("text/html;charset=UTF-8"); PrintWriter out = response.getWriter(); Connection con = null;

try { con = pool.getConnection();// Turn on transactionscon.setAutoCommit(false);Statement stmt = con.createStatement();stmt.executeQuery ("SELECT * FROM noticias");//chargeCard(); method doesn t actually exist...con.commit();out.println("Order successful! Thanks for your business!");

}catch (Exception e) {

// Any error is grounds for rollbacktry { con.rollback();}catch (Exception ignored) { }out.println("Order failed. Please contact technical support.");

} finally { if (con != null) pool.returnConnection(con); } }

2.3 Creacin del pool de conexionesJSP que invoca al servlet.

JSP para invocar a un servlet que usa un pool de conexiones JSP para invocar a un servlet que usa un pool de conexiones

2.4 Persistencia de base de datos con EMF

EMF= Entity Manager Factory

La Entidades son clases que requieren ser persistentes, usualmente es una case de datos relacional

Entidades EJB 3 Java persistence API Mapear una entidad a una tabla de una base de datos Metadatos default Introduccin al entity manager Empacar y deploying entidades Generando llaves primarias Sobrecarga de metadatos default


La Entidades son clases que requieren ser persistentes, usualmente es una case de datos relacionalTemas Entidades EJB 3 Java persistence API Mapear una entidad a una tabla de una base de datos Metadatos default Introduccin al entity manager Empacar y deploying entidades Generando llaves primarias Sobrecarga de metadatos default


Entidades EJB 3En la API de Persistencia de Java (JPA), cualquier clase o POJO (Plain Old Java Object) puede ser convertidos a una entidad con pocas modificaciones. El siguiente listado muestra la entidad Customer.java .

package ejb30.entity;import javax.persistence.Entity;import javax.persistence.Id;@Entitypublic class Customer implements java.io.Serializable {

private int id;private String firstName;private String lastName;public Customer() {}@Idpublic int getId() { return id; }public void setId(int id) { this.id = id; }public String getFirstname() { return firstName; }public void setFirstname(String firstName) {this.firstName = firstName;}public String getLastname() { return lastName; }public void setLastname(String lastName) {this.lastName = lastName;}public String toString() {return "[Id Cliente=" + id + ",Nombre=" + firstName + lastName + "]";}

}


Introduccin al EntityManagerLa interfaz al bean de sesin se llama BankService. Solo tiene una entidad y los mtodos de negocio addCustomer() y findCustomer(), que agregan clientes a una base de datos y recuperan una entidad de cliente dado un identificador.El listado de la interfaz es:

package ejb30.session;import javax.ejb.Remote;import ejb30.entity.Customer;@Remotepublic interface BankService {

void addCustomer(int custId, String firstName, String lastName);Customer findCustomer(int custId);

}

2.4 Persistencia de base de datos con EMF El listado de la implementacin del bean de sesin de nombre

BankServiceBean es:package ejb30.session;import javax.ejb.Stateless;import javax.persistence.EntityManager;import ejb30.entity.Customer;import javax.persistence.PersistenceContext;

@Statelesspublic class BankServiceBean implements BankService {

@PersistenceContext(unitName="BankService")private EntityManager em;public Customer findCustomer(int custId) {return ((Customer)em.find(Customer.class, custId));

}public void addCustomer(int custId, String firstName, String lastName) {

Customer cust = new Customer();cust.setId(custId);cust.setFirstname(firstName);cust.setLastname(lastName);em.persist(cust);

}}


Considerando la anotacin @PersistenceContext que se usa en el bean de sesin BankService. Se crea un archivo de XML que almacena la configuracin actual de persistencia, es llamado, persistence.xml, Un ejemplo es:


EJB 3 provee el Lenguaje de Consultas para Persistencia en Java (JPQL). Que abarca los siguientes capacidades:ProyeccionesClausulas GROUP BY y HAVINGJoinsSubqueriesQueries DinamicosFuncionesQueries con parmetrosManejo de fecha y horaOperaciones de actualizacin y borrado en masa SQL Nativo.


Obtener las instancias de la entidad Customer se usa el query: SELECT c FROM Customer cDonde c es una variable identificador para JPQL. El tipo de dato regresado por un query:JPQL es un listado de entidades de Customer. JDBC es un ResultSet.

El query pueden crearse dinmicamente en tiempo de ejecucin con un argumento invocando el mtodo EntityManager.createQuery(String q) que regresa una instancia de javax.persistence.Query:

Query query = em.createQuery("SELECT c FROM Customer c");

La alternativa a especificar querys dinmicos es usar querys nombrados.


Como el query anterior, regresa una lista, se puede usar el mtodo Query.getResultList() para ejecutar el query:

List customers = query.getResultList();

Si el query regresado es un sola instancia, se usa el mtodo Query.getSingleResult()

Se puede crear un mtodo simpleQuery(), con los dos mtodos anteriores encadenndolos uno en otro. El mtodo simpleQuery() se colocaria en el bean de sesin BankServiceBean:

public List simpleQuery() {return (List)em.createQuery("SELECT c FROM Customer c").getResultList();

}


Las caractersticas principales de Entity Manager son:

Manejo del entity manager por la aplicacin Manejo del entity manager por el contenedor Mtodos del entity manager Operaciones en Cascada Contexto de persistencia extendida Ciclo de vida de entidad de mtodos de retorno Clases del entity listener

Las aplicaciones hacen uso de los entity managers donde el ciclo de vida es manejado por el contenedor EJB3. Para permitir situaciones donde no se requiera los servicios ofrecidos por un contenedor EJB 3 pero podran usar el modelo de persistencia, La API de Persistencia de Java proveda por los manejadores de entidad de la aplicacin.


Listado de BankClient, agrega un cliente a la BD y lo recupera:public class BankClient {

public static void main(String[] args) {EntityManagerFactory emf = Persistence.createEntityManagerFactory("BankService");EntityManager em = emf.createEntityManager();int custId = 0; String firstName = null; String lastName = null;try {custId = Integer.parseInt(args[0]); firstName = args[1]; lastName = args[2];} catch (Exception e) {

System.err.println("Invalid arguments entered, try again"); System.exit(0);}addCustomer(em, custId, firstName, lastName);Customer cust = em.find(Customer.class, custId);System.out.println(cust);em.close(); emf.close();

}private static void addCustomer(EntityManager em, int custId, String firstName, String lastName) {

EntityTransaction trans = em.getTransaction();trans.begin();

Customer cust = new Customer();cust.setId(custId); cust.setFirstname(firstName); cust.setLastname(lastName);em.persist(cust);

trans.commit();}

}


Se necesita modificar el archivo persistence.xml para indicar que se esta usando recursos de transacciones locales en entorno de Java SE.

ejb30.entity.Customer


Los mtodos del Entity Manager:remove()El mtodo remove() marca una entidad para removerla de BD. Note la entidad debe ser una entidad manejada. La eliminacin debe llevarse inmediatamente, cuando el EntityManager sincroniza o limpiar (flush) el contexto de persistencia con la BD. Normalmente ocurre cuando una transaccin es comprometida (committed).Listado del mtodo removeCustomer() de BankServiceBean.

contains()Usado para checar si una entidad es manejada por el acutal contexto de persistencia. Regresa true si la entidad es manejada, en otro caso es false:

public void removeCustomer(Customer cust) {Customer mergedCust = em.merge(cust);em.remove(mergedCust);

}

if (em.contains(cust)) {System.out.println("cust is managed");

}


flush()Vacia o sincroniza un contexto de persistencia con la BD, que esta bajo control del entity manager. El vaciado ocurre al tiempo commit de una una transaccin, Aunque el entity manager puede vaciar en otras ocasiones, tal como, antes de la ejecucin de un query,

setFlushMode()Por default, cuando un query es ejecutado dentro de una transaccin el entity manager asegura que cualquier actualizacin a la BD este incluida en el resultado del query. El modo AUTO de vaciado es hecho antes de ejecutar el query. Un modo vaciado de COMMIT causa vaciar solo en el commit de una transaccin. Esto mejora el desempeo del query porque hay pocas llamadas a la BD. Se debe usar si se conoce que el query no es afectado por potenciales actualizaciones a la BD. El modo vaciado se establece en el entity manager usando el mtodo setFlushMode(). Se aplica a todos los querys. El mtodo setFlushMode() espera un argumento: FlushModeType.COMMIT o FlushModeType.AUTO. Por ejemplo:em.setFlushMode(FlushModeType.COMMIT);

Para establecer el modo de vaciar un objeto query sera:

Query query = em.createQuery("SELECT c FROM Customer c WHERE c.id = ?1").setParameter(1, custId) ;query.setFlushMode(FlushModeType.AUTO);


refresh()El mtodo es usado donde se quiere asegurar que cualquier cambio a la BD esta sincronizado con la entidad manejada: em.refresh(mergedCust);

clear()El mtodo limpia el contexto de persistencia, Causa que todas las entidades manejadas sean desconectadas: em.clear()Notar que cualquier actualizacin no puede ser vaciada a la BD por este mtodos

Fundamental Physics at ESAOverviewDiapositiva 3Diapositiva 4Diapositiva 5Diapositiva 6Diapositiva 7Diapositiva 8Diapositiva 9Diapositiva 10Diapositiva 11Diapositiva 12Diapositiva 13Diapositiva 14Diapositiva 15Diapositiva 16Diapositiva 17Diapositiva 18Diapositiva 19Diapositiva 20Diapositiva 21Diapositiva 22Diapositiva 23Diapositiva 24Diapositiva 25Diapositiva 26Diapositiva 27Diapositiva 28Diapositiva 29Diapositiva 30Diapositiva 31Diapositiva 32Diapositiva 33Diapositiva 34Diapositiva 35Diapositiva 36Diapositiva 37Diapositiva 38Diapositiva 39Diapositiva 40Diapositiva 41Diapositiva 42Diapositiva 43

Base de datos

Documents

Transcript of Base de datos