Conectar Java con MySQL en Netbeans

 

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.java con 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.

Bueno a continuación dejo un ejemplo muy sencillo con interfaz gráfica, para verificar cómo queda.

Saludos!