Uso de JDBC

La conexión a base de datos desde java es un punto indispensable de nuestras aplicaciones, para ello tenemos la librería JDBC  ( Java Database Connectivity ) la cual no permite genera una conexión segura a la base de datos, hablando de Oracle como db.

Por otro lado tenemos el enlace a MySQL desde java. Pero... eso lo vemos después.

Los métodos que estarán presentes en nuestros objetos serán, conectar y desconectar, pero antes de ello es necesario agregar la librería a nuestro pom en caso de tenerlo, la dependencia es la siguiente.

        <dependency>
           <groupId>com.oracle</groupId>
           <artifactId>ojdbc6</artifactId>
           <version>11.2.0.3</version>
       </dependency>
    

De lo contrario si tu proyecto no cuenta con un archivo pom.xml, la segunda opción es agregar un jar al proyecto, para ello lo puedes descargar de aquí.

Una vez que ya se tiene el driver, lo siguiente es crear los métodos anteriormente mencionados, para ello creamos una clase.

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author decodemy.blogspot.com
 */
public class JDBCConnection {

    /**
     * Establece la coneccion a una base de datos Oracle mediante JDBC
     *
     * @param user Usuario de db
     * @param pass Password de db
     * @param stringConnection Cadena de conexion para crear enlace
     * @throws java.sql.SQLException Throws exception SQL
     * @throws java.lang.ClassNotFoundException Throws Class Not fownd
     * @return connection
     */
    public Connection conectar(
        String user, 
        String pass, 
        String stringConnection
    ) throws SQLException, ClassNotFoundException {
        
        Connection con = null;
        Class.forName("oracle.jdbc.OracleDriver");
        con = DriverManager.getConnection(stringConnection, user, pass);
        if (con == null) {
            throw new SQLException("Connection is null");
        }
        return con;
    }
    
    /**
     * metodo creado para cerrar la conexion
     * @param con conexion a cerrar
     * @return true or false
     */
    public boolean desconectar( Connection con ){
        try {
            con.close();
            if( con == null )
                return true;
            else
                return false;
        } catch (SQLException ex) {
            Logger.getLogger(JDBCConnection.class.getName()).log(Level.SEVERE, null, ex);
        }
        return false;
    }
}

Esta clase permite conectar y desconectar una instancia a base de datos, su implementación la dejamos de la siguiente manera.

Creamos una clase que herede la clase anterior, con " extends JDBCConnection  ", para después agregar nuestra cadena de conexión.

Nota: la cadena de conexión contiene el balanceo para poder diferenciar entre los nodos donde se encuentra nuestra base. Quedando de la siguiente manera

String stringDeConeccion = "jdbc:oracle:thin:@ ( DESCRIPTION = ( ADDRESS = ( PROTOCOL = TCP )( HOST = IP_DEL_SERVIDOR_DB ) ( PORT = PUERTO_DEL_SERVIDOR_DB ) ) ( CONNECT_DATA = ( SERVICE_NAME=sie ) ) )";

con ello tenemos una cadena de coneccion a la cual podemos agregar mas address para ir haciendo a su vez un balanceo entre los nodos.

El método de consulta queda así.

    public Consulta() {
        Connection con;
        PreparedStatement stmt = null;
        StringBuilder query = new StringBuilder();
        try {
            con = conectar("usuario", "password", sdc);
            query.append("SELECT COUNT(*) AS TOTAL FROM EMPLEADOS");
            stmt = con.prepareStatement(query.toString());
            ResultSet rs = stmt.executeQuery();
            while (rs.next()) {
                System.out.println(rs.getInt("TOTAL"));
            }
            desconectar(con);
        } catch (ClassNotFoundException | SQLException err) {
            System.err.println("Error en consulta " + err.getMessage());
        }
    }

De esta manera el metodo conectar y desconectar que creamos en la clase JDBCConnection quedan heredados en nuestra clase dao.

Mas adelante les mostrare como hacer diferentes llamados a base desde java, invocando funciones, strore procedure, querys sencillos como se tiene ahorita, entre otras cosas.


No olvides dejar tu comentario al respecto, de esa manera conoceré tu opinión.

Nos vemos pronto.