Introducción a Java (JDBC) y MySQL (II)

Eclipse y Java

Arrancamos Eclipse y nos pedirá indicarle una ruta para guardar nuestro espacio de trabajo (workspace). Indicadle la ruta que consideréis y aceptamos. Nos encontraremos con algo parecido a esto:


Primero vamos a crear nuestro proyecto Java.




Le damos de nombre Prueba y damos a Finish.


Ahora creamos una nueva clase que llamaremos Main, en el paquete my.prueba.jdbc




Ahora probamos si Java está bien instalado ejecutando un "Hola mundo". Copiamos el siguiente código en la clase Main:

package my.prueba.jdbc;

public class Main
{

    public Main()
    {
        // TODO Auto-generated constructor stub
    }

    /**
     * @param args
     */
    public static void main(String[] args)
    {
        System.out.println("Hola mundo\n");

    }

}

Hacemos click en Run



y deberíamos obtener algo parecido a esto:


Siguiendo el ejemplo de la página de MySQL sobre JDBC, vamos a crear las clases y métodos pertinentes para conectarnos a la base de datos.

Para poder usar el driver de MySQL, debemos primero cargar la librería conectora Java de MySQL en el proyecto. Hacemos click en Project -> Properties -> Java Build Path -> Libraries -> Add External JARs y seleccionamos mysql-connector-java.jar desde el directorio /usr/share/java.


Nos creamos una clase MySQLDriver con un método load() para cargar el driver:

package my.prueba.jdbc;

public class MySQLDriver
{
   
    private static final String MYSQL_DRIVER_CLASS = "com.mysql.jdbc.Driver";
   
    /**
     * Carga el driver MySQL
     * @return Devuelve verdadero si el driver fue cargado satisfactoriamente, falso en caso contrario
     */
    public static boolean load()
    {       
        boolean ret = true;
        try {
            Class.forName(MYSQL_DRIVER_CLASS).newInstance();
        } catch (InstantiationException e) {           
            e.printStackTrace();
            ret = false;
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            ret = false;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            ret = false;
        }
        return ret;
    }
}

Ahora en nuestro método main() vamos a pegar este código:

MySQLDriver.load();
Connection conn = null;
try {
    conn = DriverManager.getConnection("jdbc:mysql://localhost/discografia?" + "user=root&password=contrasenya");
} catch (SQLException ex) {
    System.out.println("SQLException: " + ex.getMessage());
    System.out.println("SQLState: " + ex.getSQLState());
    System.out.println("VendorError: " + ex.getErrorCode());
}

if (conn != null)
{
    try {
        conn.close();
    } catch (SQLException e) {               
        e.printStackTrace();
    }
}

No olvidéis cambiar contrasenya por vuestra contraseña de MySQL root.

Ahora lo más probable es que Eclipse os marque en rojo alguna que otra cosa. Un ejemplo de la facilidad de uso de Eclipse:



En todos los marcados en rojo importamos las clases necesarias, hasta que no quede ningún error.

Le damos a Run de nuevo y veremos que termina sin mostrar nada en la consola. Esto indica que la conexión ha funcionado. Bien por nuestros culos.


Ahora vamos a modularizar esto un poco. Nos creamos una clase MySQLConnection con un método getConnection() para obtener una conexión a la BBDD:

package my.prueba.jdbc;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;

public class MySQLConnection
{
    private static final String MYSQL_DB = "discografia";
    private static final String MYSQL_USER = "root";
    private static final String MYSQL_PASS = "contrasenya";
    private static final String MYSQL_CONNECTION_STRING = "jdbc:mysql://localhost/" + MYSQL_DB + "?user=" + MYSQL_USER + "&password=" + MYSQL_PASS;
   
    /**
     * Procesa una excepción SQL
     * @param sqle Excepción SQL
     */
    private static void processSQLException(SQLException sqle)
    {
        System.out.println("SQLException: " + sqle.getMessage());
        System.out.println("SQLState: " + sqle.getSQLState());
        System.out.println("VendorError: " + sqle.getErrorCode());
    }
   
    /**
     * Obtiene una conexión a la base de datos
     * @return Conexión a la base de datos. null en caso de error
     */
    public static Connection getConnection()
    {
        Connection conn = null;
        try
        {
            conn = DriverManager.getConnection(MYSQL_CONNECTION_STRING);
        }
        catch (SQLException sqle)
        {
            conn = null;
            processSQLException(sqle);   
        }
       
        return conn;
    }
   
    /**
     * Termina una conexión a la base de datos
     */
    public static void endConnection(Connection conn)
    {
        if (conn != null)
        {
            try
            {
                conn.close();
            }
            catch (SQLException sqle)
            {               
                processSQLException(sqle);
            }
        }
    }
}

No olvidéis cambiar contrasenya por vuestra contraseña de MySQL root.

Ahora nuestra clase Main quedaría tal que

package my.prueba.jdbc;

import java.sql.Connection;

public class Main
{
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        MySQLDriver.load();
        Connection conn = MySQLConnection.getConnection();
        MySQLConnection.endConnection(conn);
    }
}

Si la lanzamos debería funcionar correctamente y no mostrar nada en la consola.

Ahora nos creamos una clase MySQLResult que almacenará el resultado de la consulta:

package my.prueba.jdbc;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class MySQLResult
{
    public Statement statement;
    public ResultSet resultSet;
   
    /**
     * Procesa una excepción SQL
     * @param sqle Excepción SQL
     */
    private static void processSQLException(final SQLException sqle)
    {
        System.out.println("SQLException: " + sqle.getMessage());
        System.out.println("SQLState: " + sqle.getSQLState());
        System.out.println("VendorError: " + sqle.getErrorCode());
    }
   
    /**
     * Cierra un ResultSet SQL
     * @param rs ResultSet SQL
     */
    private static void closeResultSet(final ResultSet rs)
    {
        if (rs != null)
        {
            try
            {
                rs.close();
            }
            catch (SQLException sqle)
            {
                processSQLException(sqle);
            }
        }
    }
   
    /**
     * Cierra un Statement SQL
     * @param s Statement SQL
     */
    private static void closeStatement(final Statement s)
    {
        if (s != null)
        {
            try
            {
                s.close();
            }
            catch (SQLException sqle)
            {
                processSQLException(sqle);
            }
        }
    }
   
    /**
     * Constructor por defecto
     * @deprecated Usar el otro constructor {@link MySQLResult#MySQLResult(Statement, ResultSet)}
     */
    public MySQLResult()
    {
        statement = null;
        resultSet = null;
    }
   
    /**
     * Constructor recomendado
     */
    public MySQLResult(Statement statement, ResultSet resultSet)
    {
        this.statement = statement;
        this.resultSet = resultSet;
    }
   
    /**
     * Cierra el resultado
     */
    public void close()
    {
        closeResultSet(resultSet);
        closeStatement(statement);
    }
   
    /**
     * Siguiente resultado de la consulta
     * @throws SQLException
     */
    public boolean next() throws SQLException
    {
        boolean ret = false;
        if (resultSet != null)
        {
            ret = resultSet.next();
        }
        return ret;
    }
   
    /**
     * Obtiene el contenido de la columna del resultado
     * @param col Nombre de la columna a consultar
     * @return Valor de la columna como String
     * @throws SQLException
     */
    public String getString(String col) throws SQLException
    {
        String ret = null;
        if (resultSet != null)
        {
            ret = resultSet.getString(col);
        }
        return ret;
    }
}

Ahora nos creamos una clase MySQLSentence, que lanzará la consulta y devolverá un resultado MySQLResult:

package my.prueba.jdbc;

import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;

public class MySQLSentence
{
    /**
     * Procesa una excepción SQL
     * @param sqle Excepción SQL
     */
    private static void processSQLException(final SQLException sqle)
    {
        System.out.println("SQLException: " + sqle.getMessage());
        System.out.println("SQLState: " + sqle.getSQLState());
        System.out.println("VendorError: " + sqle.getErrorCode());
    }
    
    /**
     * Cierra un Statement SQL
     * @param s Statement SQL
     */
    private static void closeStatement(final Statement s)
    {
        if (s != null)
        {
            try
            {
                s.close();
            }
            catch (SQLException sqle)
            {
                processSQLException(sqle);
            }
        }
    }
    
    /**
     * Cierra un ResultSet SQL
     * @param rs ResultSet SQL
     */
    private static void closeResultSet(final ResultSet rs)
    {
        if (rs != null)
        {
            try
            {
                rs.close();
            }
            catch (SQLException sqle)
            {
                processSQLException(sqle);
            }
        }
    }
    
    /**
     * Ejecuta una sentencia SELECT SQL
     * @param connConnection Conexión a la BBDD
     * @param strSql Sentencia SQL a ejecutar
     * @return MySQLResult
     */
    public static MySQLResult executeSELECT(final Connection connConnection, final String strSql)
    {
        ResultSet ret = null;
        Statement sql = null;
        
        try
        {
            sql = connConnection.createStatement();
            
            // Comprobamos si es una SELECT u otro comando SQL
            if (sql.execute(strSql))
            {
                ret = sql.executeQuery(strSql);                
            }
        }
        catch (SQLException sqle)
        {
            processSQLException(sqle);
            closeStatement(sql);
            closeResultSet(ret);
            ret = null;
            sql = null;
        }
        
        return new MySQLResult(sql, ret);
    }
}

Y ahora en el Main lanzamos la consulta que probamos en la parte anterior:

package my.prueba.jdbc;

import java.sql.Connection;
import java.sql.SQLException;


public class Main
{
    /**
     * Procesa una excepción SQL
     * @param sqle Excepción SQL
     */
    private static void processSQLException(final SQLException sqle)
    {
        System.out.println("SQLException: " + sqle.getMessage());
        System.out.println("SQLState: " + sqle.getSQLState());
        System.out.println("VendorError: " + sqle.getErrorCode());
    }
   
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        MySQLDriver.load();
        Connection conn = MySQLConnection.getConnection();
        String sql = "SELECT PISTA.DURACION FROM PISTA, ARTISTA, ALBUM WHERE ARTISTA.NOMBRE = 'Allan Holdsworth' AND ARTISTA.ID_ARTISTA = ALBUM.ID_ARTISTA AND ALBUM.FECHA_LANZAMIENTO = '1983-00-00' AND PISTA.ID_ALBUM = ALBUM.ID_ALBUM AND PISTA.NUM_PISTA = 3";       
        MySQLResult res = MySQLSentence.executeSELECT(conn, sql);
        try
        {
            while (res.next())
            {
                System.out.println("La duración de la tercera pista del disco de 1983 de Allan Holdsworth es " + res.getString("DURACION"));
            }
            res.close();
        }
        catch (SQLException sqle)
        {
            processSQLException(sqle);
        }       
        MySQLConnection.endConnection(conn);
    }
}

Y vemos que


En la próxima parte veremos cómo construir nuestra pequeña aplicación sobre estas bases. Hasta entonces, ¡sean malos y políticamente activos!

Comments

Popular Posts