Procedimientos para acceso a Base de Datos Mediante JDBC

Para utilizar JDBC deberemos importar las librerias Java referentes a acceso a Base de Datos, para
ello las sentencias import a realizar al principio de nuestro codigo serán:
import java.sql.*;//Clases basicas para sql
import java.sql.Statement;//Sentencias a ejecutar
Por ejemplo para conseguir una conexión a la Base de datos podemos realizar el siguiente método
que devuelve ya una conexión abierta con la Base de Datos.

public static Connection abrirConexionBD(String bd,String usuario,String passwd){

java.sql.Connection conn=null;
try{
Class.forName("com.mysql.jdbc.Driver").newInstance(); //Nueva instancia del Driver
conn=DriverManager.getConnection(bd,usuario,passwd); //Abre la conexión
}
catch (Exception e){
System.out.println("Error en Conexion a BD");
System.out.println(e.getMessage());
}
return conn;
}

Este método aceptará la cadena de conexión a base de datos, el usuario y contraseña de la base de
datos y realizará la conexión, devolviéndola en el objeto conn , algunos ejemplos de cadena de
conexión son los siguientes:

● Para Mysql:
“jdbc:mysql://servidorBd:puerto/BD”
siendo servidorBD la ruta de nuestro servidor de BD, ya sea una IP o nombre de dominio
siendo puerto el puerto tcp que utiliza Mysql en nuestro servidor.(Normalmente 3306)
siendo BD la Base de datos a la que vamos a conectar en dicho servidor.
Como nota debemos tener en cuenta que para el formato de fecha puede dar problemas si no
expecificamos una propiedad al controlador Mysql, dicha propiedad es
zeroDateTimeBehavior y debemos especificarle que convierta las fechas vacias a NULL,
para ello la cadena de conexión quedará de la siguiente manera:
“jdbc:mysql://servidorBd:puerto/BD?zeroDateTimeBehavior=convertToNull”

● Para Postgres:
“jdbc:postgresql://servidorBd:puerto/BD”
siendo servidorBD la ruta de nuestro servidor de BD, ya sea una IP o nombre de dominio
siendo puerto el puerto tcp que utiliza postgres en nuestro servidor.(Normalmente 5432)
siendo BD la Base de datos a la que vamos a conectar en dicho servidor.
Para cerrar la conexión con la base de datos podemos usar por ejemplo este método.

public static Connection cerrarConexionBD(Connection conn){

try{
conn.close();
}
catch (Exception e){
System.out.println("Error al cerrar la conexion");
System.out.println(e.getMessage());
}
return conn;
}

Cuando queremos ejecutar una instrucción sql sobre la conexión que hemos creado el
procedimiento será el siguiente:

Crearemos un objeto de tipo Statement ejecutando el método createstatement() del objeto conexión ,
este objeto Statement será la instrucción SQL a ejecutar:
Statement sentencia= conn.createStatement();

Crearemos la sentencia sql a ejecutar en una variables de tipo String:

String cadena=”SELECT * FROM Tabla1;”;

Ejecutaremos la sentencia sobre la conexión de la base de datos utilizando el objeto Statement que
creamos anteriormente, en este caso llamaremos a un metodo del objeto sentencia distinto
dependiendo del tipo de instrucción a ejecutar, por ejemplo:

● Para sentencias de consulta utilizaremos el metodo executeQuery(sentencia), este método

devolverá un objeto ResulSet que veremos posteriormente como recorrer.

● Para sentencias de actualización utilizaremos el método executeUpdate(sentencia) , este

método devolverá el numero de filas afectadas (formato int).

En el ejemplo anterior “SELECT * FROM Tabla1” ejecutaremos la sentencia de la siguiente forma:

ResulSet rs=conn.executeQuery(cadena);

Para recorrer este Resulset utilizaremos el método next que al inicio estará posicionado sobre el
primer registro, para ello:
while (rs.next()){
// Las instrucciones que queramos realizar
}
Como ejemplo veamos como exportar una tabla a datos tabulados dentro de un fichero en el cual
cada registro es una linea.

public static void exportarTablaTabulada(PrintStream out,Connection conn,String fichero,String tabla){

/* En principio no sabemos cuantas columnas que tendremos en la tabla,

* así que lo obtendremos de los metadatos, meteremos dichos datos en
* una lista e iremos sacando los datos del Resulset utilizando
* los nombres de campo incluidos en la lista*/
String comando= "SELECT * FROM "+tabla+";";
ResultSetMetaData metadatos;
int numeroColumnas =0;
int col=0;
ArrayList <String> listaCampos= new ArrayList<String>();
PrintWriter salida=null;
try{
//Creamos el fichero de destino, en caso de existir se sobreescribira
salida=new PrintWriter(new BufferedWriter(new FileWriter(fichero)));
}

catch(Exception e){
out.println("Error E/S");
}

try{
Statement sentencia= conn.createStatement();
sentencia.executeQuery(comando);
ResultSet rs=sentencia.getResultSet();
//ahora debemos recorrer el resulset paso a paso
metadatos=rs.getMetaData();
//Obtenemos los nombres de columna introduciendolos en un ArrayList
numeroColumnas =metadatos.getColumnCount();
for (col=1;col<numeroColumnas;col++){
listaCampos.add(metadatos.getColumnName(col));
}
// Recorremos los registros
while (rs.next()){
// Recorremos los campos utilizando el ArrayList que posee sus nombres
for (String i:listaCampos){
salida.print(rs.getString(i));//escribimos el valor del campo en fichero
salida.print("\t");// escribimos un tabulador
}
salida.print("\n");//Escribimos un salto de linea despues del ultimo campo
}
salida.close();//cerramos el fichero
}
catch (Exception e){
out.println("Error al Exportar Tabla");
out.println(e.getMessage());
out.println(e.toString());
}

}
Para este ejemplo suponemos que tenemos una base de datos que deseamos exportar de manera
tabulada de manera que cada tabla se exporte en un fichero txt que se denomine con el nombre de la
tabla correspondiente. No conocemos ningun dato de la Base de datos tan solo los necesarios para
establecer la conexión y también sabemos el directorio donde debemos exportar los ficheros.

En este ejemplo podemos ver como obtenemos un objeto DatabaseMetaData que posee los
metadatos de la base de datos, para obtener todos los objetos tabla que posee utilizamos el método
getTables de dicho objeto con los siguientes parámetros: null, null, nombreTablas, tipos donde los
dos primeros null son referentes al catálogo de tablas y al esquema de tablas, el parámetro
nombreTablas se refiere a que nombres de tablas deseamos obtener (utilizaremos la cadena “%”
para indicar todas) y tipos es un array de String que posee en cada registro un tipo de datos que
deseamos obtener que en nuestro caso será tipos[0]= "TABLE".
Recorreremos el resultado obteniendo todos los nombres de tablas e incluyendolos en el ArrayList
listaTablas, posteriormente mediante un bucle recorreremos dicha lista exportando cada tabla al
fichero correspondiente.

public static void exportarBdTabulada(PrintStream out,Connection conn,String ruta){

/* En principio no sabemos cuantas Tablas tendremos en la Bd, así que lo obtendremos de los metadatos
* de Bd, meteremos dichos datos en una lista e iremos sacando los datos del Resulset utilizando
* los nombres de tabla incluidos en la lista, para cada tabla crearemos un fichero con el nombre de la
* tabla y extensión txt en el directorio indicado
* En este caso pedimos al usuario un Directorio, por lo que debemos comprobar que realmente existe
* y que se trata de un directorio.
*/
int numeroColumnas =0;
String [] tipos=new String[1];
String nombreTablas="%";
tipos[0]= "TABLE";
ArrayList <String> listaTablas= new ArrayList<String>();
File fich=new File(ruta);
if (fich.exists()&&fich.isDirectory()){
try{
DatabaseMetaData bdMetadatos=conn.getMetaData();
ResultSet tablas = bdMetadatos.getTables( null, null, nombreTablas, tipos );
// Introducimos los nombres de las tablas en un ArrayList
while(tablas.next()){
listaTablas.add(tablas.getString(tablas.findColumn( "TABLE_NAME" )));
}
// Exportamos cada tabla a su fichero correspondiente en el directorio
for (String i:listaTablas){
exportarTablaTabulada(out,conn,ruta+i+".txt",i);
}
}
catch (Exception e){
out.println("Error en la conexión a la BD");
out.println(e.getMessage());
}
}
else{
out.println("Error la ruta proporcionada no existe ó no es un directorio.");
}
}