Los 7 pasos a seguir para el manejo de MySQL

con Java
Por
Antony García González
-
enero 4, 2015
0
49159

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:

Descargar XAMPP

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:

MySQL Driver JDBC

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 public void MySQLConnection(String user, String pass, String db_name) throws Exception {
2 try {
3 Class.forName("com.mysql.jdbc.Driver");
4 Conexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/" + db_name, user, pass);
5 JOptionPane.showMessageDialog(null, "Se ha iniciado la conexión con el servidor de forma exitosa");
6 } catch (ClassNotFoundException ex) {
7 Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex);
8 } catch (SQLException ex) {
9 Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex);
10 }
11 }

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 public static void main(String[] args) {

2 MySQL db = new MySQL();
3 db.MySQLConnection("root", "", "");
4 }
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 public void closeConnection() {

2 try {
3 Conexion.close();
4 JOptionPane.showMessageDialog(null, "Se ha finalizado la conexión con el servidor");
5 } catch (SQLException ex) {
6 Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex);
7 }
8 }

Ahora crearemos otro método, esta vez para crear una base de datos. Lo
llamaremos createDB(). El código es el siguiente:

1 public void createDB(String name) {

2 try {
3 String Query = "CREATE DATABASE " + name;
4 Statement st = Conexion.createStatement();
5 st.executeUpdate(Query);
6 closeConnection();
7 MySQLConnection("root", "", name);
8 JOptionPane.showMessageDialog(null, "Se ha creado la base de datos " + name + " de forma exitosa");
9 } catch (SQLException ex) {
10 Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex);
11 }
12 }

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 public void createTable(String name) {

2 try {
3 String Query = "CREATE TABLE " + name + ""
4 + "(ID VARCHAR(25),Nombre VARCHAR(50), Apellido VARCHAR(50),"
5 + " Edad VARCHAR(3), Sexo VARCHAR(1))";
6
7 Statement st = Conexion.createStatement();
8 st.executeUpdate(Query);
9 JOptionPane.showMessageDialog(null, "Se ha creado la tabla " + name + " de forma exitosa");
10 } catch (SQLException ex) {
11 Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex);
12 }
13 }

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 public void insertData(String table_name, String ID, String name, String lastname, String age, String gender) {
2 try {
3 String Query = "INSERT INTO " + table_name + " VALUES("
4 + "\"" + ID + "\", "
5 + "\"" + name + "\", "
6 + "\"" + lastname + "\", "
7 + "\"" + age + "\", "
8 + "\"" + gender + "\")";
9 Statement st = Conexion.createStatement();
10 st.executeUpdate(Query);
11 JOptionPane.showMessageDialog(null, "Datos almacenados de forma exitosa");
12 } catch (SQLException ex) {
13 JOptionPane.showMessageDialog(null, "Error en el almacenamiento de datos");
14 }
15 }

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 public void getValues(String table_name) {

2 try {
3 String Query = "SELECT * FROM " + table_name;
4 Statement st = Conexion.createStatement();
5 java.sql.ResultSet resultSet;
6 resultSet = st.executeQuery(Query);
7
8 while (resultSet.next()) {
9 System.out.println("ID: " + resultSet.getString("ID") + " "
10 + "Nombre: " + resultSet.getString("Nombre") + " " + resultSet.getString("Apellido") + " "
11 + "Edad: " + resultSet.getString("Edad") + " "
12 + "Sexo: " + resultSet.getString("Sexo"));
13 }
14
15 } catch (SQLException ex) {
16 JOptionPane.showMessageDialog(null, "Error en la adquisición de datos");
17 }
18 }

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.

report this ad
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 public void deleteRecord(String table_name, String ID) {

2 try {
3 String Query = "DELETE FROM " + table_name + " WHERE ID = \"" + ID + "\"";
4 Statement st = Conexion.createStatement();
5 st.executeUpdate(Query);
6
7 } catch (SQLException ex) {
8 System.out.println(ex.getMessage());
9 JOptionPane.showMessageDialog(null, "Error borrando el registro especificado");
10 }
11 }

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 package mysql_test;
2
3 import java.sql.Connection;
4 import java.sql.DriverManager;
5 import java.sql.SQLException;
6 import java.sql.Statement;
7 import java.util.logging.Level;
8 import java.util.logging.Logger;
9 import javax.swing.JOptionPane;
10
11 public class MySQL {
12
13 private static Connection Conexion;
14
15 public void MySQLConnection(String user, String pass, String db_name) {
16 try {
17 Class.forName("com.mysql.jdbc.Driver");
18 Conexion = DriverManager.getConnection("jdbc:mysql://localhost:3306/" + db_name, user, pass);
19 System.out.println("Se ha iniciado la conexión con el servidor de forma exitosa");
20 } catch (ClassNotFoundException ex) {
21 Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex);
22 } catch (SQLException ex) {
23 Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex);
24 }
25 }
26
27 public void closeConnection() {
28 try {
29 Conexion.close();
30 System.out.println("Se ha finalizado la conexión con el servidor");
31 } catch (SQLException ex) {
32 Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex);
33 }
34 }
35
36 public void createDB(String name) {
37 try {
38 String Query = "CREATE DATABASE " + name;
39 Statement st = Conexion.createStatement();
40 st.executeUpdate(Query);
41 MySQLConnection("root", "", name);
42 JOptionPane.showMessageDialog(null, "Se ha creado la base de datos " + name + " de forma exitosa");
43 } catch (SQLException ex) {
44 Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex);
45 }
46 }
47
48 public void createTable(String name) {
49 try {
50 String Query = "CREATE TABLE " + name + ""
51 + "(ID VARCHAR(25),Nombre VARCHAR(50), Apellido VARCHAR(50),"
52 + " Edad VARCHAR(3), Sexo VARCHAR(1))";
53 JOptionPane.showMessageDialog(null, "Se ha creado la base de tabla " + name + " de forma exitosa");
54 Statement st = Conexion.createStatement();
55 st.executeUpdate(Query);
56 } catch (SQLException ex) {
57 Logger.getLogger(MySQL.class.getName()).log(Level.SEVERE, null, ex);
58 }
59 }
60
61 public void insertData(String table_name, String ID, String name, String lastname, String age, String gender)
62 {
63 try {
64 String Query = "INSERT INTO " + table_name + " VALUES("
65 + "\"" + ID + "\", "
66 + "\"" + name + "\", "
67 + "\"" + lastname + "\", "
68 + "\"" + age + "\", "
69 + "\"" + gender + "\")";
70 Statement st = Conexion.createStatement();
71 st.executeUpdate(Query);
72 JOptionPane.showMessageDialog(null, "Datos almacenados de forma exitosa");
73 } catch (SQLException ex) {
74 JOptionPane.showMessageDialog(null, "Error en el almacenamiento de datos");
75 }
76 }
77
78 public void getValues(String table_name) {
79 try {
80 String Query = "SELECT * FROM " + table_name;
81 Statement st = Conexion.createStatement();
82 java.sql.ResultSet resultSet;
83 resultSet = st.executeQuery(Query);
84
85 while (resultSet.next()) {
86 System.out.println("ID: " + resultSet.getString("ID") + " "
87 + "Nombre: " + resultSet.getString("Nombre") + " " + resultSet.getString("Apellido") + " "
88 + "Edad: " + resultSet.getString("Edad") + " "
89 + "Sexo: " + resultSet.getString("Sexo"));
90 }
91
92 } catch (SQLException ex) {
93 JOptionPane.showMessageDialog(null, "Error en la adquisición de datos");
94 }
95 }
96
97 public void deleteRecord(String table_name, String ID) {
98 try {
99 String Query = "DELETE FROM " + table_name + " WHERE ID = \"" + ID + "\"";
100 Statement st = Conexion.createStatement();
101 st.executeUpdate(Query);
102
103 } catch (SQLException ex) {
104 System.out.println(ex.getMessage());
105 JOptionPane.showMessageDialog(null, "Error borrando el registro especificado");
106 }
107 }
108
}

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 public static void main(String[] args) {
2 Window w = new Window();
3 w.setVisible(true);
4 }

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 db.MySQLConnection("root", "", "");

2 db.createDB("MySQL_Test");
3 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 db.MySQLConnection("root", "", "MySQL_Test");

2 jButtonConnect.setEnabled(false);
3 jButtonDelete.setEnabled(true);
4 jButtonGet.setEnabled(true);
5 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 MySQL db = new MySQL();

2 db.MySQLConnection("root", "", "MySQL_Test");
3 db.deleteRecord("Registros", jTextFieldID.getText());
4 db.closeConnection();
5 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 MySQL db = new MySQL();

2 db.MySQLConnection("root", "", "MySQL_Test");
3 db.insertData("Registros", jTextFieldID.getText(),
4 jTextFieldNombre.getText(),
5 jTextFieldApellido.getText(),
6 jTextFieldEdad.getText(),
7 jComboBoxSexo.getSelectedItem().toString());
8 db.closeConnection();
9 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:

MySQL_Test

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í.