Para poder hacer una recuperación de datos en java, lo primero que debemos hacer es crear una conexión a una base de datos.
Una vez creada esta conexión, no solo vamos a poder consultar los datos que deseemos, sino que también vamos a poder manipularlos. Es decir, vamos a poder realizar inserción, actualización o eliminación de información.
Para manipular la información de una base de datos, debemos saber combinar tanto el lenguaje de programación java, con el lenguaje de acceso a datos SQL.
Las cláusulas que debemos conocer para poder manejar la información de una BBDD son:
- Insert: Utilizaremos esta instrucción para insertar información en una tabla de la base de datos.
- Update: Esta cláusula del lenguaje SQL, nos va a permitir actualizar la información de una tabla.
- Delete: Para eliminar registros de una tabla de la base de datos.
- Select: Con esta instrucción podremos consultar la información de una tabla.
Para realizar la manipulación de datos de la base de datos y recuperación de información en java, vamos a basarnos en el ejemplo del artículo anterior.
Sin embargo, vamos a realizar un pequeño cambio. Trasladaremos este código a una clase llamada Conexion, quedando una clase como la siguiente.
Creando la clase Conexión para conectarnos a la base de datos.
package conexionbbdd;
import java.sql.*;
/**
*
* @author Fran
* Clase encargada de conectar y desconectar de una base de datos
*/
public class Conexion {
/* Declaramos 5 variables con el driver, la bbdd, usuario y contraseña
y una para almacenar el error en caso de suceder*/
private static final String driver="com.mysql.jdbc.Driver";
private static final String bbdd="jdbc:mysql://localhost:3306/gestion";
private static final String usuario ="root";
private static final String clave="";
private static Connection conex = null;
private static String error="";
/**
*
* @return Devuelve la conexión a una base de datos
*/
public static Connection getConexion(){
//Controlamos la excepciones que puedan surgir al conectarnos a la BBDD
try {
//Registrar el driver
Class.forName(driver);
//Creamos una conexión a la Base de Datos
conex = DriverManager.getConnection(bbdd, usuario, clave);
// Si hay errores informamos al usuario.
} catch (Exception e) {
error = e.getMessage();
return null;
}
// Devolvemos la conexión.
return conex;
}
/**
*
* @param conex Parámetro que contiene la conexión que deseamos cerrar
*/
public static void getCerrarConexion(Connection conex){
try{
conex.close(); // Cerramos la conexión
}catch(SQLException e){
error = e.getMessage();
}
}
/**
*
* @return Devuelve el error en caso de no poder conectar o desconectar
* de la base de datos.
*/
public String getError(){
return error;
}
}
Creando el objeto cliente.
package conexionbbdd;
import java.util.Date;
import java.text.ParseException;
import java.text.SimpleDateFormat;
/**
*
* @author Fran
* Clase que contiene las características de un cliente.
*/
public class Cliente {
private int id;
private String nombre;
private String direccion;
private String fechaAlta;
private Date fecha;
/**
*
* @return Devuelve el id del cliente
*/
public int getId() {
return id;
}
/**
*
* @param id Establece un id
*/
public void setId(int id) {
this.id = id;
}
/**
*
* @return devuelve el nombre del cliente
*/
public String getNombre() {
return nombre;
}
/**
*
* @param nombre Establece el nombre de un cliente
*/
public void setNombre(String nombre) {
this.nombre = nombre;
}
/**
*
* @return Devuelve la dirección de un cliente
*/
public String getDireccion() {
return direccion;
}
/**
*
* @param direccion Establece una dirección para el cliente
*/
public void setDireccion(String direccion) {
this.direccion = direccion;
}
/**
*
* @return Devuelve la fecha en formato Date
*/
public Date getFecha() {
SimpleDateFormat formato = new SimpleDateFormat("dd/MM/yyyy");
try {
fecha = formato.parse(fechaAlta);
}
catch (ParseException ex)
{
System.out.println(ex);
}
return fecha;
}
/**
*
* @param fechaAlta Establece una fecha de alta del cliente
*/
public void setFechaAlta(String fechaAlta) {
this.fechaAlta = fechaAlta;
}
}
Comprobando el estado del cliente.
Para comprobar que el cliente se crea correctamente, usaremos un JOptionPane para introducir los datos. Posteriormente y de forma opcional, mostraremos los datos por consola. Esto lo haremos ya en una clase que llamaremos Principal y que contendrá el método main. Aunque vamos a mostrar este paso como ejemplo, esto no sería necesario para nuestro programa.
package conexionbbdd;
import javax.swing.JOptionPane;
/**
* Clase encargada de arrancar la aplicación
* @author Fran
*/
public class Principal {
private static Cliente nuevoCliente = new Cliente();
private static String nombre="";
private static String direccion="";
private static String fechaDeAlta="";
/**
*
* @param args Metodo principal del programa
*/
public static void main(String[] args) {
// Pedimos los datos.
nombre = JOptionPane.showInputDialog(null,
"Introduce un nombre para el cliente.");
direccion = JOptionPane.showInputDialog(null,
"Introduce una dirección para el cliente.");
fechaDeAlta = JOptionPane.showInputDialog(null,
"Introduce una fecha de alta en la empresa para el cliente.");
// Le damos los valores al cliente.
nuevoCliente.setNombre(nombre);
nuevoCliente.setDireccion(direccion);
nuevoCliente.setFechaAlta(fechaDeAlta);
// Mostramos los datos por consola.
System.out.println("Nombre: " + nuevoCliente.getNombre());
System.out.println("Dirección: " + nuevoCliente.getDireccion());
System.out.println("Fecha de alta: " + nuevoCliente.getFecha());
}
}
Manipulación y recuperación de datos en java.
Una vez tenemos creada la conexión con la base de datos, el objeto Cliente, hemos comprobado que el objeto se crea correctamente, ya podremos acceder a una tabla para poder manipular o recuperar datos. En este caso, utilizaremos para este ejemplo una tabla clientes dentro de la base de datos gestión.
Para ello debemos tener en cuenta que campos contiene la tabla clientes. En nuestro ejemplo, dicha tabla contiene los siguientes campos. Id, nombre, dirección y fecha de alta.
Introducción de datos. Cláusula Insert con un objeto Statement.
Para poder introducir los datos lo primero que debemos hacer es crear un método para ello. En la clase conexión crearemos un objeto de tipo Statement. Por este motivo, crearemos una variable a nivel de clase de tipo Statement.
private Statement miStatement=null;
A continuación, crearemos un método llamado insertarActualizarRegistros, que recibirá un parámetro de tipo String con la consulta SQL correspondiente. Este método devolverá verdadero si se ha podido insertar el registro.
public boolean insertarActualizarRegistros(String consultaSQL) {
try {
// Creamos el objeto Statement.
miStatement=conex.createStatement();
// Ejecutamos el objeto pasandole la consulta
// que se le está pasando por parámetro.
miStatement.executeUpdate(consultaSQL);
} catch (SQLException ex) {
System.out.println(ex.getMessage());
return false;
}
return true;
}
Para finalizar con la inserción de registros en la base de datos a través del objeto Statement, crearemos en la clase principal, la consulta SQL e insertaremos el registro.
// Creamos la consulta de insercion.
sql = "Insert into clientes(nombre,direccion)Values('"
+ nuevoCliente.getNombre() + "', '"
+ nuevoCliente.getDireccion() + "')";
// Instanciamos la clase conexión y nos conectamos a la base de datos.
Conexion miConex = new Conexion();
/*Intentamos conectarnos a la base de datos y ejecutar el método
para insertar los registros en la base de datos*/
try {
// Si se establece la conexión entonces...
if(miConex.getConexion() !=null){
// Si el metodo insertarRegistros devuelve true....
if(miConex.insertarActualizarRegistros(sql)){
System.out.println("Registro agregado correctamente");
}
else{
System.out.println("No se ha podido agregar el registro");
}
}
else{ // Si no se puede establecer la conexión...
System.out.println("No se ha podido conectar con la BBDD");
}
} catch (Exception e) {
// Si surge algun error lo mostramos
System.out.println(e.getMessage());
}
Actualización de datos. Cláusula Update.
Para actualizar registros dentro de una base de datos, sólo debemos cambiar la sentencia sql, de forma que, en lugar de usar una cláusula insert, usaremos una clausula update.
Vamos a ver el ejemplo para actualizar un cliente de una base de datos.
/**
*
* @param args Metodo principal del programa
*/
public static void main(String[] args) {
// Pedimos el nombre del cliente al cual queremos actualizar sus datos.
nombre = JOptionPane.showInputDialog(null,
"Introduce un nombre del cliente que quieres actualizar.");
direccion = JOptionPane.showInputDialog(null,
"Introduce la nueva dirección para el cliente.");
// Creamos la consulta de actualizacion.
sql = "Update clientes set direccion = '" + direccion
+ "' where nombre='" + nombre + "'";
// Instanciamos la clase conexión y nos conectamos a la base de datos.
Conexion miConex = new Conexion();
/*Intentamos conectarnos a la base de datos y ejecutar el método
para insertarActualizarRegistros los registros en la base de datos*/
try {
// Si se establece la conexión entonces...
if(miConex.getConexion() !=null){
if(miConex.insertarActualizarRegistros(sql)==true){
System.out.println("Registro actualizado correctamente");
}
else{
System.out.println("El registro no ha podido actualizarse");
}
}
else{
System.out.println("No se ha podido conectar");
}
} catch (Exception e) {
// Si surge algun error lo mostramos
System.out.println(e.getMessage());
}
}
}
Recuperación de datos en java. Clausula Select.
Cuando hacemos una recuperación de datos en java, o lo que es lo mismo una consulta de datos, utilizaremos la cláusula Select del lenguaje SQL.
Sin embargo esto no es todo. Debemos saber que cuando hacemos una consulta a una base de datos a través de java, estos datos consultados se almacenan en una especie de tabla virtual.
En este caso para poder realizar la consulta a la base de datos, utilizaremos además de la cláusula Select, un objeto de tipo ResultSet. Este objeto es una especie de tabla virtual donde se almacenan los datos a consultar.
En este ejemplo de consulta de información a la base de datos, crearemos en la clase conexión un método que nos va a devolver un objeto de tipo ResultSet. Esto lo haremos de la siguiente manera.
Crearemos un objeto de tipo ResultSet en la clase conexión a nivel de clase.
private ResultSet miResultSet = null;
Crearemos un método que nos va a devolver un ResultSet.
public ResultSet consultarDatos(String consultaSQL){
try {
// Creamos el objeto Statement.
miStatement=conex.createStatement();
// Asignamos la ejecución de la consulta al objeto ResultSet
miResultSet=miStatement.executeQuery(consultaSQL);
} catch (Exception e) {
// Si hay errores no devolvemos nada
System.out.println(e.getMessage());
return null;
}
//Si todo va bien devolvemos el resultset
return miResultSet;
}
Una vez que tengamos los datos en este objeto, los mostraremos por consola.
private static ResultSet resultSetConsulta=null;
/**
*
* @param args Metodo principal del programa
*/
public static void main(String[] args) {
sql="Select * From clientes";
// Instanciamos la clase conexión y nos conectamos a la base de datos.
Conexion miConex = new Conexion();
/*Intentamos conectarnos a la base de datos y ejecutar el método
para insertar los registros en la base de datos*/
try {
// Si se establece la conexión entonces...
if(miConex.getConexion() !=null){
// Asignamos el resultado a un ResultSet
resultSetConsulta=miConex.consultarDatos(sql);
// Mostramos los resultados
while(resultSetConsulta.next()){
System.out.println(resultSetConsulta.getInt(1)
+ " " + resultSetConsulta.getString(2)
+ " " + resultSetConsulta.getString(3)
+ " " + resultSetConsulta.getTimestamp(4));
}
}
else{
System.out.println("No se ha podido conectar");
}
} catch (Exception e) {
// Si surge algun error lo mostramos
System.out.println(e.getMessage());
}
}