Conectar Java con MySQL

en Netbeans
 11 marzo, 2015  Ferchu  Java, MySQL

Bueno, sinceramente llevo poco tiempo trabajando con Java, aunque de a poco estoy
tomándole aprecio a este excelente lenguaje de programación. Sí en cambio llevo
muchos años trabajando en web, más precisamente con PHP y MySQL. En esta ocasión
voy a explicar de forma muy resumida, los pasos a seguir para conectar Java con
MySQL.

Java puede conectarse a múltiples bases de datos, con la que mejor se lleva es con
Oracle, sin embargo en ocasiones puede ser que los que venimos de la web, al tener la
necesidad de hacer una aplicación de escritorio, nos sintamos más acostumbrados con
MySQL.

En primer lugar, para realizar este ejemplo debemos tener instalado tres cosas en
nuestro sistema:

 La máquina virtual de Java (Para ejecutar Java, claro está)

 MySQL (en mi caso yo tengo instalado Xampp que viene con Apache y
MySQL, entre otros servicios
 Netbeans (Con Java instalado)

¡Comencemos!

MySQL

En primer lugar vamos a crear una base de datos, a la cual yo llamaré: java_mysql. La

mista tendrá una sola tabla llamada tareas con el siguiente código:

CREATE TABLE tareas(

id_tarea int(10) unsigned not null auto_increment primary key,
titulo varchar (50) not null,
descripcion varchar(255) not null,
 nivel_de_prioridad tinyint(1) not null
);

Java

Vamos a abrir Netbeans y vamos a crear un nuevo proyecto, yendo a File -> New
Project -> Java -> Java Application.

Vamos a ponerle un nombre y vamos a guardarlo en alguna parte de nuestra máquina.

Vamos a borrar todo lo que esté dentro de la carpeta source (o src) y dentro vamos a

crear dos paquetes, uno al que yo llamaré modelos y otro al que llamaré servicios.

 
Ahora, para conectar Java a MySQL tenemos que agregar un librería que se encargará
de hacer esa magia. Así que dentro que pulsando botón derecho sobre la carpeta
Libraries, vamos a ir a Add Library

Y agregamos la librería MySQL JDBC Driver, primero seleccionándola y luego

pulsando Add Library.

Bueno, ya tenemos todo, no nos falta nada. Ya podemos empezar a escribir código Java.

Dentro del paquete modelos, vamos a crear una clase, a la que yo llamaré Tarea.java,

con el siguiente código:

package modelos;
public class Tarea {
private final Integer id_tarea;
 private String titulo;
private String descripcion;
private Integer nivel_de_prioridad;
public Tarea() {
this.id_tarea = null;
this.titulo = null;
this.descripcion = null;
this.nivel_de_prioridad = null;
}
public Tarea(Integer id_tarea, String titulo, String descripcion, Integer
nivel_de_prioridad) {
this.id_tarea = id_tarea;
this.titulo = titulo;
this.descripcion = descripcion;
this.nivel_de_prioridad = nivel_de_prioridad;
}
public Integer getId_tarea() {
return id_tarea;
}
public String getTitulo() {
return titulo;
}
public String getDescripcion() {
return descripcion;
}
public Integer getNivel_de_prioridad() {
return nivel_de_prioridad;
}
public void setTitulo(String titulo) {
this.titulo = titulo;
}
public void setDescripcion(String descripcion) {
this.descripcion = descripcion;
}
public void setNivel_de_prioridad(Integer nivel_de_prioridad) {
this.nivel_de_prioridad = nivel_de_prioridad;
 }
@Override
public String toString() {
return "Tarea{" + "id_tarea=" + id_tarea + ", titulo=" + titulo + ",
descripcion=" + descripcion + ", nivel_de_prioridad=" + nivel_de_prioridad +
'}';
}
}

Una clase, nada nuevo, que va a representar el modelo de una tarea.

Conectando JAVA con MySQL 

Bien, ahora creamos la clase que va a conectar nuestra aplicación con MySQL, yendo al
paquete servicios, vamos a crear una nueva clase llamada Conexion.javacon el
siguiente código:

package servicios;
import java.sql.*;
public class Conexion {
private static Connection cnx = null;
public static Connection obtener() throws SQLException,
ClassNotFoundException {
if (cnx == null) {
try {
Class.forName("com.mysql.jdbc.Driver");
cnx =
DriverManager.getConnection("jdbc:mysql://localhost/java_mysql", "root", "");
} catch (SQLException ex) {
throw new SQLException(ex);
} catch (ClassNotFoundException ex) {
throw new ClassCastException(ex.getMessage());
}
}
return cnx;
}
public static void cerrar() throws SQLException {
 if (cnx != null) {
cnx.close();
}
}
}

Esta clase tendrá un método estático llamado obtener(), el cual va a devolvernos una

instancia de conexión y de no haber una previa va crear una:

cnx = DriverManager.getConnection("jdbc:mysql://localhost/java_mysql",
"root", "");

Esto gracias al método getConnection(), el cuál recibirá como primer parámetro el tipo

de base de datos (MySQL) y la ubicación de la base de datos, en mi caso, como estoy
trabajando en un entorno local, será localhost. El segundo parámetro es el usuario y el
tercero la contraseña.

A su vez este método puede disparar dos excepciones, SQLException, si surge algún

error, por ejemplo que no se pueda conectar a la base de datos,
y ClassNotFoundException, en caso de que no encuentre la librería.

Y por último el método, también estático, cerrar(), que como su nombre lo indica,

cerrará la conexión, en caso de que haya alguna abierta.

Consultas

Para hacer las consultas con la base de datos, dentro del paquete servicios, creamos una
clase con el nombre: Tareas_servicio.java con el siguiente código:

package servicios;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import modelos.Tarea;
public class Tareas_servicio {
private final String tabla = "tareas";
public void guardar(Connection conexion, Tarea tarea) throws SQLException{
 try{
PreparedStatement consulta;
if(tarea.getId_tarea() == null){
consulta = conexion.prepareStatement("INSERT INTO " + this.tabla
+ "(titulo, descripcion, nivel_de_prioridad) VALUES(?, ?, ?)");
consulta.setString(1, tarea.getTitulo());
consulta.setString(2, tarea.getDescripcion());
consulta.setInt(3, tarea.getNivel_de_prioridad());
}else{
consulta = conexion.prepareStatement("UPDATE " + this.tabla + "
SET titulo = ?, descripcion = ?, nivel_de_prioridad = ? WHERE id_tarea = ?");
consulta.setString(1, tarea.getTitulo());
consulta.setString(2, tarea.getDescripcion());
consulta.setInt(3, tarea.getNivel_de_prioridad());
consulta.setInt(4, tarea.getId_tarea());
}
consulta.executeUpdate();
}catch(SQLException ex){
throw new SQLException(ex);
}
}
public Tarea recuperarPorId(Connection conexion, int id_tarea) throws
SQLException {
Tarea tarea = null;
try{
PreparedStatement consulta = conexion.prepareStatement("SELECT
titulo, descripcion, nivel_de_prioridad FROM " + this.tabla + " WHERE
id_tarea = ?" );
consulta.setInt(1, id_tarea);
ResultSet resultado = consulta.executeQuery();
while(resultado.next()){
tarea = new Tarea(id_tarea, resultado.getString("titulo"),
resultado.getString("descripcion"), resultado.getInt("nivel_de_prioridad"));
}
}catch(SQLException ex){
throw new SQLException(ex);
}
return tarea;
 }
public void eliminar(Connection conexion, Tarea tarea) throws
SQLException{
try{
PreparedStatement consulta = conexion.prepareStatement("DELETE FROM
" + this.tabla + " WHERE id_tarea = ?");
consulta.setInt(1, tarea.getId_tarea());
consulta.executeUpdate();
}catch(SQLException ex){
throw new SQLException(ex);
}
}
public List<Tarea> recuperarTodas(Connection conexion) throws
SQLException{
List<Tarea> tareas = new ArrayList<>();
try{
PreparedStatement consulta = conexion.prepareStatement("SELECT
id_tarea, titulo, descripcion, nivel_de_prioridad FROM " + this.tabla + "
ORDER BY nivel_de_prioridad");
ResultSet resultado = consulta.executeQuery();
while(resultado.next()){
tareas.add(new Tarea(resultado.getInt("id_tarea"),
resultado.getString("titulo"), resultado.getString("descripcion"),
resultado.getInt("nivel_de_prioridad")));
}
}catch(SQLException ex){
throw new SQLException(ex);
}
return tareas;
}
}

Esta clase cuenta con los métodos capaces de realizar las distintas operaciones en una
tabla.

El método guardar(), que recibirá como parámetro una instancia de conexión y un

objeto Tarea. Si el objeto tiene el valor de id nulo, va a hacer un insert, de lo contrario
un update en el registro con dicho id.
El método recuperarPorId(), recibirá la conexión y un id, y nos devolverá un
objeto Tarea correspondiente a ese id, de lo contrario nos devolverá un valor null, en
caso de que no encuentre ningún registro con ese id.

El método eliminar() recibirá un una instancia de conexión y el objeto Tarea que debe

eliminar.

Y finalmente recuperarTodas() también recibirá una instancia de conexión y nos

devolverá una lista con todas las tareas.