2.1 Tutorial de JDBC

Transcripción

1 2.1 Tutorial de JDBC

2 Índice Introducción Accesos básicos Tipos SQL y Java DataSources Pool de conexiones Transacciones Otros temas

3 Introducción JDBC (Java DataBase Connectivity) es un API que permite lanzar queries a una base de datos relacional Su diseño está inspirado en dos conocidas APIs ODBC (Open DataBase Connectivity) X/OPEN SQL CLI (Call Level Interface) El programador siempre trabaja contra los paquetes java.sql y javax.sql Forma parte de J2SE javax.sql formaba parte de J2EE, pero se movió a J2SE (desde la versión 1.4 de J2SE) Contienen un buen número de interfaces y algunas clases concretas, que conforman el API de JDBC Para poder conectarse a la BD y lanzar queries, es preciso tener un driver adecuado para ella Un driver suele ser un fichero.jar que contiene una implementación de todos los interfaces del API de JDBC Nuestro código nunca depende del driver, dado que siempre trabaja contra los paquetes java.sql y javax.sql

4 Driver JDBC Aplicación <<use>> <<use>> java.sql javax.sql BD <<access>> Driver JDBC

5 Tipos de drivers (1) Driver Tipo 1 (ej.: bridge JDBC-ODBC) <<use>> API nativa estándar (ej.: ODBC) <<access>> Driver Tipo 2 (ej: Oracle OCI) <<use>> API nativa BD (normalmente en C/C++) <<access>> <<access>> BD Driver Tipo 3 <<use>> Servidor con API genérica Driver Tipo 4 (ej: Oracle thin) <<access>>

6 Tipos de drivers (y 2) Comentarios Los drivers de tipo 1 y 2 llaman a APIs nativas mediante JNI (Java Native Interface) => requieren que la máquina en la que corre la aplicación tenga instaladas las librerías de las APIs nativas (.DLL,.so) Los drivers de tipo 3 y 4 son drivers 100% Java La ventaja de un driver de tipo 3 es que una aplicación puede usarlo para conectarse a varias BDs Pero esto también se puede conseguir usando un driver distinto (de los otros tipos) para cada BD Eficiencia: en general, los drivers más eficientes son los de tipo 2

7 Independencia de la BD Idealmente, si nuestra aplicación cambia de BD, no necesitamos cambiar el código; simplemente, necesitamos otro driver Sin embargo, desafortunadamente las BDs relacionales usan distintos dialectos de SQL ( a pesar de que en teoría es un estándar!) Tipos de datos: varían mucho según la BD Generación de identificadores: secuencias, autonumerados, etc. Veremos patrones para hacer frente a este problema Usaremos interfaces para el acceso a BD, de manera que se puedan construir adaptadores para distintas BDs, proporcionando implementaciones por defecto con SQL estándar cuando sea posible

8 Ejemplo de actualización: es.udc.fbellas.j2ee.jdbctutorial.insertexample (1) package es.udc.fbellas.j2ee.jdbctutorial; import java.sql.connection; import java.sql.statement; Import java.sql.drivermanager; import java.sql.sqlexception; public final class InsertExample { public static void main (String[] args) { Connection connection = null; Statement statement = null; try { /* Get a connection. */ String driverclassname = "com.mysql.jdbc.driver"; String driverurl = "jdbc:mysql://localhost/j2ee"; String user = "j2ee"; String password = "j2ee"; Class.forName(driverClassName); connection = DriverManager.getConnection(driverUrl, user, password);

9 Ejemplo de actualización: es.udc.fbellas.j2ee.jdbctutorial.insertexample (2) /* Create data for some accounts. */ String[] accountidentifiers = new String[] {"fbellas-1", "fbellas-2", "fbellas-3"; double[] balances = new double[] {100.0, 200.0, 300.0; /* Create "statement". */ statement = connection.createstatement(); /* Insert the accounts in database. */ for (int i=0; i<accountidentifiers.length; i++) { /* Execute query. */ String querystring = "INSERT INTO TutAccount " + "(accid, balance) VALUES ('" + accountidentifiers[i] + "', " + balances[i] + ")"; int insertedrows = statement.executeupdate(querystring); if (insertedrows!= 1) { throw new SQLException(accountIdentifiers[i] + ": problems when inserting!!!!");

10 Ejemplo de actualización: es.udc.fbellas.j2ee.jdbctutorial.insertexample (y 3) catch (SQLException e) { e.printstacktrace(); finally { try { if (statement!= null) { statement.close(); if (connection!= null) { connection.close(); catch (SQLException e) { e.printstacktrace(); // try // main // class

11 Ejemplo de búsqueda: es.udc.fbellas.j2ee.jdbctutorial.selectexample (1) public final class SelectExample { public static void main (String[] args) { Connection connection = null; Statement statement = null; ResultSet resultset = null; try { /* Get a connection. */ <<... >> /* Create "statement". */ statement = connection.createstatement(); /* Execute query. */ String querystring = "SELECT accid, balance FROM " + "TutAccount"; resultset = statement.executequery(querystring);

12 Ejemplo de búsqueda: es.udc.fbellas.j2ee.jdbctutorial.selectexample (2) /* Iterate over matched rows. */ while (resultset.next()) { int i = 1; String accountidentifier = resultset.getstring(i++); double balance = resultset.getdouble(i++); System.out.println("accountIdentifier = " + accountidentifier + " balance = " + balance); catch (SQLException e) { e.printstacktrace();

13 Ejemplo de búsqueda: es.udc.fbellas.j2ee.jdbctutorial.selectexample (y 3) finally { try { if (resultset!= null) { resultset.close(); if (statement!= null) { statement.close(); if (connection!= null) { connection.close(); catch (SQLException e) { e.printstacktrace(); // try // main // class

14 Cargar el driver Comentarios (1) Su inicializador static registra el driver en DriverManager En una aplicación real El nombre de la clase del driver, la URL (depende del driver), el nombre de usuario y la contraseña deberían ser configurables (ej.: leerlos de un fichero de configuración) Existe una alternativa mejor a DriverManager (javax.sql.datasource) ResultSet es un proxy sobre las filas que han concordado en la búsqueda El driver no tiene porque traer de golpe todas las filas a memoria Un buen driver leerá las filas por bloques, leyendo un nuevo bloque cada vez que se intenta leer una fila que no está en memoria (quizás eliminando de memoria el bloque anterior)

15 Comentarios (2) DriverManager +manages 0..n <<Interface>> Driver <<instantiate>> <<Interface>> Connection <<instantiate>> <<Interface>> Statement <<instantiate>> <<Interface>> ResultSet

16 Liberación de recursos Comentarios (y 3) En principio, aunque no se llame a Connection.close, cuando la conexión sea eliminada por el garbage collector, el método finalize de la clase que implementa Connection, invocará al método close Además Cuando se cierra una conexión, cierra todos sus Statements asociados Cuando se cierra un Statement, cierra todos sus ResultSets asociados Sin embargo, En una aplicación multi-thread que solicita muchas conexiones por minuto (ej.: una aplicación Internet), el garbage collector correrá demasiado tarde => es imprescindible cerrar las conexiones tan pronto como se pueda Puede haber bugs en algunos drivers, de manera que no cierren los Statements asociados a una conexión y los ResultSets asociados a un Statement => mejor cerrarlos explícitamente

17 PreparedStatement Cada vez que se envía una query a la BD, ésta construye un plan para ejecutarla La parsea Determina qué se quiere hacer Determina cómo ejecutarla Ejemplo InsertExample Existe un bucle en el que repetidamente se lanza la misma query INSERT con distintos parámetros La BD construye un plan para ejecutar la misma query cada vez! En este tipo de situaciones, es mejor usar PreparedStatement PreparedStatement Es un interfaz que deriva de Statement Permite representar una query parametrizada, para la que la BD construirá un plan

18 es.udc.fbellas.j2ee.jdbctutorial.preparedstatementexample (1) public final class PreparedStatementExample { public static void main (String[] args) { Connection connection = null; PreparedStatement preparedstatement = null; try { /* Get a connection. */ <<... >> /* Create data for some accounts. */ String[] accountidentifiers = new String[] {"fbellas-1", "fbellas-2", "fbellas-3"; double[] balances = new double[] {100.0, 200.0, 300.0;

19 es.udc.fbellas.j2ee.jdbctutorial.preparedstatementexample (2) /* Create "preparedstatement". */ String querystring = "INSERT INTO TutAccount " + "(accid, balance) VALUES (?,?)"; preparedstatement = connection.preparestatement(querystring); /* Insert the accounts in database. */ for (int i=0; i<accountidentifiers.length; i++) { /* Fill "preparedstatement". */ int j = 1; preparedstatement.setstring(j++, accountidentifiers[i]); preparedstatement.setdouble(j++, balances[i]); /* Execute query. */ int insertedrows = preparedstatement.executeupdate(); if (insertedrows!= 1) { throw new SQLException(accountIdentifiers[i] + ": problems when inserting!!!!");

20 es.udc.fbellas.j2ee.jdbctutorial.preparedstatementexample (y 3) catch (SQLException e) { e.printstacktrace(); finally { try { if (preparedstatement!= null) { preparedstatement.close(); if (connection!= null) { connection.close(); catch (SQLException e) { e.printstacktrace(); // try // main // class

21 Statement vs PreparedStatement PreparedStatement es más eficiente en bucles que lanzan la misma query con distintos parámetros Statement obliga a formatear los datos de la query porque ésta se envía a la BD tal cual la escribimos Las cadenas de caracteres tienen que ir entre => código menos legible y más propenso a errores Existen algunos tipos de datos (ej.: fechas) que se especifican de manera distinta según la BD Con PreparedStatement el formateo de los datos lo hace el driver Conclusión En general, usar siempre PreparedStatement

22 Tipos SQL y Java ResultSet y PreparedStatement proporcionan métodos getxxx y setxxx Cuál es la correspondencia entre tipos Java y tipos SQL? Idea básica: un dato de tipo Java se puede almacenar en una columna cuyo tipo SQL sea consistente con el tipo Java Las BDs suelen emplear nombres distintos para los tipos que proporcionan No afecta al código Java (excepto que cree tablas, lo que en general, no debe hacerse)

23 Correspondencia entre tipos Java y SQL estándar Tipo Java boolean byte short int long float double java.math.bigdecimal String byte[] java.sql.date java.sql.time java.sql.timestamp Tipo SQL BIT TINYINT SMALLINT INTEGER BIGINT REAL DOUBLE NUMERIC VARCHAR o LONGVARCHAR VARBINARY o LONGVARBINARY DATE TIME TIMESTAMP

24 DataSources (1) Cargar el driver y obtener conexiones con DriverManager.getConnection requiere Conocer el nombre de la clase del driver La cadena de conexión A no ser que leamos los anteriores parámetros de un fichero de configuración, el registro del driver y la obtención de conexiones no será portable Interfaz javax.sql.datasource Es la alternativa recomendada a DriverManager.getConnection No hay que escribir código para registrar el driver Actúa como factoría de conexiones

25 DataSources (2) Normalmente una aplicación obtiene una referencia a un objeto DataSource mediante JNDI JNDI (Java Naming and Directory Interface) Familia de paquetes javax.naming Formó parte de J2EE (hasta la versión 1.2), pero se movió a J2SE (desde la versión 1.3 de J2SE) Es un API que proporciona un conjunto de interfaces para acceder a un servicio de nombres y directorios Servicio de nombres y directorios Permite gestionar información de manera jerárquica Usuarios (login+password, directorios home, etc.), máquinas de la red (direcciones ethernet e IP, etc.) Puede implementarse como un sólo servidor o una jerarquía de servidores (federación)

26 DataSources (3) Servicio de nombres y directorios Ejemplos LDAP (Lightweight Directory Access Protocol) NIS/NIS+ (Network Information System) Microsoft Active Directory JNDI permite acceder a cualquier servicio de nombres y directorios usando la misma interfaz Se necesita disponer de una implementación de JNDI para el servicio en cuestión Actualmente se pretende que las aplicaciones lean la información de configuración mediante servicios de nombres y directorios, y no mediante ficheros planos locales Ventaja: la información de configuración de las aplicaciones se puede centralizar en la máquina (o máquinas) que corren el servicio de nombres y directorios

27 DataSources (y 4) Ejemplo import javax.naming.context import javax.naming.initialcontext; import javax.sql.datasource; //... Context context = new InitialContext(); DataSource datasource = (DataSource)context.lookup( java:comp/env/jdbc/j2ee-examplesds ); Connection connection = datasource.getconnection(); Quién registra los objetos DataSource en el servicio de nombres y directorios? Podría hacerlo el programador usando JDNI Sin embargo, normalmente dispondremos de una herramienta de administración o un fichero de configuración en el servidor

28 Una implementación sencilla de un DataSource A partir del tema 4 (tecnologías web) usaremos JNDI para localizar objetos DataSource Mientras tanto... <<Interface>> DataSource (from sql) SimpleDataSource + SimpleDataSource() <<use>> ConfigurationParametersManager (from configuration) Sólo implementa "getconnection()". El resto de operaciones lanzan la exception (unchecked) "UnsupportedOperationException"

29 es.udc.fbellas.j2ee.util.sql.simpledatasource (1) public class SimpleDataSource implements DataSource { private static final String DRIVER_CLASS_NAME_PARAMETER = "SimpleDataSource/driverClassName"; private static final String URL_PARAMETER = "SimpleDataSource/url"; private static final String USER_PARAMETER = "SimpleDataSource/user"; private static final String PASSWORD_PARAMETER = "SimpleDataSource/password"; private static String url; private static String user; private static String password;

30 es.udc.fbellas.j2ee.util.sql.simpledatasource (2) static { try { /* Read configuration parameters. */ String driverclassname = ConfigurationParametersManager.getParameter( DRIVER_CLASS_NAME_PARAMETER); url = ConfigurationParametersManager.getParameter( URL_PARAMETER); user= ConfigurationParametersManager.getParameter( USER_PARAMETER); password = ConfigurationParametersManager.getParameter( PASSWORD_PARAMETER); /* Load driver. */ Class.forName(driverClassName); catch (Exception e) { e.printstacktrace(); // static

31 es.udc.fbellas.j2ee.util.sql.simpledatasource (y 3) public Connection getconnection() throws SQLException { return DriverManager.getConnection(url, user, password); << Resto de métodos => throw new UnsupportedOperationException("Not implemented"); >> // class

32 es.udc.fbellas.j2ee.util.configuration.configurationparametersmanager (1) public final class ConfigurationParametersManager { private static final String JNDI_PREFIX = "java:comp/env/"; private static final String CONFIGURATION_FILE = "ConfigurationParameters.properties"; private static boolean usesjndi; private static Map parameters; static { try { /* Read property file (if exists).*/ Class configurationparametersmanagerclass = ConfigurationParametersManager.class; ClassLoader classloader = configurationparametersmanagerclass.getclassloader(); InputStream inputstream = classloader.getresourceasstream(configuration_file); Properties properties = new Properties(); properties.load(inputstream); inputstream.close();

33 es.udc.fbellas.j2ee.util.configuration.configurationparametersmanager (2) /* We have been able to read the file. */ usesjndi = false; System.out.println("*** Using " + "'ConfigurationParameters.properties' file " + "for configuration ***"); /* * We use a "HashMap" instead of a "HashTable" because * HashMap's methods are *not* synchronized (so they are * faster), and the parameters are only read. */ parameters = new HashMap(properties); catch (Exception e) { /* We assume configuration with JNDI. */ usesjndi = true; System.out.println("*** Using JNDI for configuration ***"); /* * We use a synchronized map because it will be filled * by using a lazy strategy. */ parameters = Collections.synchronizedMap(new HashMap()); // static

34 es.udc.fbellas.j2ee.util.configuration.configurationparametersmanager (y 3) private ConfigurationParametersManager() { public static String getparameter(string name) throws MissingConfigurationParameterException { String value = (String) parameters.get(name); if (value == null) { if (usesjndi) { try { InitialContext initialcontext = new InitialContext(); value = (String) initialcontext.lookup( JNDI_PREFIX + name); parameters.put(name, value); catch (Exception e) { throw new MissingConfigurationParameterException( name); else { throw new MissingConfigurationParameterException(name); return value; // class

35 Comentarios ConfigurationParameters.properties tiene que estar en el class path Ejemplo de especificación de parámetros de configuración en ConfigurationParameters.properties # # SimpleDataSource. # SimpleDataSource/driverClassName=com.mysql.jdbc.Driver SimpleDataSource/url=jdbc:mysql://localhost/j2ee SimpleDataSource/user=j2ee SimpleDataSource/password=j2ee

36 Pool de conexiones (1) En una aplicación servidora (ej.: un contenedor de páginas JSP/Servlets, un contenedor de EJBs) con carga alta Se solicitan muchas conexiones a la BD por minuto Pedir una conexión cada vez se convierte en un cuello de botella Solución: pool de conexiones Ejemplo de implementación <<interface>> java.sql.connection <<instantiate>> <<interface>> javax.sql.datasource ConnectionWrapper - c : java.sql.connection <<instantiate>> ConnectionPool - connections: java.util.linkedlist releaseconnection(c:connection):void

37 Pool de conexiones (2) Ejemplo de implementación (cont) ConnectionPool Una sóla instancia Cuando se crea, pide n conexiones a la BD (quizás usando DriverManager.getConnection) y las almacena en una lista getconnection Si quedan conexiones en la lista, devuelve una de ellas dentro de un objeto ConnectionWrapper (comprobando antes si está viva ) En otro caso, deja durmiendo al thread llamador usando wait releaseconnection (con visibilidad package ) Devuelve la conexión a la lista, y notifica (notifyall) a los posibles threads que esperan por una conexión ConnectionWrapper Encapsula a una conexión real close Usa releaseconnection para devolver la conexión real al pool finalize Si no se ha llamado a ConnectionWraper.close, lo llama Resto de operaciones Delegan en la conexión real

38 Pool de conexiones (y 3) Ejemplo de implementación (cont) El programador trabaja contra javax.sql.datasource y java.sql.connection Su código no sabe que está trabajando contra un pool de conexiones Los servidores de aplicaciones completos J2EE proporcionan implementaciones de DataSources con pool de conexiones A partir del tema 4 (tecnologías web), trabajaremos con pool de conexiones

39 Transacciones Permiten ejecutar bloques de código con las propiedades ACID (Atomicity-Consistency-Isolation- Durability) Por defecto, cuando se crea una conexión está en modo auto-commit Cada Statement y PreparedStatement que se ejecute sobre ella irá en su propia transacción Para ejecutar varias queries en una misma transacción es preciso Deshabilitar el modo auto-commit de la conexión Lanzar las queries Terminar con connection.commit() si todo va bien, o connection.rollback() en otro aso.

40 es.udc.fbellas.j2ee.jdbctutorial.transactionexample (1) Mismo ejemplo que es.udc.fbellas.j2ee.jdbctutorial.preparedstatementexample, pero ahora la inserción de cuentas se realiza en una única transacción public final class TransactionExample { public static void main (String[] args) { Connection connection = null; PreparedStatement preparedstatement = null; boolean commited = false; try { /* Get a connection with autocommit to "false". */ DataSource datasource = new SimpleDataSource(); connection = datasource.getconnection(); connection.setautocommit(false); << Insertar cuentas. >> /* Commit transaction. */ connection.commit(); commited = true;

41 es.udc.fbellas.j2ee.jdbctutorial.transactionexample (y 2) catch (SQLException e) { e.printstacktrace(); finally { try { if (preparedstatement!= null) { preparedstatement.close(); if (connection!= null) { if (!commited) { connection.rollback(); connection.close(); catch (SQLException e) { e.printstacktrace(); // try // main // class

42 Problemas de concurrencia En principio, las transacciones garantizan que no hay problemas si dos o más transacciones modifican datos comunes concurrentemente Propiedad I en ACID Para el programador es como si la BD serializase las transacciones En realidad, dependiendo de la estrategia de bloqueo que se use, pueden darse los siguientes problemas Dirty reads Non-repeatable reads Phantom reads

43 Dirty reads Una transacción lee datos actualizados por otra transacción, pero todavía no comprometidos Transacción 1 Transacción 2 begin SELECT X /* X = 0 */ X = X + 10 /* X = 10 */ UPDATE X /* X = 10 en BD pero no comprometido */ rollback /* X = 0 en BD */ begin SELECT X /* X = 10 */ X = X + 10 /* X = 20 */ UPDATE X /* X = 20 en BD pero no comprometido */ commit /* X = 20 en BD y comprometido */

44 Non-repeatable reads Una transacción relee un dato que ha cambiado mágicamente desde la primera lectura Transacción 1 Transacción 2 begin SELECT X /* X = 0 */ begin X = 20 SELECT X /* X = 20 */... commit UPDATE X /* X = 20 en BD pero no comprometido */ commit /* X = 20 en BD y comprometido */

45 Phantom reads Una transacción relanza una query de consulta y obtiene mágicamente más filas la segunda vez Transacción 1 Transacción 2 begin SELECT WHERE condition begin INSERT /* Inserta nuevas filas en BD (no comprometidas), algunas cumpliendo condition */ commit /* Inserciones comprometidas */ SELECT WHERE condition /* Ahora devuelve más filas */... commit

46 Transaction isolation levels (1) java.sql.connection proporciona el método settransactionisolation, que permite especificar el nivel de aislamiento deseado TRANSACTION_NONE: transacciones no soportadas TRANSACTION_READ_UNCOMMITED: pueden ocurrir dirty reads, non-repeatable reads y phantom reads TRANSACTION_READ_COMMITED: pueden ocurrir non-repeatable reads y phantom reads TRANSACTION_REPEATABLE_READ: pueden ocurrir phantom reads TRANSACTION_SERIALIZABLE: elimina todos los problemas de concurrencia Mayor nivel de aislamiento => la BD realiza más bloqueos => menos concurrencia

47 Transaction isolation levels (y 2) No todos los drivers/bds tienen porque soportar todos los niveles de aislamiento Suelen soportar TRANSACTION_READ_COMMITED y TRANSACTION_SERIALIZABLE Cuál es el nivel de aislamiento por defecto en las conexiones? Depende del driver/bd Suele ser TRANSACTION_READ_COMMITED

48 Una transferencia bancaria Ejemplos es.udc.fbellas.j2ee.jdbctutorial.transf erence*example Realizan una transferencia de dinero entre dos cuentas bancarias Veremos 4 estrategias Objetivo Estudiar los problemas de concurrencia que puede tener una transacción típica que Lee un dato (o más) de BD Lo actualizar en memoria (ej.: le suma una cantidad) Lo actualiza en BD Muchas transacciones son de este estilo

49 es.udc.fbellas.j2ee.jdbctutorial.transference1example (1) private static void transfer(connection connection, String sourceaccountidentifier, String destinationaccountidentifier, double amount) throws SQLException { boolean commited = false; try { connection.setautocommit(false); addamount(connection, sourceaccountidentifier, -amount); addamount(connection, destinationaccountidentifier, amount); connection.commit(); commited = true; connection.setautocommit(true); finally { if (!commited) { connection.rollback();

50 es.udc.fbellas.j2ee.jdbctutorial.transference1example (2) private static void addamount(connection connection, String accountidentifier, double amount) throws SQLException { PreparedStatement preparedstatement = null; try { /* Create "preparedstatement". */ String querystring = "UPDATE TutAccount" + " SET balance = balance +? WHERE accid =?"; preparedstatement = connection.preparestatement(querystring); /* Fill "preparedstatement". */ int i = 1; preparedstatement.setdouble(i++, amount); preparedstatement.setstring(i++, accountidentifier);

51 es.udc.fbellas.j2ee.jdbctutorial.transference1example (y 3) /* Execute query. */ int updatedrows = preparedstatement.executeupdate(); if (updatedrows == 0) { throw new SQLException(accountIdentifier + not found"); finally { if (preparedstatement!= null) { preparedstatement.close(); NOTA: En una situación real usaríamos InstanceNotFoundException o similar en vez de SQLException(accountIdentifier + not found )

52 Comentarios Asumiendo conexión con TRANSACTION_READ_COMMITED (que es lo normal) o superior => no hay problemas de concurrencia Sin embargo, el código anterior no puede detectar de una manera elegante y portable la situación de cuenta origen con balance insuficiente Se puede añadir una restricción de integridad (balance >= 0) sobre la columna balance Si se viola => el primer UPDATE provocará una SQLException Problemas: cómo sabe el programador si ha habido un problema en la BD (ej.: se ha caído) o si la cuenta no tiene suficiente balance? Y si quisiésemos actualizar otros datos de la cuenta?

53 es.udc.fbellas.j2ee.jdbctutorial.transference2example (1) private static void transfer(connection connection, String sourceaccountidentifier, String destinationaccountidentifier, double amount) throws SQLException, IOException { boolean commited = false; try { /* Prepare connection. */ connection.setautocommit(false); /* Read balances. */ double sourceaccountbalance = getbalance(connection, sourceaccountidentifier); double destinationaccountbalance = getbalance(connection, destinationaccountidentifier); /* Calculate new balances. */ if (sourceaccountbalance < amount) { throw new SQLException(sourceAccountIdentifier + ": Insufficient balance");

54 es.udc.fbellas.j2ee.jdbctutorial.transference2example (2) double sourceaccountnewbalance = sourceaccountbalance - amount; double destinationaccountnewbalance = destinationaccountbalance + amount; /* Update accounts. */ updatebalance(connection, sourceaccountidentifier, sourceaccountnewbalance); updatebalance(connection, destinationaccountidentifier, destinationaccountnewbalance); /* Commit. */ connection.commit(); commited = true; connection.setautocommit(true); finally { if (!commited) { connection.rollback();

55 es.udc.fbellas.j2ee.jdbctutorial.transference2example (3) private static double getbalance(connection connection, String accountidentifier) throws SQLException { PreparedStatement preparedstatement = null; ResultSet resultset = null; try { /* Create "preparedstatement". */ String querystring = "SELECT balance FROM TutAccount WHERE + " accid =?"; preparedstatement = connection.preparestatement(querystring); /* Fill "preparedstatement". */ int i = 1; preparedstatement.setstring(i++, accountidentifier); /* Execute query. */ resultset = preparedstatement.executequery();

56 es.udc.fbellas.j2ee.jdbctutorial.transference2example (4) if (!resultset.next()) { throw new SQLException(accountIdentifier + " not found"); /* Get results. */ return resultset.getdouble(1); finally { if (resultset!= null) { resultset.close(); if (preparedstatement!= null) { preparedstatement.close();

57 es.udc.fbellas.j2ee.jdbctutorial.transference2example (5) private static void updatebalance (Connection connection, String accountidentifier, double newbalance) throws SQLException { PreparedStatement preparedstatement = null; try { /* Create "preparedstatement". */ String querystring = "UPDATE TutAccount" + " SET balance =? WHERE accid =?"; preparedstatement = connection.preparestatement(querystring); /* Fill "preparedstatement". */ int i = 1; preparedstatement.setdouble(i++, newbalance); preparedstatement.setstring(i++, accountidentifier); /* Execute query. */ int updatedrows = preparedstatement.executeupdate();

58 es.udc.fbellas.j2ee.jdbctutorial.transference2example (y 6) if (updatedrows == 0) { throw new SQLException(accountIdentifier + " not found"); finally { if (preparedstatement!= null) { preparedstatement.close(); NOTA: En una situación real usaríamos InstanceNotFoundException e InsufficientBalanceException o similares en vez de los SQLException(...)

59 Comentarios (1) La solución es más genérica Podríamos tener getaccountstate y updateaccountstate en vez de getbalance y updatebalance, que nos valdrían para implementar transfer y otras operaciones que lean y/o actualicen datos de las cuentas Problema Si la conexión tiene un nivel inferior a TRANSACTION_SERIALIZABLE => problemas de concurrencia Ejemplo Dos transacciones ejecutando transfer(connection, fbellas-1, fbellas-2, 10) Supongamos inicialmente => (fbellas-1, 100) y (fbellas- 2, 200)

60 Comentarios (2) Leer balances => Transacción 1 sourceaccountbalance = 100 destinationaccountbalance = 200 Calcular nuevos balances => sourceaccountnewbalance = 90 destinationaccountnewbalance = 210 Actualizar cuentas => fbellas-1 => balance = 90 fbellas-2 => balance = 210 Leer balances => Transacción 2 sourceaccountbalance = 100 destinationaccountbalance = 200 Calcular nuevos balances => sourceaccountnewbalance = 90 destinationaccountnewbalance = 210 Actualizar cuentas => fbellas-1 => balance = 90 fbellas-2 => balance = 210 Problema: hemos perdido los efectos de una de las transacciones El problema puede darse siempre que se hagan varias transferencias simultáneas que tengan al menos una cuenta en común

61 Comentarios (y 3) Experimentar ejecutando... java classpath $J2EE_EXAMPLES_CLASSPATH es.udc.fbellas.j2ee.jdbctutorial.transference2example fbellas-1 fbellas-2... desde dos ventanas NOTA: Las cuentas fbellas-1 y fbellas-2 tienen que estar creadas y con balance >= 20

62 es.udc.fbellas.j2ee.jdbctutorial.transference3example Idem Transference2Example, excepto private static double getbalance(connection connection, String accountidentifier, boolean forupdate) throws SQLException { PreparedStatement preparedstatement = null; ResultSet resultset = null; try { /* Create "preparedstatement". */ String querystring = "SELECT balance FROM TutAccount WHERE + " accid =?"; if (forupdate) { querystring += " FOR UPDATE"; //...

63 Comentarios (1).. y la implementación de transfer usa getbalance(accountidentifier, true) No tiene problemas de concurrencia SELECT FOR UPDATE bloquea la fila (filas) en cuestión hasta que termine la transacción En el ejemplo anterior, si la transacción 1 ejecuta antes el SELECT FOR UPDATE sobre fbellas-1, cuando la segunda transacción intente hacer lo mismo, se quedará bloqueada hasta que termina la primera Si hubiese dos transferencias concurrentes del estilo.. transfer(connection, fbellas-1, fbellas-2, 10) transfer(connection, fbellas-2, fbellas-1, 10)... podría producirse una situación de inter-bloqueo => una de las transacciones gana, y la otra recibe un SQLException (la BD queda en estado consistente)

64 Comentarios (y 2) Experimentar ejecutando... java classpath $J2EE_EXAMPLES_CLASSPATH es.udc.fbellas.j2ee.jdbctutorial.transference3example fbellas-1 fbellas-2... desde dos ventanas... y... java classpath $J2EE_EXAMPLES_CLASSPATH es.udc.fbellas.j2ee.jdbctutorial.transference3example fbellas-1 fbellas-2 java classpath $J2EE_EXAMPLES_CLASSPATH es.udc.fbellas.j2ee.jdbctutorial.transference3example fbellas-2 fbellas-1... cada uno en su ventana

65 es.udc.fbellas.j2ee.jdbctutorial.transference4example (1) Idem Transference2Example, excepto private static void transfer(connection connection, String sourceaccountidentifier, String destinationaccountidentifier, double amount) throws SQLException, IOException { boolean commited = false; try { /* * Prepare connection. * * IMPORTANT: Some JDBC drivers require * "settransactionisolation to be called before * "setautocommit". */ int oldtransactionisolation = connection.gettransactionisolation(); connection.settransactionisolation( Connection.TRANSACTION_SERIALIZABLE); connection.setautocommit(false);

66 es.udc.fbellas.j2ee.jdbctutorial.transference4example (y 2) << Igual que en Transference2Example >>> /* Commit. */ connection.commit(); commited = true; connection.settransactionisolation( oldtransactionisolation); connection.setautocommit(true); finally { if (!commited) { connection.rollback();

67 Comentarios No tiene problemas de concurrencia Qué ocurre exactamente? BDs con Optimistic Locking => si se ejecutan dos transferencias concurrentes del tipo transfer(connection, fbellas-1, fbellas- 2, 10), una de ellas gana, y la otra recibe una SQLException (no hay bloqueos y la BD queda en estado consistente) BDs con Pessimistic Locking => Mismo comportamiento que Transference3Example Realizar experimentos similares a Transference3Example

68 Conclusiones acerca de concurrencia en transacciones (1) Transacciones que leen de BD, realizan cálculos en memoria (con lo leído) y actualizan en BD (con lo calculado) SELECT FOR UPDATE o TRANSACTION_SERIALIZABLE En otro caso Véase transparencia Transaction isolation levels (1) Para adoptar un enfoque sencillo (y mantenible), bastante portable y seguro (no propenso a errores) El código de los ejemplos de la asignatura usará TRANSACTION_SERIALIZABLE para todo tipo de transacciones

69 Conclusiones acerca de concurrencia en transacciones (y 2) En una aplicación claramente transaccional es mejor usar EJB (aunque usemos JDBC en la implementación de los EJBs) Las transacciones las gestiona el contenedor de EJBs El programador sólo necesita especificar qué métodos son transaccionales No hay que modificar el modo auto-commit de las conexiones ni cambiar el nivel de aislamiento EJB también implementa transacciones distribuidas EJB también permite automatizar la persistencia de objetos En resumen => más potencia + más portabilidad + más sencillez

70 Scrollable ResultSets Otros temas Permiten navegación sobre el ResultSet ResultSets actualizables Permiten hacer modificaciones a las filas correspondientes Procesamiento batch Permiten construir un Statement que agrupa a un conjunto de queries Soporte para tipos SQL3 BLOB, CLOB, arrays, STRUCT, etc.