Conexión, consulta y ejecución de sentencias en Oracle desde Java

En un artículo anterior abordé el tema de Leer la estructura de una base de datos Oracle en Java sin ahondar demasiado en el tema de la conexión. En este artículo explicaré paso a paso cómo realizar la conexión a Oracle en Java, así como la forma de realizar consultas a los registros existentes y ejecutar sentencias de inserción, borrado y actualización de datos.

Al final del artículo tendremos una clase que encapsulará todos los procedimientos necesarios para trabajar con la base de datos.

Obtener el driver

Como toda conexión a bases de datos en Java, necesitamos un driver (también conocido como conector) para realizar la comunicación con la base de datos, en este caso necesitaremos el de Oracle, específicamente el ojdbc6.jar disponible para su descarga desde el siguiente enlace:

Descargar

Crear el proyecto de NetBeans

En lo particular utilizo la que a la fecha de publicación de este artículo es la versión más reciente del NetBeans: la 7.1.1. Para crear el proyecto basta con dar clic en el botón de 'Nuevo Proyecto' o ir al menú Archivo -> Nuevo Proyecto.

Al proyecto le titularemos OracleBD, aunque solo es un nombre sugerido ya que no afecta en lo más mínimo con el comportamiento del programa. Una vez creado el proyecto el IDE nos posicionará en la clase principal del mismo y creará por sí solo el método main desde el cual ejecutaremos todos nuestros procedimientos.

Establecer la conexión a la base de datos

Lo primero que vamos a hacer es importar las clases y/o paquetes que vamos a utilizar (los llamados import’s), en este caso solamente será el que se muestra a continuación:

   import java.sql.*;

Posteriormente dentro de la clase declararemos una variable privada de tipo Connection que será la que contendrá la conexión con la base de datos:

public class OracleBD {    private Connection conexion;
    .
    .

Para organizar el código crearemos el get y set de conexion además del método llamado conectar() el cual se encargará de establecer a la conexión con la base de datos para que posteriormente podamos realizar los procedimientos que necesitamos. Dentro del método encerraremos la mayor parte del código dentro de un try-catch con el fin de capturar las excepciones que se puedan originar tras la ejecución del mismo.

       public Connection getConexion() {
        return conexion;
    }    public void setConexion(Connection conexion) {
        this.conexion = conexion;
    }    public OracleBD conectar() {
        try {
           .
           .
        } catch (Exception e) {
            e.printStackTrace();
        }
        return this;
    }

Como puedes ver, el método devuelve una instancia de la clase OracleBD (es decir, la misma que lo contiene), esto con el fin de poder encadenar los siguientes métodos que necesitaremos y ahorrarnos una línea de código ;) .

Ahora bien, dentro del try-catch lo primero que realizaremos será cargar el driver en la memoria y posteriormente crear una cadena con la URL de conexión a la base de datos como se muestra en el siguiente código:

    Class.forName("oracle.jdbc.OracleDriver");
    String BaseDeDatos = "jdbc:oracle:thin:@localhost:1521:ESQUEMA";

En la URL de la conexión debes tomar en cuenta que:

• localhost indica el host o la IP del servidor Oracle.
• 1521 es el puerto de conexión por defecto.
• ESQUEMA es el esquema al cual te vas a conectar

En este momento lo único que nos falta para crear la conexión es llamar al método getConnection() del driver de la siguiente manera:

 
conexion = DriverManager.getConnection(BaseDeDatos, "USUARIO", "contraseña");

Puedes validar si la conexión se realizó correctamente verificando si la variable es nula:

            if (conexion != null) {
                System.out.println("Conexion exitosa!");
            } else {
                System.out.println("Conexion fallida!");
            }

El método completo entonces quedaría de la siguiente manera:

    public OracleBD conectar() {
        try {
            Class.forName("oracle.jdbc.OracleDriver");
            String BaseDeDatos = "jdbc:oracle:thin:@localhost:1521:ESQUEMA";
            
            conexion = DriverManager.getConnection(BaseDeDatos, "USUARIO","CONTRASEÑA");            if (conexion != null) {
                System.out.println("Conexion exitosa!");
            } else {
                System.out.println("Conexion fallida!");
            }
        } catch (Exception e) {
            e.printStackTrace();
        }        return this;
    }

Ejecutar sentencias en la base de datos

Ya que hemos realizado la conexión a la base de datos podemos trabajar con ella por lo cual crearemos un método a partir del cual ejecutaremos las sentencias más comunes que no nos devuelven resultados como INSERT, UPDATE, DELETE, etc.

Vamos a definir el método para que sea público y nos devuelva un valor booleano, true si se ejecuta la consulta correctamente, false si no. A su vez recibirá una cadena que contendrá la consulta SQL a ejecutar.

  
public boolean ejecutar(String sql) {
.
.
}

Posteriormente, igual como lo hicimos en el método anterior, vamos a encerrar prácticamente todo el comportamiento dentro de try-catch.

  
public boolean ejecutar(String sql) {
        try {
            .
     .
            .
        } catch (SQLException e) {
            e.printStackTrace();
            return false;
        }        return true;
    }

Ahora definimos un objeto tipo Statement que nos ayudará a ejecutar la consulta de la siguiente manera:

  
 Statement sentencia = getConexion().createStatement(ResultSet.TYPE_FORWARD_ONLY,  ResultSet.CONCUR_READ_ONLY);
        sentencia.executeUpdate(sql);
        getConexion().commit();

Por último cerramos la sentencia para liberar recursos:

 sentencia.close();

En el caso de que se presente una excepción daremos por hecho que no se realizó la ejecución correctamente, por lo tanto, sólo en ese caso retornaremos false.

El método completo luce de la siguiente manera:

public boolean ejecutar(String sql) {
        try {
            Statement sentencia;
            sentencia = getConexion().createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
            sentencia.executeUpdate(sql);
            getConexion().commit();
            sentencia.close();
        } catch (SQLException e) {
            e.printStackTrace();
            return false;
        }        return true;
    }

Realizar consultas a la base de datos

Lo único que nos falta es consultar a la base de datos (SELECT) lo cual haremos igualmente mediante un método público que nos devuelva un objeto de tipo ResultSet e igualmente recibirá una cadena que contendrá una consulta SQL a realizar.

 public ResultSet consultar(String sql) {
 .
 .
 .
 }

Lo primero que vamos a agregar es una declaración del objeto de tipo ResultSet y posteriormente encerraremos la ejecución dentro de un try-catch para capturar las excepciones que se puedan generar.

public ResultSet consultar(String sql) {
        ResultSet resultado = null;
        try {
            .
     .
     .
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }        return resultado;
    }

De igual manera nos apoyaremos de un objeto de tipo Statement para poder realizar la consulta.

 
 Statement sentencia = getConexion().createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);

Obtenemos el mapa de resultados a través del método executeQuery() del objeto Statement y posteriormente llamamos al método commit() de la conexión para asegurarnos que la consulta se está realizando.

 
 resultado = sentencia.executeQuery(sql);
        getConexion().commit();

En el caso de que se presente una excepción daremos por hecho que no se realizó la consulta correctamente, por lo tanto, sólo en ese caso retornaremos null.

El método completo se ve de la siguiente manera:

public ResultSet consultar(String sql) {
        ResultSet resultado = null;
        try {
            Statement sentencia;
            sentencia = getConexion().createStatement(ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
            resultado = sentencia.executeQuery(sql);
            getConexion().commit();
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }        return resultado;
    }

Con esto tenemos completa nuestra clase que se encargará de realizar la conexión, consulta y ejecución de sentencias en la base de datos Oracle.

Probar el funcionamiento

Para verificar que todo funciona bien podemos crear una tabla en la base de datos de nombre TEST con 2 campos, IDENTIFICADOR de tipo NUMBER y DESCRIPCION de tipo VARCHAR y ejecutar lo siguiente dentro del método main:

public static void main(String[] args) {
        OracleBD baseDatos = new OracleBD().conectar();        if (baseDatos.ejecutar("INSERT INTO TEST(IDENTIFICADOR,DESCRIPCION) VALUES(4,'CUATRO')")) {
            System.out.println("Ejecucion correcta!");
        } else {
            System.out.println("Ocurrió un problema al ejecutar!");
        }        ResultSet resultados = baseDatos.consultar("SELECT * FROM TEST");        if (resultados != null) {
            try {
                System.out.println("IDENTIFICADOR       DESCRIPCION");
                System.out.println("--------------------------------");
                while (resultados.next()) {
                    System.out.println(""+resultados.getBigDecimal("IDENTIFICADOR")+"       "+resultados.getString("DESCRIPCION"));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

Como es de costumbre, el proyecto de NetBeans está disponible para descargar desde el siguiente enlace:

Descargar

La contraseña para descomprimir el proyecto es: http://monillo007.blogspot.com.

Tus comentarios y/o preguntas son bienvenidos.

Si el código te fue útil te invito a que me ayudes a difundirlo desde los botones sociales (Twitter, Facebook, Google+).

De igual manera puedes suscribirte al blog   para que los nuevos artículos lleguen a tu bandeja de correo o lector de Feeds favorito desde los enlaces del lado derecho de la página.