JDBC CRUD Ejemplo en MySQL y Oracle Sin Tx JavaSE

JDBC CRUD Ejemplo en MySQL y Oracle
Metodos con control de excepcion en DAO:
Esto significa que en este ejemplo la clase DAOImpl se encarga de controlar las excepciones por lo que la clase service no será transaccional.

A continuación realizaremos un CRUD con java se,  utilizando patron de diseño DAO, DTO y Singleton.
Además crearemos una clase conexión la cual se puede configurar para MySQL y Oracle.

La estructura de las clases es la siguiente:

Como se ve en la imagen la clase MainAlumno actua como service para este ejemplo a partir de aqui se mandan a llamar los metodos de la interfaz de alumnos.

El paquete DAO llama a la clase conexión y se apoya del dominio alumno para ejecutar las operaciones a la BD que reciba de la clase service.

Tenemos la clase alumno que es el dominio del sistema

Finalmente la clase conexión que se encarga proveer la interaccion con la base de datos, aquí se puede configurar el gestor de BD oracle, mysql.

Proyecto:
Estrutura final del proyecto
1) Clase alumno es el modelo de la tabla y objeto DTO.

package com.tx.dao;
import java.sql.SQLException;
import java.util.List;
import com.tx.domain.Alumno;
/**
 * Esta interfaz contiene los metodos abstractos con las
 * operaciones basicas sobre la tabla de Persona
 * CRUD (Create, Read, Update y Delete)
 * Se debe crear una clase concreta para implementar el
 * codigo asociado a cada metodo
 * @author hix
 *
 */
public interface AlumnoDao {
public int insert(Alumno alumno) throws SQLException;
public int update(Alumno alumno)
throws SQLException;
public int delete(Alumno alumno)
throws SQLException;
public List<Alumno> select() throws SQLException;
}

2.- Clase AlumnoDao: Esta clase es la interfaz que contiene los métodos a implementar. en un futuro sólo se tendría que agregar una nueva implementación.

3.- AlumnoDaoImpl: esta clase realiza la operación de los métodos. y crea el objeto connection, aquí esta parte de la diferencia para que los métodos sean transaccionales. En este caso como no se propaga la Excepcion si ocurre un error el mismo método realiza el rollback.

Codigo fuente:

package com.tx;
import java.sql.*;
import java.util.List;
import com.tx.conexion.Conexion;
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 = Conexion.getConnection();
//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(4);
            alumno.setNombre("Mary");
        //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(3);
            aa.setNombre("xdxdxd");
        //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);
            }
        }*/
        }catch(Exception e) {
        e.printStackTrace();
        }
    }
}

4.- Clase Conexión: Esta clase se encarga de cargar el driver y establecer la conexión con la BD.
Aquí solo se deben comentar las 4 variables para realizar la carga con una base u otra.

Conexion.java

package com.tx.conexion;
import java.sql.*;
/**
 * Clase Conexion JDBC
 */
public class Conexion {
/******MySQL******/
    //Valores de conexion a MySql
    //private static final String JDBC_DRIVER = "com.mysql.cj.jdbc.Driver";
    //El puerto es opcional, al igual que el parametro useSSL
    //private static final String JDBC_URL = "jdbc:mysql://localhost:3306/examples?useUnicode=true&useJDBCCompliantTimezoneShift=true&useLegacyDatetimeCode=false&serverTimezone=UTC";
    //private static final String JDBC_USER = "mysql";
    //private static final String JDBC_PASS = "admin";
    /******Oracle******/
    private static final String JDBC_DRIVER = "oracle.jdbc.OracleDriver";    private static final String JDBC_URL = "jdbc:oracle:thin:@localhost:1521:xe";    private static final String JDBC_USER = "c##oracle";
    private static final String JDBC_PASS = "admin";
        private static Driver driver = null;
    //Para que no haya problemas al obtener la conexion de    //manera concurrente, se usa la palabra synchronized
    public static synchronized Connection getConnection()
            throws SQLException {
        if (driver == null) {
            try {
                //Se registra el driver
                Class jdbcDriverClass = Class.forName(JDBC_DRIVER);
                driver = (Driver) jdbcDriverClass.newInstance();
                DriverManager.registerDriver(driver);
            } catch (Exception e) {
                System.out.println("Fallo en cargar el driver JDBC");
                e.printStackTrace();
            }
        }
        return DriverManager.getConnection(JDBC_URL, JDBC_USER, JDBC_PASS);
    }
    //Cierre del resultSet
    public static void close(ResultSet rs) {
        try {
            if (rs != null) {
                rs.close();
            }
        } catch (SQLException sqle) {
            sqle.printStackTrace();
        }
    }
    //Cierre del PrepareStatement
    public static void close(PreparedStatement stmt) {
        try {
            if (stmt != null) {
                stmt.close();
            }
        } catch (SQLException sqle) {
            sqle.printStackTrace();
        }
    }
    //Cierre de la conexion    public static void close(Connection conn) {
        try {
            if (conn != null) {
                conn.close();
            }
        } catch (SQLException sqle) {
            sqle.printStackTrace();
        }
    }
}

5.- Clase MainAlumno.java, esta clase simula la clase servicio, en donde se carga la instancia de la capaDao.
En este caso los métodos no son transaccionales dado que la clase Dao no propaga la excepción.
Es decir si insertamos un registro A y luego queremos insertar un registro B y este ultimo genera error, el registro A se habrá insertado correctamente.

MainAlumno.java (Service)

package com.tx;
import java.sql.*;
import java.util.List;
import com.tx.conexion.Conexion;
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 = Conexion.getConnection();
//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(4);
            alumno.setNombre("Mary");
        //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(3);
            aa.setNombre("xdxdxd");
        //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);
            }
        }*/
        }catch(Exception e) {
        e.printStackTrace();
        }
    }
}

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 .


Descarga el código Fuente