La creacin y gestin de bases de datos MySQL con Java es uno de los

conocimientos esenciales que todo Java Programmer debe poseer. Esta gua ha
sido diseada por un principiante, para principiantes, exponiendo los
conocimientos bsicos que se necesitan para entrar en el mundo del MySQL en
Java

A continuacin voy a describir paso a paso lo que se necesita para crear una base de
datos y utilizar MySQL con Java. Esta gua ha sido diseada para aquellos usuarios
que sean principiantes en el manejo de bases de datos MySQL con Java. Yo alguna
vez estuve en dicha posicin y cmo me hubiese encantado que alguien me explicara
lo que deba 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 comunicacin de
la aplicacin Java con la base de datos. Antes ya he escrito en este blog
sobre XAMPP y he mostrado cmo crear bases de datos desde PHPmyAdmin. En este
tutorial no crearemos las bases de datos con este mtodo sino que a travs de
programacin 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 aplicacin y nos aparece la siguiente

ventana:
Slo 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 librera que hace posible el uso de MySQL con Java. Posee los mtodos
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 librera que descargamos en el paso anterior.
4- Programamos la clase MySQL
Dentro de la clase MySQL vamos a colocar todos los mtodos relacionados al manejo
de la base de datos y la conexin con el servidor. Lo primero que haremos ser
crear una variable global. Estas es:

1 private static Connection Conexion;

Ahora creamos un mtodo tipo void llamado MySQLConnection(). Aqu vamos a

iniciar una conexin con el servidor MySQL. El cdigo 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 conexin 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 parmetros el nombre de usuario, la

contrasea 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
mtodo de la clase principal (MySQL_Test) y ejecutamos el mtodo
MySQLConnection(). Aqu est el cdigo 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 contrasea 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 mtodo para finalizar la conexin con el servidor.

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

Ahora crearemos otro mtodo, esta vez para crear una base de datos. Lo
llamaremos createDB(). El cdigo 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 gustara resaltar es la variable que he llamado Query. Esta variable
contiene una instruccin 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. Ntese que para que este mtodo se pueda utilizar es necesario primero
ejecutar MySQLConnection(). Una vez que se ha creado la Base de Datos, se cierra
la conexin y se reinicia, ahora introduciendo como parmetro la base de datos que
hemos creado.

Vamos a crear un mtodo 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 parntesis 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 parntesis se coloca la cantidad mxima 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 mtodo para introducir los registros a la tabla. Crearemos el
mtodo insertData(). El cdigo 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 instruccin INSERT INTO, seguido del nombre de la tabla
en la que se quiere insertar la informacin. Luego se agrega la palabra VALUES y
entre parntesis los valores que se desean insertar, entre comillas. Digamos que
queremos introducir la informacin de Juan Rodrguez, hombre con 19 aos de edad.
Su ID es 8-835-532. El nombre de la tabla es Registros. El Query quedara de la
siguiente forma:

INSERT INTO Registros VALUES (8-835-532, Juan, Rodrguez, 19,

M);

Ahora vamos a crear un mtodo 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 adquisicin de datos");
17 }
18 }

Ahora el Query est formado por las palabrasSELECT * 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
mtodo getString() leemos las columnas que deseamos.
Ahora le vamos a agregar un mtodo para borrar registros. Lo
llamaremos deleteRecord() y le introduciremos como parmetro 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 }

Quizs podramos agregar mtodos 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 conexin 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 conexin 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 try {
63 String Query = "INSERT INTO " + table_name + " VALUES("
64 + "\"" + ID + "\", "
65 + "\"" + name + "\", "
66 + "\"" + lastname + "\", "
67 + "\"" + age + "\", "
68 + "\"" + gender + "\")";
69 Statement st = Conexion.createStatement();
70 st.executeUpdate(Query);
71 JOptionPane.showMessageDialog(null, "Datos almacenados de forma exitosa");
72 } catch (SQLException ex) {
73 JOptionPane.showMessageDialog(null, "Error en el almacenamiento de datos");
74 }
75 }
76
77 public void getValues(String table_name) {
78 try {
79 String Query = "SELECT * FROM " + table_name;
80 Statement st = Conexion.createStatement();
81 java.sql.ResultSet resultSet;
82 resultSet = st.executeQuery(Query);
83
84 while (resultSet.next()) {
85 System.out.println("ID: " + resultSet.getString("ID") + " "
86 + "Nombre: " + resultSet.getString("Nombre") + " " + resultSet.getString("Apellido") + " "
87 + "Edad: " + resultSet.getString("Edad") + " "
88 + "Sexo: " + resultSet.getString("Sexo"));
89 }
90
91 } catch (SQLException ex) {
92 JOptionPane.showMessageDialog(null, "Error en la adquisicin de datos");
93 }
94 }
95
96 public void deleteRecord(String table_name, String ID) {
97 try {
98 String Query = "DELETE FROM " + table_name + " WHERE ID = \"" + ID + "\"";
99 Statement st = Conexion.createStatement();
100 st.executeUpdate(Query);
101
102 } catch (SQLException ex) {
103 System.out.println(ex.getMessage());
104 JOptionPane.showMessageDialog(null, "Error borrando el registro especificado");
105 }
106 }
107
108 }

Vamos al siguiente paso.

5- Creamos una interfaz grfica

Vamos a la clase Window.java y diseamos una sencilla interfaz de usuario.
Colocamos los 4 botones con las opciones que deseamos que posea nuestra aplicacin.
Las opciones Registrar Usuario, Obtener Registros y Borrar Registro se
encuentran inactivas ya que no pueden ser ejecutadas si no se inicia la conexin con
el servidor MySQL.

Vamos a crear una clase con un formulario de registro y una con la opcin de borrar
un registro. He agregado las clases Window_Register y Window_Delete con las
siguientes interfaces grficas.
Podemos pasar al siguiente paso.

6- Programamos la interfaz grfica

La prioridad de toda aplicacin Java es ejecutar el mtodo main de la clase principal.
Vamos a crear una instancia para que lo primero que haga nuestro programa sea
mostrarnos la ventana principal.
Nuestro mtodo main de la clase MySQL_Test quedara 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

botn Conectar a base de Datos debemos colocar el siguiente cdigo:
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 botn Admin al lado de

MySQL) nos debe aparecer una nueva base de datos con la tabla registros en su
interior.
Ahora el cdigo que colocamos en el botn 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 programacin.

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 conexin se des habilita el botn de conectar y se habilitan los
dems botones. A continuacin el cdigo para cada botn:
Ahora vamos a cada ventana que hemos agregado y programamos los botones.
Primero la ventana de borrar registros.

En el botn 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 conexin, borramos el registro con
el ID que se haya introducido en el TextField y cerramos la conexin. Por ltimo
cerramos la ventana.

Ahora vamos a la ventana de registro de datos. La programacin del botn 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 cdigo nos queda as:

Con esto hemos terminado nuestra programacin. Tenemos una pequea aplicacin
que nos permite registrar informacin en una base de datos, imprimirla y borrar ciertos
registros.

7- Probamos nuestra aplicacin

Ya que tenemos nuestro cdigo terminado podemos proceder a probar lo que hemos
hecho. El proyecto completo puede ser descargado desde Github, en el siguiente
enlace:

MySQL_Test

A continuacin un video donde se muestra el funcionamiento de esta aplicacin.

El proyecto est tal como lo he desarrollado para este tutorial. Debemos recordar
que esto no es una aplicacin, sino una demostracin. Los mtodos 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.