La creación y gestión de bases de datos MySQL con Java es uno de los conocimientos esenciales que todo Java Programmer debe poseer. Esta guía ha sido diseñada por un principiante, para principiantes, exponiendo los conocimientos básicos que se necesitan para entrar en el mundo del MySQL en Java
A continuación voy a describir paso a paso lo que se necesita para crear una base de datos y utilizar MySQL con Java. Esta guía ha sido diseñada para aquellos usuarios que sean principiantes en el manejo de bases de datos MySQL con Java. Yo alguna vez estuve en dicha posición y cómo me hubiese encantado que alguien me explicara lo que debía hacer paso por paso. Veamos qué es lo que se necesita.
1- Necesitamos contar con MySQL y Apache Server
El Apache y MySQL server son necesarios para que se pueda dar la comunicación de la aplicación Java con la base de datos. Antes ya he escrito en este blog sobre XAMPP y he mostrado cómo crear bases de datos desde PHPmyAdmin. En este tutorial no crearemos las bases de datos con este método sino que a través de programación crearemos y modificaremos la base de datos en MySQL.
Lo que yo recomiendo en cuando al Apache y MySQL servers es descargar e instalar XAMPP. Este programa lo podemos conseguir en su sitio oficial:
Una vez descargado e instalado, abrimos la aplicación y nos aparece la siguiente ventana:
Sólo tenemos que dar clic en «Start» para el MySQL y Apache Servers.
Hemos completado el primer paso de nuestro proceso. Veamos qué sigue.
2- Descargar el MySQL driver para Java
Esta es la librería que hace posible el uso de MySQL con Java. Posee los métodos necesarios para que esto sea posible. La podemos descargar desde el siguiente enlace:
Dentro encontraremos el archivo mysql-connector-java-5.0.8-bin.jar que es el que tendremos que agregar a nuestro proyecto en Netbeans.
Podemos seguir con el siguiente paso.
3- Creamos un proyecto en Netbeans
Creamos un proyecto tipo Java Application llamado MySQL_Test. Dentro vamos a agregar un JFrame y una clase. El JFrame lo vamos a llamar Window y la clase se llamará MySQL. Recordamos agregar la librería que descargamos en el paso anterior.
4- Programamos la clase MySQL
Dentro de la clase MySQL vamos a colocar todos los métodos relacionados al manejo de la base de datos y la conexión con el servidor. Lo primero que haremos será crear una variable global. Estas es:
|
1 |
private static Connection Conexion; |
Ahora creamos un método tipo void llamado MySQLConnection(). Aquí vamos a iniciar una conexión con el servidor MySQL. El código es el siguiente:
|
1 2 3 4 5 6 7 8 9 10 11 |
public void MySQLConnection(String user, String pass, String db_name) throws Exception { try { Class.forName("com.mysql.jdbc.Driver"); Conexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/" + db_name, user, pass); JOptionPane.showMessageDialog(null, "Se ha iniciado la conexión con el servidor de forma exitosa"); } catch (ClassNotFoundException ex) { Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex); } catch (SQLException ex) { Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex); } } |
Como vemos, necesitamos introducir como parámetros el nombre de usuario, la contraseña y el nombre de la base de datos. Podemos hacer una prueba en este momento. Si tenemos todo en orden, creamos una instancia de la clase MySQL en el método de la clase principal (MySQL_Test) y ejecutamos el método MySQLConnection(). Aquí está el código que se coloca en la clase principal:
|
1 2 3 4 |
public static void main(String[] args) { MySQL db = new MySQL(); db.MySQLConnection("root", "", ""); } |
El nombre de usuario por defecto es root. La contraseña y nombre de la base de datos la dejamos en blanco. Si tenemos todo en orden, el resultado debe ser el siguiente:
Podemos agregar un método para finalizar la conexión con el servidor.
|
1 2 3 4 5 6 7 8 |
public void closeConnection() { try { Conexion.close(); JOptionPane.showMessageDialog(null, "Se ha finalizado la conexión con el servidor"); } catch (SQLException ex) { Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex); } } |
Ahora crearemos otro método, esta vez para crear una base de datos. Lo llamaremos createDB(). El código es el siguiente:
|
1 2 3 4 5 6 7 8 9 10 11 12 |
public void createDB(String name) { try { String Query = "CREATE DATABASE " + name; Statement st = Conexion.createStatement(); st.executeUpdate(Query); closeConnection(); MySQLConnection("root", "", name); JOptionPane.showMessageDialog(null, "Se ha creado la base de datos " + name + " de forma exitosa"); } catch (SQLException ex) { Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex); } } |
Un punto que me gustaría resaltar es la variable que he llamado Query. Esta variable contiene una instrucción que es con lo que se trabaja en MySQL. Para las bases de datos, el Query consta de los comantos CREATE TABLE seguido del nombre de la base de datos. Nótese que para que este método se pueda utilizar es necesario primero ejecutar MySQLConnection(). Una vez que se ha creado la Base de Datos, se cierra la conexión y se reinicia, ahora introduciendo como parámetro la base de datos que hemos creado.
Vamos a crear un método para crear una tabla dentro de la base de datos. Lo llamaremos createTable().
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
public void createTable(String name) { try { String Query = "CREATE TABLE " + name + "" + "(ID VARCHAR(25),Nombre VARCHAR(50), Apellido VARCHAR(50)," + " Edad VARCHAR(3), Sexo VARCHAR(1))"; Statement st = Conexion.createStatement(); st.executeUpdate(Query); JOptionPane.showMessageDialog(null, "Se ha creado la tabla " + name + " de forma exitosa"); } catch (SQLException ex) { Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex); } } |
Tenemos lo que se necesita para construir una Base de Datos y una Tabla. El Query esta vez luce un poco diferente. Para crear la tabla se utiliza CREATE TABLE seguido del nombre de la tabla, se abre un paréntesis y se coloca el nombre de las columnas que va a tener y el tipo de dato de cada columna, separando cada una columna de otra con una coma (,). Para este ejemplo utilizará VARCHAR, aunque para la edad bien pude utilizar INT. Entre paréntesis se coloca la cantidad máxima de caracteres que podrá almacenar una celda de determinada columna. La tabla poseerá 5 columnas: ID, Nombre, Apellido, Edad y Sexo.
Ahora hay que crear un método para introducir los registros a la tabla. Crearemos el método insertData(). El código es el siguiente:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
public void insertData(String table_name, String ID, String name, String lastname, String age, String gender) { try { String Query = "INSERT INTO " + table_name + " VALUES(" + "\"" + ID + "\", " + "\"" + name + "\", " + "\"" + lastname + "\", " + "\"" + age + "\", " + "\"" + gender + "\")"; Statement st = Conexion.createStatement(); st.executeUpdate(Query); JOptionPane.showMessageDialog(null, "Datos almacenados de forma exitosa"); } catch (SQLException ex) { JOptionPane.showMessageDialog(null, "Error en el almacenamiento de datos"); } } |
Ahora el Query posee la instrucción INSERT INTO, seguido del nombre de la tabla en la que se quiere insertar la información. Luego se agrega la palabra VALUES y entre paréntesis los valores que se desean insertar, entre comillas. Digamos que queremos introducir la información de Juan Rodríguez, hombre con 19 años de edad. Su ID es 8-835-532. El nombre de la tabla es Registros. El Query quedaría de la siguiente forma:
INSERT INTO Registros VALUES («8-835-532», «Juan», «Rodríguez», «19», «M»);
Ahora vamos a crear un método llamado getValues() para hacer las consultas en la base de datos. Por ahora vamos a imprimir en la consola.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
public void getValues(String table_name) { try { String Query = "SELECT * FROM " + table_name; Statement st = Conexion.createStatement(); java.sql.ResultSet resultSet; resultSet = st.executeQuery(Query); while (resultSet.next()) { System.out.println("ID: " + resultSet.getString("ID") + " " + "Nombre: " + resultSet.getString("Nombre") + " " + resultSet.getString("Apellido") + " " + "Edad: " + resultSet.getString("Edad") + " " + "Sexo: " + resultSet.getString("Sexo")); } } catch (SQLException ex) { JOptionPane.showMessageDialog(null, "Error en la adquisición de datos"); } } |
Ahora el Query está formado por las palabras SELECT * FROM seguidas del nombre de la tabla. El asterisco indica que se desean consultar todos los valores de una fila determinada. Para hacer la consulta necesitamos crear un resultSet. Esta variable funciona como una cabeza lectora que va leyendo fila a fila. Con el método getString() leemos las columnas que deseamos.
Ahora le vamos a agregar un método para borrar registros. Lo llamaremos deleteRecord() y le introduciremos como parámetro el nombre de la tabla y el ID del registro que queremos eliminar.
|
1 2 3 4 5 6 7 8 9 10 11 |
public void deleteRecord(String table_name, String ID) { try { String Query = "DELETE FROM " + table_name + " WHERE ID = \"" + ID + "\""; Statement st = Conexion.createStatement(); st.executeUpdate(Query); } catch (SQLException ex) { System.out.println(ex.getMessage()); JOptionPane.showMessageDialog(null, "Error borrando el registro especificado"); } } |
Quizás podríamos agregar métodos para borrar tablas y bases de datos pero vamos a dejarlo así por ahora. Hemos terminado de programar la clase MySQL. Aquí la tenemos:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 |
package mysql_test; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.Statement; import java.util.logging.Level; import java.util.logging.Logger; import javax.swing.JOptionPane; public class MySQL { private static Connection Conexion; public void MySQLConnection(String user, String pass, String db_name) { try { Class.forName("com.mysql.jdbc.Driver"); Conexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/" + db_name, user, pass); System.out.println("Se ha iniciado la conexión con el servidor de forma exitosa"); } catch (ClassNotFoundException ex) { Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex); } catch (SQLException ex) { Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex); } } public void closeConnection() { try { Conexion.close(); System.out.println("Se ha finalizado la conexión con el servidor"); } catch (SQLException ex) { Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex); } } public void createDB(String name) { try { String Query = "CREATE DATABASE " + name; Statement st = Conexion.createStatement(); st.executeUpdate(Query); MySQLConnection("root", "", name); JOptionPane.showMessageDialog(null, "Se ha creado la base de datos " + name + " de forma exitosa"); } catch (SQLException ex) { Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex); } } public void createTable(String name) { try { String Query = "CREATE TABLE " + name + "" + "(ID VARCHAR(25),Nombre VARCHAR(50), Apellido VARCHAR(50)," + " Edad VARCHAR(3), Sexo VARCHAR(1))"; JOptionPane.showMessageDialog(null, "Se ha creado la base de tabla " + name + " de forma exitosa"); Statement st = Conexion.createStatement(); st.executeUpdate(Query); } catch (SQLException ex) { Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex); } } public void insertData(String table_name, String ID, String name, String lastname, String age, String gender) { try { String Query = "INSERT INTO " + table_name + " VALUES(" + "\"" + ID + "\", " + "\"" + name + "\", " + "\"" + lastname + "\", " + "\"" + age + "\", " + "\"" + gender + "\")"; Statement st = Conexion.createStatement(); st.executeUpdate(Query); JOptionPane.showMessageDialog(null, "Datos almacenados de forma exitosa"); } catch (SQLException ex) { JOptionPane.showMessageDialog(null, "Error en el almacenamiento de datos"); } } public void getValues(String table_name) { try { String Query = "SELECT * FROM " + table_name; Statement st = Conexion.createStatement(); java.sql.ResultSet resultSet; resultSet = st.executeQuery(Query); while (resultSet.next()) { System.out.println("ID: " + resultSet.getString("ID") + " " + "Nombre: " + resultSet.getString("Nombre") + " " + resultSet.getString("Apellido") + " " + "Edad: " + resultSet.getString("Edad") + " " + "Sexo: " + resultSet.getString("Sexo")); } } catch (SQLException ex) { JOptionPane.showMessageDialog(null, "Error en la adquisición de datos"); } } public void deleteRecord(String table_name, String ID) { try { String Query = "DELETE FROM " + table_name + " WHERE ID = \"" + ID + "\""; Statement st = Conexion.createStatement(); st.executeUpdate(Query); } catch (SQLException ex) { System.out.println(ex.getMessage()); JOptionPane.showMessageDialog(null, "Error borrando el registro especificado"); } } } |
Vamos al siguiente paso.
5- Creamos una interfaz gráfica
Vamos a la clase Window.java y diseñamos una sencilla interfaz de usuario.
Colocamos los 4 botones con las opciones que deseamos que posea nuestra aplicación. Las opciones «Registrar Usuario«, «Obtener Registros» y «Borrar Registro» se encuentran inactivas ya que no pueden ser ejecutadas si no se inicia la conexión con el servidor MySQL.
Vamos a crear una clase con un formulario de registro y una con la opción de borrar un registro. He agregado las clases Window_Register y Window_Delete con las siguientes interfaces gráficas.
Podemos pasar al siguiente paso.
6- Programamos la interfaz gráfica
La prioridad de toda aplicación Java es ejecutar el método main de la clase principal. Vamos a crear una instancia para que lo primero que haga nuestro programa sea mostrarnos la ventana principal.
Nuestro método main de la clase MySQL_Test quedaría de la siguiente forma:
|
1 2 3 4 |
public static void main(String[] args) { Window w = new Window(); w.setVisible(true); } |
Ahora cada vez que ejecutamos nuestro programa nos aparece la ventana principal. Vamos a programar la clase Window.java.
Primero creamos un objeto llamado db como una instancia de la clase MySQL. En el botón «Conectar a base de Datos» debemos colocar el siguiente código:
|
1 2 3 |
db.MySQLConnection("root", "", ""); db.createDB("MySQL_Test"); db.createTable("Registros"); |
Ejecutemos el programa para ver si todo está en orden.
En nuestro PHPMyAdmin (en XAMPP presionamos el botón Admin al lado de MySQL) nos debe aparecer una nueva base de datos con la tabla registros en su interior.
Ahora el código que colocamos en el botón debemos cambiarlo, ya que no podemos crear una base de datos con el mismo nombre 2 veces. Ya tenemos nuestra base de datos con la tabla registros dentro, así que vamos a cambiar la programación.
|
1 2 3 4 5 |
db.MySQLConnection("root", "", "MySQL_Test"); jButtonConnect.setEnabled(false); jButtonDelete.setEnabled(true); jButtonGet.setEnabled(true); jButtonRegister.setEnabled(true); |
Vemos que al iniciar la conexión se des habilita el botón de conectar y se habilitan los demás botones. A continuación el código para cada botón:
Ahora vamos a cada ventana que hemos agregado y programamos los botones. Primero la ventana de borrar registros.
En el botón de Borrar Registro colocamos:
|
1 2 3 4 5 |
MySQL db = new MySQL(); db.MySQLConnection("root", "", "MySQL_Test"); db.deleteRecord("Registros", jTextFieldID.getText()); db.closeConnection(); this.dispose(); |
Instanciamos la clase MySQL, luego abrimos una conexión, borramos el registro con el ID que se haya introducido en el TextField y cerramos la conexión. Por último cerramos la ventana.
Ahora vamos a la ventana de registro de datos. La programación del botón Registrar es la siguiente:
|
1 2 3 4 5 6 7 8 9 |
MySQL db = new MySQL(); db.MySQLConnection("root", "", "MySQL_Test"); db.insertData("Registros", jTextFieldID.getText(), jTextFieldNombre.getText(), jTextFieldApellido.getText(), jTextFieldEdad.getText(), jComboBoxSexo.getSelectedItem().toString()); db.closeConnection(); this.dispose(); |
Nuestro código nos queda así:
Con esto hemos terminado nuestra programación. Tenemos una pequeña aplicación que nos permite registrar información en una base de datos, imprimirla y borrar ciertos registros.
7- Probamos nuestra aplicación
Ya que tenemos nuestro código terminado podemos proceder a probar lo que hemos hecho. El proyecto completo puede ser descargado desde Github, en el siguiente enlace:
A continuación un video donde se muestra el funcionamiento de esta aplicación.
El proyecto está tal como lo he desarrollado para este tutorial. Debemos recordar que esto no es una aplicación, sino una demostración. Los métodos pueden ser mejorados y hay algunas cosas que se pueden hacer de una mejor forma que la que he plasmado en este tutorial, pero queda en ustedes desarrollar sus habilidades en el uso de MySQL a partir de lo que ya les he mostrado aquí.
Espero sus comentarios. Saludos.
