JAFramework

.
Manejo de Transacciones

JAF también provee un pequeño manejador de trasacciones a través del cual podemos confirmar (commit) o revertir (rollback) las sentencias realizadas contra la base de datos.

Veamos las tablas DEPT (departamento) y EMP (empleado) que tienen los campos que se detallan a continuación para luego analizar un ejemplo sobre como utilizar transacciones con JAF.

DEPT
- deptno (número de departamento, NUMERIC primay key)
- dname (nombre del departamento, VARCHAR)
- loc (localidad donde funciona el departamento, VARCHAR)

EMP
- empno (número de empleado, NUMERIC primary key)
- ename (nombre del empleado, VARCHAR)
- deptno (referencia al departament donde trabaja el empleado, NUMERIC foreign key)


En el siguiente ejemplo insertamos una fila en DEPT y varias filas en EMP. Queremos "todo o nada". Si todo salió bien entonces confirmamos la operación (commit). Si algo falla entonces no se llegará a ejecutar el commit y en el finally revertimos con rollback.

TestTransaccion.java

   1:
   2:package demo;
   3:
   4:import framework.JAConnectionFactory;
   5:import framework.JAFactory;
   6:import framework.jdbc.JATransaction;
   7:
   8:public class TestTransaccion
   9:{
  10:   public static void main(String[] args)
  11:   {
  12:      JAConnectionFactory factory = JAFactory
  13:                              .getConnectionFactory();
  14:
  15:      // levanto la configuracion del data-source
  16:      factory.load("descriptor.xml");
  17:
  18:      // defino un objetto para la transaccion
  19:      JATransaction trx = null;
  20:
  21:      try
  22:      {
  23:         // inicializo una transaccion
  24:         trx = factory.beginTransaction();
  25:
  26:         // inserto un departamento (padre)
  27:         // (departamento numero 6)
  28:         InsertaFilas.insertaDept(6);
  29:
  30:         // inserto varios empleados (hijos)
  31:         // (inserto 5 empleados numerados desde 7,
  32:         // todos en el departamento numero 6)
  33:         InsertaFilas.insertaEmp(6, 7, 5);
  34:
  35:         // si todo salio bien entonces comiteo
  36:         trx.commit();
  37:      }
  38:      catch( Exception ex )
  39:      {
  40:         ex.printStackTrace();
  41:         throw new RuntimeException(ex);
  42:      }
  43:      finally
  44:      {
  45:         // siempre hago el rollback
  46:         if( trx != null ) trx.rollback();
  47:      }
  48:   }
  49:}
  50:

Veamos la clase con la que insertamos las filas en las tablas.

InsertaFilas.java

   1:
   2:package demo;
   3:
   4:import java.sql.Connection;
   5:import java.sql.PreparedStatement;
   6:
   7:import javax.sql.DataSource;
   8:
   9:import framework.JAConnectionFactory;
  10:import framework.JAFactory;
  11:
  12:public class InsertaFilas
  13:{
  14:   // inserta una fila en la tabla DEPT
  15:   public static void insertaDept(int deptno)
  16:   {
  17:      Connection con = null;
  18:      PreparedStatement pstm = null;
  19:
  20:      try
  21:      {
  22:         JAConnectionFactory factory = JAFactory
  23:                              .getConnectionFactory();
  24:
  25:         String sql = "";
  26:         sql += "INSERT INTO dept ( ";
  27:         sql += "deptno, dname, loc) VALUES( ";
  28:         sql += "?,?,?)";
  29:
  30:         // Obtengo el data-source por default
  31:         DataSource ds = factory.getDataSource();
  32:
  33:         // le pido una conexion
  34:         con = ds.getConnection();
  35:        
  36:         // utilizo la conexion
  37:         pstm = con.prepareStatement(sql);
  38:
  39:         pstm.setInt(1, deptno);
  40:         pstm.setString(2, "Dept(" + deptno + ")");
  41:         pstm.setString(3, "Loc(" + deptno + ")");
  42:         if( pstm.executeUpdate() != 1 )
  43:         {
  44:            throw new RuntimeException("Error");
  45:         }
  46:      }
  47:      catch( Exception ex )
  48:      {
  49:         ex.printStackTrace();
  50:         throw new RuntimeException(ex);
  51:      }
  52:      finally
  53:      {
  54:         try
  55:         {
  56:            if( pstm != null ) pstm.close();
  57:           
  58:            // retorno la conexion al data-source
  59:            if( con != null ) con.close();
  60:         }
  61:         catch( Exception ex )
  62:         {
  63:            ex.printStackTrace();
  64:            throw new RuntimeException(ex);
  65:         }
  66:      }
  67:   }
  68:
  69:   // inserta n filas en la tabla EMP
  70:   public static void insertaEmp(int deptno
  71:                               , int empnoBase
  72:                               , int n)
  73:   {
  74:      Connection con = null;
  75:      PreparedStatement pstm = null;
  76:
  77:      try
  78:      {
  79:         JAConnectionFactory factory = JAFactory
  80:                              .getConnectionFactory();
  81:
  82:         String sql = "";
  83:         sql += "INSERT INTO emp ( ";
  84:         sql += "empno, ename, deptno) VALUES( ";
  85:         sql += "?,?,?)";
  86:
  87:         // obtengo el data-source por default
  88:         DataSource ds = factory.getDataSource();
  89:        
  90:         // le pido una conexion
  91:         con = ds.getConnection();
  92:        
  93:         // utilizo la conexion
  94:         pstm = con.prepareStatement(sql);
  95:
  96:         for( int i = 0; i < n; i++ )
  97:         {
  98:            pstm.setInt(1, empnoBase + i);
  99:            pstm.setString(2, "Emp(" + i + ")");
 100:            pstm.setInt(3, deptno);
 101:            if( pstm.executeUpdate() != 1 )
 102:            {
 103:               throw new RuntimeException("Error");
 104:            }
 105:         }
 106:      }
 107:      catch( Exception ex )
 108:      {
 109:         ex.printStackTrace();
 110:         throw new RuntimeException(ex);
 111:      }
 112:      finally
 113:      {
 114:         try
 115:         {
 116:            if( pstm != null ) pstm.close();
 117:
 118:            // devuelvo la conexion al data-source
 119:            if( con != null ) con.close();
 120:         }
 121:         catch( Exception ex )
 122:         {
 123:            ex.printStackTrace();
 124:            throw new RuntimeException(ex);
 125:         }
 126:      }
 127:   }
 128:}
 129:

.