JDBC: CONEXIN CON BASE DE DATOS

Qu es JDBC?
JDBC es el acrnimo de Java Database Connectivity, una API que permite la
ejecucin de operaciones sobre bases de datos desde el lenguaje de
programacin JAVA, independientemente del sistema operativo donde se
ejecute o de la base de datos a la cual se accede utilizando el lenguaje SQL del
mldelo de base de datos que se utilice.
Est conformada por diversas clases e interfaces ubicadas en el paquete
java.sql.
La necesidad de una librera
Al trabajar con JDBC resulta necesario agregar un jar al proyecto que contiene
las clases necesarias que se utilizan para dialogar con un DBMS. Cada DBMS
tiene su propio archivo jar. Estos archivos se pueden obtener de:
http://developers.sun.com/product/jdbc/drivers
Tambin es posible conseguir estos archivos .jar en la pgina web
correspondiente a cada DBMS, por ejemplo, en caso de usar DMBS Oracle es
posible buscarlo en la pgina de Oracle: www.oracle.com. En nuestro caso
vamos a usar el jar de MySQL, el MySQL connector y lo podemos descargar
desde ac:

http://www.mysql.com/downloads/connector/j/
Dentro del zip que se descarga se encuentra el jar.
Conexin con la base de datos
La interfaz Connection
Para poder trabajar con una base de datos, el punto de partida siempre es
conseguir una conexin, es decir un objeto de tipo Connection (este objeto
pertenece a una clase que implementa la interfaz Connection).

Construccin de un Administrador de Conexiones

Para poder obtener una conexin, una forma simple y cmoda de trabajar es
armar una clase llamada, por ejemplo, AdministradorDeConexiones, que
contenga dentro de un mtodo (obtenerConexion()) el cdigo necesario para

obtenerla.

A continuacin se presenta un ejemplo de la clase con su correspondiente

mtodo:

package ar.com.et3.lab8.ejercicio1.administrador;
import java.sql.Connection;
import java.sql.DriverManager;
/**
* @author Martin
*/
public abstract class AdministradorDeConexiones {
public AdministradorDeConexiones() {
}
public static Connection getConnection() throws Exception
{
// Establece el nombre del driver a utilizar
String dbDriver = "com.mysql.jdbc.Driver";
// Establece la conexion a utilizar contra la base de datos
String dbConnString = "jdbc:mysql://localhost/6to_ET3";
// Establece el usuario de la base de datos
String dbUser = "root";
// Establece la contrasea de la base de datos
String dbPassword = "";
// Establece el driver de conexin
Class.forName(dbDriver).newInstance();
// Retorna la conexin
return DriverManager.getConnection(dbConnString, dbUser, dbPassword);
}

Como consultar datos

El mtodo createStatement()
El mtodo createStatement() se utiliza para crear un objeto que modela a una
sentencia SQL. Es un objeto del tipo de una clase que implementa la interfaz
Statement, y provee la infraestructura para ejecutar sentencias SQL sobre una
conexin con una base de datos.
La forma de construir un objeto de este tipo es:
Statement stmtConsulta = laconexion.createStatement();
El mtodo executeQuery()
El mtodo executeQuery() se utiliza para ejecutar una sentencia SQL y obtener
el resultado correspondiente dentro de un objeto del tipo ResulSet. Este objeto
representa un conjunto de resultados que se obtienen como consecuencia de
ejecutar la sentencia SQL del tipo SELECT a travs de la conexin.
La forma de generar un objeto de este tipo es:
ResulSet rs = stmConsulta.executeQuery(laConsulta);
Como realizar una consulta
// Define la conexin
Connection laConexion =
AdministradorDeConexiones.getConnection();
// Arma la consulta y la ejecuta
String laConsulta = "SELECT * FROM alumnos";
Statement stmtConsulta = laConexion.createStatement();
ResultSet rs = stmtConsulta.executeQuery(laConsulta);
// Muestra los datos
while( rs.next() )
System.out.println( "ID: " + rs.getInt("alu_id") + " -- " + "Nombre: " +
rs.getString("alu_nombre") + " -- " + "Apellido: " +
rs.getString("alu_apellido") );
// Cierra el Statement y la Connection
stmtConsulta.close();

laConexion.close();

Como insertar datos

El mtodo createStatement()
El mtodo createStatement() es el mismo presentado en la seccin
Consulta.
El mtodo execute()
El mtodo execute() se utiliza para ejecutar sentencias SQL del tipo INSERT,
UPDATE o DELETE, y a diferencia del mtodo executeQuery() no retorna un
conjunto de resultados.
La forma de utilizar el mtodo execute() es:
String laInsercion = "INSERT INTO alumnos (alu_id, alu_nombre, alu_apellido)
VALUES (501, 'Carlos', 'Sanchez')";
Como realizar una insercin
// Define la conexin
Connection laConexion = AdministradorDeConexiones.getConnection();
// Arma la sentencia de insercin y la ejecuta
String laInsercion = "INSERT INTO alumnos (alu_id, alu_nombre,
alu_apellido) VALUES (201, 'Jos', 'Perez')";
Statement stmtInsercion = laConexion.createStatement();
stmtInsercion.execute(laInsercion);
// Cierra el Statement y la Connection
stmtInsercion.close();
laConexion.close();
// Informa que la insercin ha sido realizada con xito
System.out.println("La insercin ha sido realizada con xito...");
Como actualizar datos
El mtodo createStatement()
El mtodo createStatement() es el mismo presentado en la seccin
Consulta.

El mtodo execute()
El mtodo execute() es el mismo presentado en la seccin Insercion.

Como realizar una actualizacin

// Define la conexin
Connection laConexion =
AdministradorDeConexiones.getConnection();
// Arma la sentencia de actualizacin y la ejecuta
String laActualizacion = "UPDATE alumnos SET alu_apellido = 'Prez'
WHERE alu_id = 201";
Statement stmtActualizacion = laConexion.createStatement();
stmtActualizacion.execute(laActualizacion);
// Cierra el Statement y la Connection
stmtActualizacion.close();
laConexion.close();
// Informa que la actualizacin ha sido realizada con xito
System.out.println("La actualizacin ha sido realizada con xito...");
Como eliminar datos
El mtodo createStatement()
El mtodo createStatement() es el mismo presentado en la seccin
Consulta.
El mtodo execute()
El mtodo execute() es el mismo presentado en la seccin Insercion.
Como realizar una eliminacin
// Define la conexin
Connection laConexion =
AdministradorDeConexiones.getConnection();
// Arma la sentencia de eliminacin y la ejecuta
String laEliminacion = "DELETE FROM alumnos WHERE alu_id = 201";

Statement stmtEliminacion = laConexion.createStatement();

stmtEliminacion.execute(laEliminacion);
// Cierra el Statement y la Connection
stmtEliminacion.close();
laConexion.close();
// Informa que la eliminacin ha sido realizada con xito
System.out.println("La eliminacin ha sido realizada con xito...");

Como tratar excepciones con el manejo de base de datos

public static void main(String[] args) {
// Declara el objeto de conexin
Connection laConexion = null;
try
{
// Obtiene la conexin
laConexion = AdministradorDeConexiones.getConnection();
// Muestra los alumnos en pantalla
mostrarAlumnos(laConexion);
} catch(Exception e) {
System.out.println( e.getMessage() );
} finally {
// Cierra la conexin
try
{
if(laConexion != null)
laConexion.close();
} catch(Exception e){}
}
}
public static void mostrarAlumnos(Connection conn) throws SQLException
{
Statement stmtAlumnos = null;
// Arma la sentencia SQL en forma de text
String consulta = "SELECT * FROM alumnos";

// Arma la sentencia SQL y la ejecuta

stmtAlumnos = conn.createStatement();
ResultSet rs = stmtAlumnos.executeQuery( consulta );
// Muestra los alumnos en pantalla
while(rs.next())
System.out.println( rs.getString("alu_nombre") + " -- " +
rs.getString("alu_apellido") );
}

Transacciones
Que es un DAO?
Cuando se pretende modelar con objetos de un modelo de datos, es decir las
tablas y sus relaciones, es muy comn utilizar una propuesta simple que
consiste en armar una clase por cada tabla existente.
Dicha clase tendr los mtodos de acceso a la tabla correspondiente, entre
ellos la insercin, modificacin y la eliminacin. Este tipo de clases suelen
conocerse como DAOs, ya que objetos de esta clase se utilizaran para realizar
operaciones de datos.
De esta forma, si existe la tabla autos, es posible construir una clase
denominada Auto, que siguiendo la especificacin de un DAO, se debera tener
los mtodos insertar, modificar, eliminar y mtodos con las consultas que
resulten necesarias.
Qu es una transaccin?
Una transaccin en SQL es una coleccin de sentencias DML que forman una
unidad lgica de trabajo o procesamiento, con propiedades bien definidas. De
esta manera ser un conjunto de operaciones sobre los datos en una base de
datos que o se ejecuta entera o no se ejecuta ninguna de sus sentencias.
JDBC permite que las declaraciones de SQL sean agrupadas juntas en una
sola transaccin. De esta manera, es posible asegurar la atomicidad y
consistencia de datos, usando caractersticas transaccionales de JDBC.
El mtodo setAutoCommit()
El control de la transaccin es realizado por el objeto de la conexin. Cuando se
crea una conexin, por defecto est en el modo activado. Esto significa que
cada declaracin individual de SQL es tratada como transaccin por s
mismo, y ser comprometida tan pronto como finalice la ejecucin.
El mtodo setAutoCommit es el encargado de establecer si se trabajara
agrupando varias sentencias en una transaccin, o por el contrario cada
sentencia SQL ser una transaccin independiente.
Para trabajar con varias sentencias SQL y ejecutarlas como una transaccin es

necesario establecer el atuo-commit en false:

unaConexion.setAutoCommit(false);
Si no es necesario trabajar con transacciones, por defecto el auto-commit esta
seteado en true.

El mtodo commit
Cuanto el auto-commit est en false, para poder comprometer o impactar los
cambios en la base de datos, es necesario llamar al mtodo commit(). Si no se
llama al mtodo commit(), los cambios no sern reflejados en la base de datos
aun cuando se hayan ejecutadas una o ms sentencias SQL.
El mtodo commit() pertenece a la conexin, y la forma de invocarlo es la
siguiente:
unaConexion.commit();
El mtodo rollback()
Si en algn punto antes de invocar el mtodo commit(), el mtodo rollback() es
invocado, todas las sentencias que se hayan ejecutado quedaran sin efecto, es
decir que el rollback() vuelve atrs todos los cambios realizados sobre los datos
desde el ultimo commit() realizado.
El mtodo rollback() tambin pertenece a la conexin, y la forma de invocarlo
es la siguiente:
una Conexin.rollback()
Utilizacin de transacciones
// Declara la conexin
Connection conn = null;
//Declara los alumnos a insertar
Alumno a1 = new Alumno(Juan);
Alumno a2 = new Alumno(Pedro);
Alumno a3 = new Alumno(Mario);
try{
// Define la conexin
conn = AdministradorDeConexiones.getConnection();

// Setea el auto-commit en falso

conn.setAutoCommit(false);
//Ac comienza la transaccin
a1.insertar(conn);
a2.insertar(conn);
a3.insertar(conn);
// Confirma los cambios
conn.commit();
}
catch(Exception e) {
try{
// Vuelve atras los cambios
conn.rollback();
} catch(Exception ee){//Manejo de errores}
} finally{
try{
// Cierra la conexin
if( conn != null )
conn.close();
} catch(Exception e){//Manejo de errores}
}