Download Instructivo de instalación de manejador de base de datos

Instructivo de instalación de manejador de base de datos “MySQL” en Windows y pruebas con NetBeans.
MySQL es el manejador de bases de datos de código abierto más popular del mundo. Con su velocidad superior y fácil uso, MySQL
se ha convertido en la opción preferida por los desarrolladores de software debido a que elimina una gran cantidad de problemas
relacionados con el tiempo de respuesta, mantenimiento y administración de aplicaciones web, entre muchas otras cosas.
Debido a esto es el software que se utilizará en la clase para aprender y comprender la forma en cómo se trabaja con bases de datos
desde aplicaciones Java. Cabe destacar que existen varias maneras de operar bases de datos desde aplicaciones Java, pero son formas
más avanzadas. Para comenzar a familiarizarse con este tipo de manejadores MySQL es la mejor opción.
A continuación se ejemplificará el procedimiento a seguir para instalar esta herramienta en un sistema operativo Windows.
1.
Descarga
a. Ingresar a la URL http://dev.mysql.com/downloads/windows/installer/.
b.
Ya en la página, deslizar el scroll hacia abajo hasta la parte donde se debe seleccionar el sistema operativo y el
instalador a descargar.
Verificar que la plataforma sea “Microsoft Windows” y seleccionar la opción de descarga de mayor peso (248.2 M).
Esta acción redirecciona hacia otra página. En la parte inferior de dicha página, se encuentra un vínculo que dice
“No thanks, just start my download”. Dar clic en este vínculo para comenzar con la descarga.
c.
2.
Seleccionar
“Guardar”
y
esperar
a
que
se
complete
la
descarga.
NOTA: normalmente los archivos descargados se almacenan en el directorio “Descargas”, a menos que se
modifique esta configuración.
Instalación
a. Ir al directorio en el cual se almacenó el archivo de instalación “mysql-installer-community-5.6.20.0.msi” y dar
doble clic sobre él.
NOTA: Si aparecen las solicitudes de autorización para iniciar la instalación, seleccionar “Si” o “Continuar”.
b.
Al iniciarse el instalador, aparecerá la siguiente ventana:
Seleccionar “Install MySQL Products”.
c.
En la siguiente pantalla, seleccionar la casilla “I accept the licence terms” y dar clic en “next”.
Aparecerá un mensaje diciendo que el instalador buscará los productos más nuevos de MySQL (en caso que los
haya). Simplemente hay que dar clic en “Execute”.
El instalador realizará sus operaciones y al terminar mostrará el botón “Next”. Dar clic en este botón.
d.
En la siguiente ventana se pueden seleccionar diversos productos que ofrece el instalador. Como no vamos a utilizar
todas las herramientas disponibles, seleccionamos la opción “Custom” y damos clic en el botón “Next” (dejamos los
directorios de instalación por defecto).
e.
Después damos clic en “MySQL Server 5.6.20” y seleccionamos todas las opciones del menú de la derecha.
f.
Si se encuentra activa la casilla de aplicaciones, la deseleccionamos. Esto es para ahorrar espacio en disco. Si
alguien desea instalar estas aplicaciones, lo puede hacer.
En la parte de “MySQL Connectors” seleccionamos solamente la opción “Connector/J 5.1.31”.
g.
Finalmente seleccionamos “Documentation”, verificamos que ambas selecciones del menú derecho estén activadas y
damos clic en “Next”.
h.
Después se comprobarán requerimientos adicionales. Damos clic en “Next”.
i.
En la siguiente pantalla se mostrarán los productos a instalar. Verificamos que estén correctos y damos clic en
“Execute”.
j.
Cuando los productos se terminen de instalar, su “status” aparecerá como “Install success”. Damos clic en “Next”.
k.
Posteriormente se iniciará la configuración del servidor MySQL recién instalado. Damos clic en “Next”.
l.
En la parte “Config Type” seleccionamos “Development Machine”. Habilitamos las casillas “Enable TCP/IP
Networking” y “Open Firewall port for network access”; el número de puerto lo dejamos por default y
deshabilitamos la casilla “Show Advanced Options”. Clic en “Next”.
m. Escogemos un password para nuestro usuario root (administrador) y lo escribimos en los campos de texto “MySQL
Root Password” y “Repeat Password”. En este momento no agregaremos más usuarios, así que simplemente damos
clic en “Next”.
n.
En “Windows Service Name” dejamos el valor por defecto. Deshabilitamos la casilla “Start the MySQL Server at
System Startup” y seleccionamos “Standard System Account”. Clic en “Next”.
o.
Al configurarse correctamente el servidor, se mostrará una “paloma”. Ahora sigue instalar lo demás. Damos clic en
“Next”.
Al terminarse la instalación de todos los productos se mostrarán “palomas” en ellos. Clic en “Next”.
p.
3.
Ya tenemos instalado nuestro servidor MySQL en el sistema operativo. Damos clic en “Finish” para cerrar el
instalador.
Uso de MySQL
Lo primero que debemos saber es que como no instalamos un software gráfico para el manejo del servidor MySQL, solo lo
tendremos dos opciones para operarlo:
I.
Desde una consola
II.
Desde NetBeans IDE
Si alguien instaló las herramientas adicionales tendrá más opciones de visualizar las bases de datos que residan en nuestro
servidor. Además, existen muchas más herramientas para poder operar con MySQL, pero ejemplificar más de estas
herramientas no es el objetivo de este instructivo.
Pasando a los ejemplos de manejo de MySQL, al terminar la instalación se crean accesos directos a una aplicación llamada
“mysql.exe” ubicada en el directorio “C:\Program Files\MySQL\MySQL Server 5.6\bin”. Estos accesos directos nos sirven si
queremos operar MySQL desde consola. Podemos dar doble clic sobre uno de estos accesos para comenzar a utilizar MySQL
o, podemos abrir una consola y ejecutar el programa “mysql.exe” directamente.
A continuación mostraré la forma de entrar al servidor MySQL desde una consola:
a. Oprimir la tecla “Windows” (normalmente ubicada al lado derecho de la tecla ctrl izquierdo) más la tecla “R”. Esto
desplegará en pantalla la ventana de “Ejecutar”. Escribimos “cmd” y damos clic en “Aceptar”.
Esto nos abrirá una consola. Escribimos lo siguiente para cambiarnos al directorio que contiene el programa
“mysql.exe”: “cd ../../Program Files/MySQL/MySQL Server 5.6/bin” (sin las comillas).
b.
Después escribimos el comando que nos permitirá identificarnos con el servidor MySQL: “mysql –u root -p” (sin las
comillas). Damos “enter” y se nos solicitará el password que definimos en la configuración del servidor. Lo
escribimos y damos nuevamente “enter” para poder identificarnos.
c.
Ya identificados, podremos escribir sentencias SQL para operar nuestras bases de datos. Las sentencias SQL más
básicas que estaremos utilizando son:
 CREATE DATABASE nombre_bd;  para crear una nueva base de datos llamada “nombre_bd”.
 SHOW DATABASES;  para mostrar las bases de datos almacenadas.
 DROP DATABASE nombre_bd;  elimina la base de datos llamada “nombre_bd”.
 USE nombre_bd;  para trabajar con la base de datos llamada “nombre_bd”.
 CREATE TABLE nombre_tabla (atributos…);  para crear una nueva tabla de una base de datos con sus
atributos llamada “nombre_tabla”.
 SHOW TABLES;  para mostrar las tablas de una base de datos.
 DROP TABLE nombre_tabla;  elimina la tabla llamada “nombre_tabla”.
 INSERT INTO nombre_tabla VALUES (valores…);  para agregar datos a la tabla “nombre_tabla”.
 SELECT [atributos…] FROM nombre_tabla;  para consultar la información de la tabla llamada
“nombre_tabla”.
 DELETE FROM nombre_tabla;  para eliminar información de la tabla llamada “nombre_tabla”.
 UPDATE nombre_tabla SET atributos…;
Las sentencias “SELECT”, “DELETE” y “UPDATE” pueden ser condicionadas con la palabra “WHERE”. A
continuación muestro un ejemplo de ello:
 SELECT * FROM usuarios WHERE id=1;  selecciona todos los atributos de la tabla “usuarios” donde el
atributo “id” es igual a 1.
 DELETE FROM usuarios WHERE id=1;  elimina la información de la tabla “usuarios” donde el atributo
“id” es igual a 1.
 UPDATE usuarios SET nombre=’daniel’, edad=28 WHERE id=1;  actualiza los atributos “nombre” y
“edad” de la tabla “usuarios” donde el atributo “id” es igual a 1.
Ya que terminemos de trabajar con MySQL desde la consola, para salir escribimos “exit”.
d.
Ahora que ya sabemos cómo acceder al servidor MySQL desde una consola, voy a mostrar cómo trabajar con él desde
NetBeans IDE:
a. Lo primero es ejecutar NetBeans.
b.
En el menú del lado izquierdo, seleccionamos la pestaña “Services” para poder ver las bases de datos con las que
contamos.
En caso de que no se muestre dicha pestaña, damos clic en el menú “Window” y seleccionamos “Services”. De esta
forma ya nos aparecerá.
c.
Ya en la pestaña “Services” podremos ver los servidores de bases de datos que tenemos instalados. En nuestro caso,
nos interesa “MySQL Server”. Nos aparecerá el “localhost:3306 [root] (disconnected)”.
Damos clic derecho en el servidor MySQL y seleccionamos “Properties…”.
d.
En la ventana de propiedades, escribimos el password que especificamos al configurar nuestro servidor MySQL y
activamos la casilla “Remember Password”. Clic en “OK”.
e.
Después nuevamente damos clic derecho en el servidor MySQL y seleccionamos “Connect”.
Al establecerse la conexión con MySQL se mostrarán las bases de datos almacenadas.
f.
Ahora vamos a crear una base de datos para realizar pruebas. Damos clic derecho en el servidor MySQL y
seleccionamos “Create Database…”.
Nombramos la base de datos como “biblioteca” y damos clic en “OK”.
La nueva base de datos se mostrará debajo del servidor MySQL. Damos clic derecho sobre “biblioteca” y
seleccionamos “Connect…”.
Esperamos a que se establezca la conexión y al terminar, debajo de “Drivers”, se visualizará
“jdbc:mysql://localhost:3306/biblioteca…”. Desplegamos el árbol para ver el contenido.
g.
Como la base de datos es nueva, no contiene información. Vamos a crear una tabla para ingresar datos. Damos clic
derecho en “Tables” y seleccionamos “Create Table…”.
h.
Nombramos la tabla como “Libros”. Nótese que el botón “OK” no está activo. Éste se activará después de que
agreguemos columnas a nuestra tabla. Para ello, damos clic en el botón “Add column” que se encuentra del lado
derecho.
i.
j.
k.
Nombramos la columna como “autor” de tipo “VARCHAR” y tamaño 50. Desactivamos la casilla “Null” (debido a
que esta información nunca puede faltar) y damos clic en “OK”.
De esta misma forma creamos otras cuatro columnas no nulas:
 “titulo” de tipo “VARCHAR” y tamaño 50
 ”editorial” de tipo “VARCHAR” y tamaño 50
 ”anio” de tipo “INT”
 ”edicion” de tipo “INT”
Finalmente creamos una última columna llamada “isbn” de tipo “VARCHAR” y tamaño 20. A diferencia de las
demás columnas, ésta será la llave primaria. Activamos la casilla “Primary key”, dejamos los valores por defecto y
damos clic en “OK”.
Ya que hayamos terminado de agregar nuestras columnas (atributos de la tabla o campos) damos clic en el botón
“OK” que ya estará activo.
Podremos observar en nuestra base de datos que se ha creado la nueva tabla con sus respectivos campos.
4.
Pruebas del servidor MySQL con clases Java
Ahora vamos a realizar nuestras pruebas con MySQL insertando, consultando, eliminando y actualizando datos en la tabla
“libros” perteneciente a la base de datos “biblioteca” que creamos anteriormente.
a. Primero creamos un nuevo proyecto de NetBeans tipo “Java Application” llamado “Biblioteca” sin crear la clase
principal.
b.
Creamos 2 nuevos paquetes:
 uam.azc.mx.modelo
 uam.azc.mx.vista
En el paquete “modelo”, agregamos una nueva clase Java llamada “Libro” y en el paquete “vista” agregamos un
nuevo “JFrame Form” llamado “GUI”.
c.
d.
e.
Abrimos la clase “Libro”, agregamos seis datos miembro de la siguiente forma:
private String autor;
private String titulo;
private String editorial;
private String ISBN;
private int anio;
private int edicion;
Agregamos un constructor:
public Libro(String autor,String titulo,String editorial,String ISBN,int anio,int edicion){
this.autor=autor;
this.titulo=titulo;
this.editorial=editorial;
this.ISBN=ISBN;
this.anio=anio;
this.edicion=edicion;
}
Después agregamos los métodos “get” de nuestros datos miembro:
public String getAutor(){
return(this.autor);
}
public String getTitulo(){
return(this.titulo);
}
public String getEditorial(){
return(this.editorial);
}
public String getISBN(){
return(this.ISBN);
}
public int getAnio(){
return(this.anio);
}
public int getEdicion(){
return(this.edicion);
}
f.
g.
h.
Sobrescribimos el método “toString”:
@Override
public String toString(){
return("Autor:\t\t" + this.autor + "\nTitulo:\t\t" + this.titulo +
"\nEditorial:\t" + this.editorial + "\nISBN:\t\t" + this.ISBN +
"\nAnio:\t\t" + this.anio + "\nEdicion:\t" + this.edicion +
"\n----------------------------------------------------------");
}
Ya que tenemos nuestra clase “Libro” terminada creamos una clase “Test” en el paquete “default” para corroborar
que esté correcta. A esta nueva clase le agregamos el siguiente código dentro del método principal:
Libro [] libros=new Libro[5];
libros[0]=new Libro("Thomas H. Cormen","Introduction to Algorithms","McGrow-Hill","107013151",2001,2);
System.out.println(libros[0].toString());
libros[1]=new Libro("Cay Horstmann","BIG JAVA","Wilew","326902040",2008,3);
System.out.println(libros[1].toString());
libros[2]=new Libro("Deitel & Deitel","Como Programar en Java","Pearson","970260548",2003,5);
System.out.println(libros[2].toString());
libros[3]=new
Libro("Stuart
J.
Russell","Inteligencia
Artificial:
Un
Enfoque
Moderno","Pearson","842054003",2004,2);
System.out.println(libros[3].toString());
libros[4]=new
Libro("Barry
B.
Brey","The
Intel
Microprocessors","Prentice-Hall
International","113802745",1997,4);
System.out.println(libros[4].toString());
Para ejecutar nuestra clase “Test” presionamos “Shift” + “F6”. La salida que se debe mostrar es la siguiente:
run:
Autor:
Thomas H. Cormen
Titulo:
Introduction to Algorithms
Editorial:
McGrow-Hill
ISBN:
107013151
Anio:
2001
Edicion:2
---------------------------------------------------------Autor:
Cay Horstmann
Titulo:
BIG JAVA
Editorial:
Wilew
ISBN:
326902040
Anio:
2008
Edicion:3
---------------------------------------------------------Autor:
Deitel & Deitel
Titulo:
Como Programar en Java
Editorial:
Pearson
ISBN:
970260548
Anio:
2003
Edicion:5
---------------------------------------------------------Autor:
Stuart J. Russell
Titulo:
Inteligencia Artificial: Un Enfoque Moderno
Editorial:
Pearson
ISBN:
842054003
Anio:
2004
Edicion:2
---------------------------------------------------------Autor:
Barry B. Brey
i.
j.
k.
Titulo:
The Intel Microprocessors
Editorial:
Prentice-Hall International
ISBN:
113802745
Anio:
1997
Edicion:4
---------------------------------------------------------BUILD SUCCESSFUL (total time: 0 seconds)
Si no se mostró lo anterior, hay que consultar los pasos anteriores para determinar a qué se debe. Además, no hay
que olvidar agregar la documentación necesaria para nuestro constructor y los métodos utilizados.
Ahora vamos a ingresar esta información (los cinco libros) en nuestra base de datos “biblioteca”. Para ello, creamos
un nuevo paquete llamado “uam.azc.mx.control” y agregamos una clase Java llamada “SQL”. Esta nueva clase nos
servirá para establecer una conexión entre el servidor MySQL y nuestra aplicación Java, para así poder manipular la
información contenida en la base de datos “biblioteca”, que por el momento solo contendrá información de libros.
Abrimos la clase SQL y añadimos las siguientes importaciones:
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import uam.azc.mx.modelo.Libro;
Agregamos un dato miembro privado de tipo “Connection” llamado “conn” y el constructor de la clase:
private Connection conn;
public SQL(){
this.conn=null;
}
Creamos un nuevo método público tipo “boolean” llamado “conectar”, que reciba cuatro objetos de la clase
“String”, con los cuales sabremos el host al que nos conectaremos, el nombre de la base de datos, el usuario y el
password necesarios para poder establecer la conexión:
public boolean conectar(String server,String bd,String user,String pass){
try{
Class.forName("com.mysql.jdbc.Driver");
}
catch(ClassNotFoundException e){
System.err.println("Error: " + e.getMessage());
return(false);
}
try{
this.conn=DriverManager.getConnection("jdbc:mysql://" + server + "/" + bd,user,pass);
}
catch(SQLException e){
System.err.println("Error: " + e.getMessage());
return(false);
}
return(true);
}
Éste método creará una conexión con el servidor MySQL y regresará verdadero (true) si se tiene éxito. Si se produce
un error al intentar conectarse regresará falso (false).
l.
Ahora creamos el método que cerrará la conexión con MySQL:
public void desconectar(){
try{
this.conn.close();
}
catch(SQLException e){
System.err.println("Error: " + e.getMessage());
}
}
No olvidemos que cada que creamos una nueva conexión con una fuente externa a nuestra aplicación (MySQL,
archivos, servidores web, etc.) debemos siempre cerrar el canal de comunicación que se crea.
m. Ya que tengamos nuestra conexión establecida, debemos ingresar la información de nuestros libros en la base de
datos. Para ello, creamos el método público de tipo “boolean” llamado “agregaLibro”, que recibirá como argumento
un objeto de tipo “Libro” para después acceder a sus atributos e ingresarlos a la base de datos. Lo hacemos de la
siguiente manera:
public boolean agregaLibro(Libro libro){
String query="INSERT INTO libros(autor,titulo,editorial,anio,edicion,isbn) VALUES('" +
libro.getAutor() + "','" + libro.getTitulo() + "','" + libro.getEditorial() +
"'," + libro.getAnio() + "," + libro.getEdicion() + ",'" + libro.getISBN() + "')";
try{
PreparedStatement ps=this.conn.prepareStatement(query);
ps.execute();
}
catch(SQLException e){
System.err.println("Error: " + e.getMessage());
return(false);
}
return(true);
}
Si el libro se ingresa correctamente, el método regresará verdadero (true), si no, será falso (false).
n. También podemos llegar a prescindir de cierta información. Es por eso que necesitaremos un método que elimine
libros de nuestra base de datos. Para identificar qué libro vamos a eliminar, pasaremos como argumento el “isbn” del
libro. El método será público de tipo “boolean” y se llamará “eliminaLibro”:
public boolean eliminaLibro(String isbn){
String query="DELETE FROM libros WHERE isbn='" + isbn + "'";
try{
PreparedStatement ps=this.conn.prepareStatement(query);
ps.execute();
}
catch(SQLException e){
System.err.println("Error: " + e.getMessage());
return(false);
}
return(true);
}
Si el libro se elimina correctamente, el método regresará verdadero (true), si no, será falso (false)
o. Para poder consultar la información que tenemos en nuestra base de datos “biblioteca”, en particular en la tabla
“libros”, requeriremos de un método público tipo “void” llamado “verLibros”:
public void verLibros(){
String query="SELECT * FROM libros";
try{
PreparedStatement ps=this.conn.prepareStatement(query);
ResultSet libros=ps.executeQuery();
while(libros.next()){
Libro libro=new Libro(libros.getString("autor"),
libros.getString("titulo"),
libros.getString("editorial"),
libros.getString("isbn"),
Integer.parseInt(libros.getString("anio")),
Integer.parseInt(libros.getString("edicion")));
System.out.println(libro.toString());
}
}
catch(SQLException e){
System.err.println("Error: " + e.getMessage());
}
p.
}
Cuando se creen nuevas tablas en la base de datos se deberán hacer sus propios métodos para realizar una consulta.
Obviamente serán muy parecidos a este método.
Finalmente, crearemos métodos para actualizar los campos de nuestra tabla “libros”. Debido a que tenemos seis
campos en la tabla, escribiremos seis métodos, uno para actualizar cada campo. Todos los métodos serán públicos de
tipo “boolean” y la actualización se realizará al libro identificado por su ISBN. A continuación muestro los seis
métodos:
public boolean actualizaAutor(String isbn,String autor){
String query="UPDATE libros SET autor='" + autor + "' WHERE isbn='" + isbn + "'";
try{
PreparedStatement ps=this.conn.prepareStatement(query);
ps.execute();
}
catch(SQLException e){
System.err.println("Error: " + e.getMessage());
return(false);
}
return(true);
}
public boolean actualizaTitulo(String isbn,String titulo){
String query="UPDATE libros SET titulo='" + titulo + "' WHERE isbn='" + isbn + "'";
try{
PreparedStatement ps=this.conn.prepareStatement(query);
ps.execute();
}
catch(SQLException e){
System.err.println("Error: " + e.getMessage());
return(false);
}
return(true);
}
public boolean actualizaEditorial(String isbn,String editorial){
String query="UPDATE libros SET editorial='" + editorial + "' WHERE isbn='" + isbn + "'";
try{
PreparedStatement ps=this.conn.prepareStatement(query);
ps.execute();
}
catch(SQLException e){
System.err.println("Error: " + e.getMessage());
return(false);
}
return(true);
q.
r.
s.
}
public boolean actualizaISBN(String isbn,String nuevo){
String query="UPDATE libros SET isbn=’" + nuevo + "’ WHERE isbn='" + isbn + "'";
try{
PreparedStatement ps=this.conn.prepareStatement(query);
ps.execute();
}
catch(SQLException e){
System.err.println("Error: " + e.getMessage());
return(false);
}
return(true);
}
public boolean actualizaAnio(String isbn,int anio){
String query="UPDATE libros SET anio=" + anio + " WHERE isbn='" + isbn + "'";
try{
PreparedStatement ps=this.conn.prepareStatement(query);
ps.execute();
}
catch(SQLException e){
System.err.println("Error: " + e.getMessage());
return(false);
}
return(true);
}
public boolean actualizaEdicion(String isbn,int edicion){
String query="UPDATE libros SET edicion=" + edicion + " WHERE isbn='" + isbn + "'";
try{
PreparedStatement ps=this.conn.prepareStatement(query);
ps.execute();
}
catch(SQLException e){
System.err.println("Error: " + e.getMessage());
return(false);
}
return(true);
}
Nótese que en estos métodos se repite el código que ejecuta el query en MySQL. Esto se puede reducir. Además, no
hay que olvidarse de documentar todos los métodos de la clase “SQL”.
Ya que tenemos terminada la clase “SQL”, modificamos la clase “Test” para realizar pruebas. Primero, importamos
lo siguiente:
import uam.azc.mx.control.SQL;
Después eliminamos los “System.out.println” que escribimos anteriormente., quedando el código anterior como:
Libro [] libros=new Libro[5];
libros[0]=new Libro("Thomas H. Cormen","Introduction to Algorithms","McGrow-Hill","107013151",2001,2);
libros[1]=new Libro("Cay Horstmann","BIG JAVA","Wilew","326902040",2008,3);
libros[2]=new Libro("Deitel & Deitel","Como Programar en Java","Pearson","970260548",2003,5);
libros[3]=new
Libro("Stuart
J.
Russell","Inteligencia
Artificial:
Un
Enfoque
Moderno","Pearson","842054003",2004,2);
libros[4]=new
Libro("Barry
B.
Brey","The
Intel
Microprocessors","Prentice-Hall
International","113802745",1997,4);
De esta forma, solo creamos el arreglo de libros y no lo imprimimos en pantalla.
Ahora creamos un objeto de tipo “SQL” llamado “conexion”:
SQL conexion=new SQL();
t.
Nos conectamos con el servidor MySQL:
conexion.conectar("localhost","biblioteca","root","123456");
System.out.println("Conexión establecida");
Imprimimos en pantalla mensajes de control.
u. Ingresamos los libros que tenemos en el arreglo a la base de datos con ayuda de un ciclo “for each”:
for(Libro l : libros){
conexion.agregaLibro(l);
System.out.println("Libro agregado");
}
v. Desplegamos en pantalla los libros recién agregados:
conexion.verLibros();
w. A continuación probamos los demás métodos programados agregando un libro personalizado y desconectándonos
del servidor MySQL:
conexion.agregaLibro(new Libro("Daniel Torres","Libro de Muestra","UAM-A","000111222",2014,1));
System.out.println("Nuevo libro agregado");
conexion.verLibros();
conexion.actualizaAnio("000111222",2000);
System.out.println("Año actualizado");
conexion.actualizaAutor("000111222","Daniel Alberto Torres Gonzalez");
System.out.println("Autor actualizado");
conexion.actualizaEdicion("000111222",2);
System.out.println("Edición actualizada");
conexion.actualizaEditorial("000111222","UAM Azcapotzalco");
System.out.println("Editorial actualizado");
conexion.actualizaISBN("000111222","222111000");
System.out.println("ISBN actualizado");
conexion.actualizaTitulo("222111000","Muestras de libro en BD");
System.out.println("Titulo actualizado");
conexion.verLibros();
conexion.eliminaLibro("222111000");
System.out.println("Libro eliminado");
conexion.verLibros();
conexion.desconectar();
x. Ya que tengamos nuestro código de prueba listo, necesitaremos agregar a las librerías del proyecto el conector que
instalamos cuando cargamos MySQL. Para esto, dar un clic derecho en “Libraries”, localizado debajo de “Source
Packages”, en el menú izquierdo y seleccionar “Add JAR/Folder”.
En la ventana que se despliega, buscar la ruta “C:\Program Files (x86)\MySQL\Connector J 5.1.31”, seleccionar el
archivo “mysql-connector-java-5.1.31-bin.jar” y dar clic en “Abrir”.
Al agregar la librería se mostrará debajo de “Libraries”.
y.
Ahora ejecutamos la clase “Test” presionando “Shift” + “F6”. Observamos la salida en pantalla paso a paso para
comprobar que todo esté correcto. Si han realizado cada paso exactamente a como se ha descrito, la salida deberá
ser:
run:
Conexión establecida
Libro agregado
Libro agregado
Libro agregado
Libro agregado
Libro agregado
Autor:
Thomas H. Cormen
Titulo:
Introduction to Algorithms
Editorial:
McGrow-Hill
ISBN:
107013151
Año:
2001
Edicion:2
---------------------------------------------------------Autor:
Barry B. Brey
Titulo:
The Intel Microprocessors
Editorial:
Prentice-Hall International
ISBN:
113802745
Año:
1997
Edicion:4
---------------------------------------------------------Autor:
Cay Horstmann
Titulo:
BIG JAVA
Editorial:
Wilew
ISBN:
326902040
Año:
2008
Edicion:3
---------------------------------------------------------Autor:
Stuart J. Russell
Titulo:
Inteligencia Artificial: Un Enfoque Moderno
Editorial:
Pearson
ISBN:
842054003
Año:
2004
Edicion:2
---------------------------------------------------------Autor:
Deitel & Deitel
Titulo:
Como Programar en Java
Editorial:
Pearson
ISBN:
970260548
Año:
2003
Edicion:5
---------------------------------------------------------Nuevo libro agregado
Autor:
Daniel Torres
Titulo:
Libro de Muestra
Editorial:
UAM-A
ISBN:
000111222
Año:
2014
Edicion:1
---------------------------------------------------------Autor:
Thomas H. Cormen
Titulo:
Introduction to Algorithms
Editorial:
McGrow-Hill
ISBN:
107013151
Año:
2001
Edicion:2
---------------------------------------------------------Autor:
Barry B. Brey
Titulo:
The Intel Microprocessors
Editorial:
Prentice-Hall International
ISBN:
113802745
Año:
1997
Edicion:4
---------------------------------------------------------Autor:
Cay Horstmann
Titulo:
BIG JAVA
Editorial:
Wilew
ISBN:
326902040
Año:
2008
Edicion:3
---------------------------------------------------------Autor:
Stuart J. Russell
Titulo:
Inteligencia Artificial: Un Enfoque Moderno
Editorial:
Pearson
ISBN:
842054003
Año:
2004
Edicion:2
---------------------------------------------------------Autor:
Deitel & Deitel
Titulo:
Como Programar en Java
Editorial:
Pearson
ISBN:
970260548
Año:
2003
Edicion:5
---------------------------------------------------------Año actualizado
Autor actualizado
Edición actualizada
Editorial actualizado
ISBN actualizado
Titulo actualizado
Autor:
Thomas H. Cormen
Titulo:
Introduction to Algorithms
Editorial:
McGrow-Hill
ISBN:
107013151
Año:
2001
Edicion:2
---------------------------------------------------------Autor:
Barry B. Brey
Titulo:
The Intel Microprocessors
Editorial:
Prentice-Hall International
ISBN:
113802745
Año:
1997
Edicion:4
---------------------------------------------------------Autor:
Daniel Alberto Torres Gonzalez
Titulo:
Muestras de libro en BD
Editorial:
UAM Azcapotzalco
ISBN:
222111000
Año:
2000
Edicion:2
---------------------------------------------------------Autor:
Cay Horstmann
Titulo:
BIG JAVA
Editorial:
Wilew
ISBN:
326902040
Año:
2008
Edicion:3
---------------------------------------------------------Autor:
Stuart J. Russell
Titulo:
Inteligencia Artificial: Un Enfoque Moderno
Editorial:
Pearson
ISBN:
842054003
Año:
2004
Edicion:2
---------------------------------------------------------Autor:
Deitel & Deitel
Titulo:
Como Programar en Java
Editorial:
Pearson
ISBN:
970260548
Año:
2003
Edicion:5
---------------------------------------------------------Libro eliminado
Autor:
Thomas H. Cormen
Titulo:
Introduction to Algorithms
Editorial:
McGrow-Hill
ISBN:
107013151
Año:
2001
Edicion:2
---------------------------------------------------------Autor:
Barry B. Brey
Titulo:
The Intel Microprocessors
Editorial:
Prentice-Hall International
ISBN:
113802745
Año:
1997
Edicion:4
---------------------------------------------------------Autor:
Cay Horstmann
Titulo:
BIG JAVA
Editorial:
Wilew
ISBN:
326902040
Año:
2008
Edicion:3
z.
---------------------------------------------------------Autor:
Stuart J. Russell
Titulo:
Inteligencia Artificial: Un Enfoque Moderno
Editorial:
Pearson
ISBN:
842054003
Año:
2004
Edicion:2
---------------------------------------------------------Autor:
Deitel & Deitel
Titulo:
Como Programar en Java
Editorial:
Pearson
ISBN:
970260548
Año:
2003
Edicion:5
---------------------------------------------------------BUILD SUCCESSFUL (total time: 0 seconds)
Si hay algún dato que no coincida, regresar a los pasos anteriores para verificar a que se debe.
Finalmente, mostraré como visualizar con NetBeans la información recién almacenada en nuestra tabla “libros”. En
la pestaña “Services”, damos clic derecho en el nombre de la tabla “libros” y seleccionamos “Refresh”. Con esto
actualizaremos la información almacenada en la tabla.
Nuevamente damos clic derecho en el nombre de la tabla “libros”, pero ahora seleccionamos “View Data…”.
Con esto, se enviará un query de selección al servidor MySQL y nos regresará la información contenida en la tabla,
la cual será desplegada en una nueva pestaña de NetBeans. En la parte superior veremos el nombre de la pestaña; en
la parte central veremos el query enviado; debajo del query veremos la información almacenada en la tabla “libros”
y en la parte inferior veremos el resultado de la ejecución del query.
5.
Con esto comprobamos que el código escrito es correcto.
Interfaz gráfica
Ahora vamos a crear una interfaz gráfica simple con ayuda de NetBeans para manipular nuestra base de datos.
a. Abrimos la clase “GUI” creada en el paquete “uam.azc.mx.vista”. Se desplegará la vista de diseño.
En la parte inferior izquierda podremos ver el navegador. Aquí se mostrarán todos los componentes gráficos que
agreguemos a nuestra clase.
En la parte central tendremos la vista de nuestro JFrame principal, en el cual vamos a agregar los componentes
gráficos.
Del lado superior derecho tenemos la paleta de componentes gráficos. De aquí podemos seleccionar el componente
que deseamos mostrar en nuestro JFrame principal arrastrándolo directamente hacia él. De los “Swing Containers”
utilizaremos solamente el “Scroll Pane”.
De los “Swing Controls” utilizaremos “Label”, ”Button”, ”Radio Button”, ”Button Group”, ”Text Field” y
”Separator”.
En la parte inferior derecha podremos ver las propiedades del componente que seleccionemos.
b.
Ahora vamos a agregar nuestros componentes al JFrame principal arrastrándolos desde la paleta. Los componentes
que seleccionaremos son:
 Siete Button: Conectar, Desconectar, Ver Libros, Agregar, Eliminar, Cambiar, Salir.
 Ocho Label: Status, Autor, Título, Editorial, Año, Edición, ISBN, Nuevo.
 Siete TextField: Uno para cada Label.
 Seis Radio Button: Uno para cada Label.
 Dos Separator: Uno para separar los botones Conectar, Desconectar y la etiqueta Status y el otro para
separar el botón Ver Libros y el Scroll Pane del resto de los componentes.
 Un Scroll Pane: Nos servirá para crear dinámicamente una tabla que contendrá los libros de la base de
datos.
 Un Button Group: en él añadiremos con código Java los seis Radio Button.
Los componentes serán acomodados preferentemente como muestra la siguiente imagen:
Las dimensiones de cada componente dependen de cada uno. Lo que si se recomienda es que asignen un nombre de
variable diferente al que se otorga por default. De esta manera podrán identificar más fácilmente sus componentes.
A continuación muestro los nombres de variables que asigné:
Recomiendo utilizar los mismos nombres de variable debido a que en el código Java que se escriba los utilizaré tal y
como se muestran. Para poder cambiar los nombres de variable hay que dar clic derecho en algún componente y
seleccionar “Change Variable Name…”.
En la ventana que se despliega escribir el nombre nuevo para la variable y dar clic en “OK”.
c.
Ya que tengamos todos nuestros componentes ordenados y renombrados en el JFrame principal, vamos a especificar
la acción que va a realizar cada botón al ser presionado. Para esto, damos clic derecho en algún botón,
seleccionamos “Events“”Action””actionPerformed”.
Cada que hagamos esto se cambiará el modo. Para cambiar entre el modo diseño y el modo código hay que
seleccionar “Design” o “Source”, ubicados en la parte central superior.
d.
Hay que agregar una acción a cada botón. Cuando se realice este procedimiento con cada botón, ir al modo “Source”
para escribir el código Java necesario para que nuestra clase funcione adecuadamente.
Ya en el modo “Source”, podremos ver el código Java de nuestra clase. Las líneas que estén de color gris no las
podremos modificar, debido a que NetBeans restringe su modificación.
e.
f.
g.
h.
i.
j.
En la clase “GUI” hacemos las siguientes importaciones:
import java.util.List;
import javax.swing.JOptionPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;
import uam.azc.mx.control.SQL;
import uam.azc.mx.modelo.Libro;
Agregamos un atributo privado de tipo “SQL” llamado “conexion”:
private SQL conexion;
En el constructor añadimos lo siguiente:
initComponents();
this.conexion=new SQL();
this.GrupoRadioBotones.add(this.RadioBotonAnio);
this.GrupoRadioBotones.add(this.RadioBotonAutor);
this.GrupoRadioBotones.add(this.RadioBotonEdicion);
this.GrupoRadioBotones.add(this.RadioBotonEditorial);
this.GrupoRadioBotones.add(this.RadioBotonISBN);
this.GrupoRadioBotones.add(this.RadioBotonTitulo);
this.RadioBotonAutor.setSelected(true);
this.BotonAgregar.setEnabled(false);
this.BotonCambiar.setEnabled(false);
this.BotonEliminar.setEnabled(false);
this.BotonVerLibros.setEnabled(false);
this.BotonDesconectar.setEnabled(false);
En el método que se creó para realizar la acción del botón “Conectar” (private
BotonConectarActionPerformed(java.awt.event.ActionEvent evt)), escribimos lo siguiente:
if(!this.conexion.conectar("localhost","biblioteca","root","123456")){
JOptionPane.showMessageDialog(this,"Error
al
conectar
con
la
base
datos","Error",JOptionPane.ERROR_MESSAGE);
return;
}
this.BotonAgregar.setEnabled(true);
this.BotonCambiar.setEnabled(true);
this.BotonConectar.setEnabled(false);
this.BotonEliminar.setEnabled(true);
this.BotonVerLibros.setEnabled(true);
this.BotonDesconectar.setEnabled(true);
this.Status.setText("Conectado");
En el método que se creó para realizar la acción del botón “Desconectar” (private
BotonDesconectarActionPerformed(java.awt.event.ActionEvent evt)), escribimos lo siguiente:
this.conexion.desconectar();
this.BotonAgregar.setEnabled(false);
this.BotonCambiar.setEnabled(false);
this.BotonConectar.setEnabled(true);
this.BotonEliminar.setEnabled(false);
this.BotonVerLibros.setEnabled(false);
this.BotonDesconectar.setEnabled(false);
this.Status.setText("Desconectado");
En el método que se creó para realizar la acción del botón “Agregar” (private
BotonAgregarActionPerformed(java.awt.event.ActionEvent evt)), escribimos lo siguiente:
if(this.CampoAnio.getText().isEmpty() || this.CampoAutor.getText().isEmpty() ||
this.CampoEdicion.getText().isEmpty() || this.CampoEditorial.getText().isEmpty() ||
this.CampoISBN.getText().isEmpty() || this.CampoTitulo.getText().isEmpty()){
void
de
void
void
k.
l.
JOptionPane.showMessageDialog(this,"Especifique
todos
los
campos","Error",JOptionPane.ERROR_MESSAGE);
return;
}
Libro libro=new Libro(this.CampoAutor.getText(),
this.CampoTitulo.getText(),
this.CampoEditorial.getText(),
this.CampoISBN.getText(),
Integer.parseInt(this.CampoAnio.getText()),
Integer.parseInt(this.CampoEdicion.getText()));
if(!this.conexion.agregaLibro(libro)){
JOptionPane.showMessageDialog(this,"Error al agregar el libro","Error",JOptionPane.ERROR_MESSAGE);
return;
}
JOptionPane.showMessageDialog(this,"Libro
agregado
con
éxito","OK",JOptionPane.INFORMATION_MESSAGE);
En el método que se creó para realizar la acción del botón “Eliminar” (private void
BotonEliminarActionPerformed(java.awt.event.ActionEvent evt)), escribimos lo siguiente:
if(this.CampoISBN.getText().isEmpty()){
JOptionPane.showMessageDialog(this,"Especifique el campo ISBN","Error",JOptionPane.ERROR_MESSAGE);
return;
}
if(!this.conexion.eliminaLibro(this.CampoISBN.getText())){
JOptionPane.showMessageDialog(this,"Error al eliminar el libro","Error",JOptionPane.ERROR_MESSAGE);
return;
}
JOptionPane.showMessageDialog(this,"Libro
eliminado
con
éxito","OK",JOptionPane.INFORMATION_MESSAGE);
En el método que se creó para realizar la acción del botón “Cambiar” (private void
BotonCambiarActionPerformed(java.awt.event.ActionEvent evt)), escribimos lo siguiente:
if(this.CampoISBN.getText().isEmpty()){
JOptionPane.showMessageDialog(this,"Especifique el ISBN","Error",JOptionPane.ERROR_MESSAGE);
return;
}
if(this.RadioBotonAnio.isSelected()){
if(this.CampoAnio.getText().isEmpty()){
JOptionPane.showMessageDialog(this,"Especifique el año","Error",JOptionPane.ERROR_MESSAGE);
return;
}
if(!this.conexion.actualizaAnio(this.CampoISBN.getText(),Integer.parseInt(this.CampoAnio.getText()))){
JOptionPane.showMessageDialog(this,"Error al actualizar","Error",JOptionPane.ERROR_MESSAGE);
return;
}
}
else if(this.RadioBotonAutor.isSelected()){
if(this.CampoAutor.getText().isEmpty()){
JOptionPane.showMessageDialog(this,"Especifique el autor","Error",JOptionPane.ERROR_MESSAGE);
return;
}
if(!this.conexion.actualizaAutor(this.CampoISBN.getText(),this.CampoAutor.getText())){
JOptionPane.showMessageDialog(this,"Error al actualizar","Error",JOptionPane.ERROR_MESSAGE);
return;
}
}
else if(this.RadioBotonEdicion.isSelected()){
if(this.CampoEdicion.getText().isEmpty()){
JOptionPane.showMessageDialog(this,"Especifique la edición","Error",JOptionPane.ERROR_MESSAGE);
return;
}
if(!this.conexion.actualizaEdicion(this.CampoISBN.getText(),Integer.parseInt(this.CampoEdicion.getText()))){
JOptionPane.showMessageDialog(this,"Error al actualizar","Error",JOptionPane.ERROR_MESSAGE);
return;
}
}
else if(this.RadioBotonEditorial.isSelected()){
if(this.CampoEditorial.getText().isEmpty()){
JOptionPane.showMessageDialog(this,"Especifique la editorial","Error",JOptionPane.ERROR_MESSAGE);
return;
}
if(!this.conexion.actualizaEditorial(this.CampoISBN.getText(),this.CampoEditorial.getText())){
JOptionPane.showMessageDialog(this,"Error al actualizar","Error",JOptionPane.ERROR_MESSAGE);
return;
}
}
else if(this.RadioBotonISBN.isSelected()){
if(this.CampoNuevo.getText().isEmpty()){
JOptionPane.showMessageDialog(this,"Especifique el nuevo isbn","Error",JOptionPane.ERROR_MESSAGE);
return;
}
if(!this.conexion.actualizaISBN(this.CampoISBN.getText(),this.CampoNuevo.getText())){
JOptionPane.showMessageDialog(this,"Error al actualizar","Error",JOptionPane.ERROR_MESSAGE);
return;
}
}
else if(this.RadioBotonTitulo.isSelected()){
if(this.CampoTitulo.getText().isEmpty()){
JOptionPane.showMessageDialog(this,"Especifique el título","Error",JOptionPane.ERROR_MESSAGE);
return;
}
if(!this.conexion.actualizaTitulo(this.CampoISBN.getText(),this.CampoTitulo.getText())){
JOptionPane.showMessageDialog(this,"Error al actualizar","Error",JOptionPane.ERROR_MESSAGE);
return;
}
}
BotonVerLibrosActionPerformed(null);
JOptionPane.showMessageDialog(this,"Libro
actualizado
con
éxito","OK",JOptionPane.INFORMATION_MESSAGE);
m. En el método que se creó para realizar la acción del botón “Ver Libros” (private void
BotonVerLibrosActionPerformed(java.awt.event.ActionEvent evt)), escribimos lo siguiente:
DefaultTableModel modeloTabla=new DefaultTableModel(){
@Override
public boolean isCellEditable(int row,int column){
return(false);
}
};
modeloTabla.addColumn("Autor");
modeloTabla.addColumn("Título");
modeloTabla.addColumn("Editorial");
n.
o.
p.
modeloTabla.addColumn("Año");
modeloTabla.addColumn("Edición");
modeloTabla.addColumn("ISBN");
List <Libro> libros;
if((libros=this.conexion.verLibros())==null){
JOptionPane.showMessageDialog(this,"Error al consultar los libros","Error",JOptionPane.ERROR_MESSAGE);
return;
}
for(Libro l : libros){
Object [] s={l.getAutor(),l.getTitulo(),l.getEditorial(),l.getAnio(),l.getEdicion(),l.getISBN()};
modeloTabla.addRow(s);
}
JTable tabla=new JTable(modeloTabla);
this.ScrollPanel.setViewportView(tabla);
Finalmente en el método que se creó para realizar la acción del botón “Salir” (private void
BotonSalirActionPerformed(java.awt.event.ActionEvent evt)), escribimos lo siguiente:
try{
BotonDesconectarActionPerformed(null);
}
catch(NullPointerException e){}
System.exit(0);
Ahora, necesitamos modificar el método “verLibros” de nuestra clase “SQL”. Abrimos la clase “SQL”, nos
dirigimos a este método y rescribimos como sigue:
public List <Libro> verLibros(){
String query="SELECT * FROM libros";
List <Libro> libs=new ArrayList <Libro> ();
try{
PreparedStatement ps=this.conn.prepareStatement(query);
ResultSet libros=ps.executeQuery();
while(libros.next()){
Libro libro=new Libro(libros.getString("autor"),
libros.getString("titulo"),
libros.getString("editorial"),
libros.getString("isbn"),
Integer.parseInt(libros.getString("anio")),
Integer.parseInt(libros.getString("edicion")));
libs.add(libro);
}
}
catch(SQLException e){
System.err.println("Error: " + e.getMessage());
}
return(libs);
}
De esta forma no se mostrarán más errores en compilación y podremos ejecutar nuestra clase “GUI” presionando
“Shift” + “F6”, para así verificar la función de cada componente que se ha añadido.
En caso de que se hayan realizado los pasos anteriores y no se muestre el resultado esperado, me pueden contactar al correo
[email protected] y con gusto resolveré sus dudas.
Creado por: Ing. Daniel Alberto Torres González
Fecha: 18 de septiembre de 2014.