JDBC CRUD Ejemplo en MySQL y Oracle Usando Tx JavaSE
JDBC CRUD Ejemplo en MySQL y Oracle Usando Tx JavaSE
Metodos propagando excepcion en DAO
Esto significa que en este ejemplo la clase DAOImpl envÃa una excepcion al metodo de service mainalumno, el cual podrá hacer rollback y ejecutará el método commit.
Este proyecto es "simil" a este proyecto solo sufre algunas modificaciones en las clases MainAlumno, y AlumnoDaoImpl. que se describen a continuacion.
Este cambio permitirá que en el metodo de service por ejemplo se realiza un registro A, y enseguida se realiza un registro B si el registro B falla, el registro A no se insertará en la BD porque caerá en una excepcion y se podrá realizar rollback para regresar al estado inicial.
Diseño de clases:
A diferencia del proyecto anterior aquà se realiza la conexión en la clase service, la cual se ejecutará el método commit que permitirá la funcionalidad de transacción.
Estrutura del proyecto
1).- MainAlumno.java.
MainAlumno.java
De esta clase el cambio importante consiste en pasar en el argumento del constructor el objeto connection, asi como el catch que realiza el rollback y el método commit.
2.- AlumnoDaoImpl.java
El otro cambio importante consiste en el cambio al lanzar el SQLException y solo dejar el finally asà como el llamado al constructor con un parámetro.
Código:
Finalmente la clase mainAlumno actúa como service, ejecuta el rollback si algún método falla antes si ninguno falla ejecuta el commit y guarda en BD.
Para la base de datos solo necesitas crear un xe para oracle y examples para mysql
usuarios mysql, oracle y password admin.
simplemente crea una tabla llamada alumnos, con 2 columnas primary key id y nombre .
Código fuente
Metodos propagando excepcion en DAO
Esto significa que en este ejemplo la clase DAOImpl envÃa una excepcion al metodo de service mainalumno, el cual podrá hacer rollback y ejecutará el método commit.
Este proyecto es "simil" a este proyecto solo sufre algunas modificaciones en las clases MainAlumno, y AlumnoDaoImpl. que se describen a continuacion.
Este cambio permitirá que en el metodo de service por ejemplo se realiza un registro A, y enseguida se realiza un registro B si el registro B falla, el registro A no se insertará en la BD porque caerá en una excepcion y se podrá realizar rollback para regresar al estado inicial.
Diseño de clases:
Estrutura del proyecto
1).- MainAlumno.java.
MainAlumno.java
De esta clase el cambio importante consiste en pasar en el argumento del constructor el objeto connection, asi como el catch que realiza el rollback y el método commit.
package com.tx;
import java.sql.*;
import java.util.List;
import com.tx.conexion.Conexion;
import com.tx.conexion.Pool;
import com.tx.dao.AlumnoDao;
import com.tx.dao.AlumnoDaoImpl;
import com.tx.domain.Alumno;
public class MainAlumno {
public static void main(String[] args) {
//Utilizamos el tipo interface como referencia
//a una clase concreta
Connection conn = null;
//AlumnoDao alumnoDao = new AlumnoDaoImpl();
try {
/**Este codigo se comenta para tx**/
conn = Pool.getConexion();
//Revisamos si la conexion esta en modo autocommit
//por default es autocommit == true
if (conn.getAutoCommit()) {
conn.setAutoCommit(false);
}
AlumnoDao alumnoDao = new AlumnoDaoImpl(conn);
Alumno alumno = new Alumno();
alumno.setId(5);
alumno.setNombre("pedro");
//alumnoDao.insert(alumno);
//eliminamos un registro, el id 3
//alumnoDao.delete( new Alumno(3));
//actualizamos un registro
//Alumno atmp= new Alumno();
//atmp.setId(90);//actualizamos el registro 2
//atmp.setNombre("Carla");
//alumnoDao.update(atmp);
//Seleccionamos todos los registros
Alumno aa = new Alumno();
aa.setId(4);
aa.setNombre("Carmen");
//alumnoDao.insert(alumno);
List<Alumno> alumnos = alumnoDao.select();
for (Alumno a : alumnos) {
System.out.print( a );
System.out.println();
}
/******Codigo para tx*********/
conn.commit();
} catch (SQLException e) {
//Hacemos rollback en caso de error
try {
System.out.println("Entramos al rollback");
//Imprimimos la excepcion a la consola
e.printStackTrace(System.out);
//Hacemos rollback
conn.rollback();
} catch (SQLException e1) {
e1.printStackTrace(System.out);
}
}
finally {
try {
conn.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
/******Codigo sin Tx*********/
/*}catch(Exception e) {
e.printStackTrace();
}*/
}
}
2.- AlumnoDaoImpl.java
El otro cambio importante consiste en el cambio al lanzar el SQLException y solo dejar el finally asà como el llamado al constructor con un parámetro.
Código:
package com.tx.dao;
import java.sql.*;import java.util.ArrayList;import java.util.List;
import com.tx.conexion.Conexion;import com.tx.domain.Alumno;
/** * Esta clase implementa la clase AlumnoDao es una implementacion con la * tecnologia JDBC podra haber otro tipo de implementaciones con tecnologias * como Hibernate, iBatis, SpringJDBC, etc. * * @author hix * */public class AlumnoDaoImpl implements AlumnoDao {
private Connection userConn; private final String SQL_INSERT = "INSERT INTO alumnos(id, nombre) VALUES(?,?)"; private final String SQL_UPDATE = "UPDATE alumnos SET nombre=? WHERE id=?"; private final String SQL_DELETE = "DELETE FROM alumnos WHERE id = ?"; private final String SQL_SELECT = "SELECT * FROM alumnos";
/** * Constructor vacio */ public AlumnoDaoImpl() { }
/** * Constructor con que recibe una conexion (Usado para transacciones) * @param conn */ public AlumnoDaoImpl(Connection conn) { this.userConn = conn; } /** * El metodo insert recibe como argumento un objeto DTO el cual viene de * otra capa, y se extraen sus valores para crear un nuevo registro */ public int insert(Alumno alumno) throws SQLException { Connection conn = null; PreparedStatement stmt = null; int rows = 0; try { conn = (this.userConn != null) ? this.userConn : Conexion.getConnection(); stmt = conn.prepareStatement(SQL_INSERT); int index = 1; stmt.setInt(index++, alumno.getId()); stmt.setString(index, alumno.getNombre()); System.out.println("Ejecutando query:" + SQL_INSERT); rows = stmt.executeUpdate(); System.out.println("Registros afectados:" + rows); /**Este codigo se comenta para propagar la excepcion en tx**/ } finally { Conexion.close(stmt); if (this.userConn == null) { Conexion.close(conn); } } /**Codigo Sin Tx**/ /*} catch (SQLException e) { e.printStackTrace(); } finally { Conexion.close(stmt); Conexion.close(conn); }*/ return rows; }
/** * El metodo update recibe un objeto personaDTO el cual encapsula la * informacion en un solo objeto y evitamos pasar los parametros de manera * aislada Despues extraemos la informacion del objeto y actualizamos el * registro seleccionado */ public int update(Alumno alumno) throws SQLException { Connection conn = null; PreparedStatement stmt = null; int rows = 0; try { conn = (this.userConn != null) ? this.userConn : Conexion.getConnection(); System.out.println("Ejecutando query:" + SQL_UPDATE); stmt = conn.prepareStatement(SQL_UPDATE); int index = 1; stmt.setString(index++, alumno.getNombre()); stmt.setInt(index, alumno.getId()); rows = stmt.executeUpdate(); System.out.println("Registros actualizados:" + rows); /**Este codigo se comenta para propagar la excepcion en tx**/ } finally { Conexion.close(stmt); if (this.userConn == null) { Conexion.close(conn); } } /**Codigo Sin Tx**/ /*} catch (SQLException e) { e.printStackTrace(); } finally { Conexion.close(stmt); Conexion.close(conn); }*/ return rows; }
/** * Recibimos un objeto no necesariamente debe venir lleno, sino * solo nos importa el atributo id_persona */ public int delete(Alumno alumno) throws SQLException { Connection conn = null; PreparedStatement stmt = null; int rows = 0; try { conn = (this.userConn != null) ? this.userConn : Conexion.getConnection(); System.out.println("Ejecutando query:" + SQL_DELETE); stmt = conn.prepareStatement(SQL_DELETE); stmt.setInt(1, alumno.getId()); rows = stmt.executeUpdate(); System.out.println("Registros eliminados:" + rows); /**Este codigo se comenta para propagar la excepcion en tx**/ } finally { Conexion.close(stmt); if (this.userConn == null) { Conexion.close(conn); } } /**Codigo Sin Tx**/ /*} catch (SQLException e) { e.printStackTrace(); } finally { Conexion.close(stmt); Conexion.close(conn); }*/ return rows; }
/** * En este metodo utilizamos el objeto PersonaDTO para llenar una lista y * regresarla */ public List<Alumno> select() throws SQLException { Connection conn = null; PreparedStatement stmt = null; ResultSet rs = null; Alumno alumno = null; List<Alumno> alumnos = new ArrayList<Alumno>(); try { conn = (this.userConn != null) ? this.userConn : Conexion.getConnection(); stmt = conn.prepareStatement(SQL_SELECT); rs = stmt.executeQuery(); while (rs.next()) { //Por cada registro se recuperan los valores //de las columnas y se crea un objeto DTO int idPersonaTemp = rs.getInt(1); String nombreTemp = rs.getString(2);
//Llenamos el DTO y lo agregamos a la lista alumno = new Alumno(); alumno.setId(idPersonaTemp); alumno.setNombre(nombreTemp); alumnos.add(alumno); } /**Este codigo se comenta para propagar la excepcion en tx**/ } finally { Conexion.close(rs); Conexion.close(stmt); if (this.userConn == null) { Conexion.close(conn); } } /**Codigo Sin Tx**/ /*} catch (SQLException e) { e.printStackTrace(); } finally { Conexion.close(rs); Conexion.close(stmt); Conexion.close(conn); }*/ return alumnos; }
}
Finalmente la clase mainAlumno actúa como service, ejecuta el rollback si algún método falla antes si ninguno falla ejecuta el commit y guarda en BD.
Para la base de datos solo necesitas crear un xe para oracle y examples para mysql
usuarios mysql, oracle y password admin.
simplemente crea una tabla llamada alumnos, con 2 columnas primary key id y nombre .
Código fuente
Entradas
No hay comentarios.