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

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.

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

http://dev.mysql.com/downloads/windows/installer/

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

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

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.

f. 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. Ya tenemos instalado nuestro servidor MySQL en el sistema operativo. Damos clic en “Finish” para cerrar el

instalador.

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

d. Ya que terminemos de trabajar con MySQL desde la consola, para salir escribimos “exit”.

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

j. 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”.

k. 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. 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;

d. 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;

}

e. 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. 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----------------------------------------------------------");

}

g. 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);


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);


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

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.

i. 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;

j. Agregamos un dato miembro privado de tipo “Connection” llamado “conn” y el constructor de la clase:

private Connection conn;

public SQL(){

this.conn=null;

}

k. 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){


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();

}



}

}

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();

}



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{


ps.execute();

}



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{


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());

}

}



}

}

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.

p. 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{


ps.execute();

}



return(false);

}

return(true);

}

public boolean actualizaTitulo(String isbn,String titulo){

String query="UPDATE libros SET titulo='" + titulo + "' WHERE isbn='" + isbn + "'";

try{


ps.execute();

}



return(false);

}

return(true);

}

public boolean actualizaEditorial(String isbn,String editorial){

String query="UPDATE libros SET editorial='" + editorial + "' WHERE isbn='" + isbn + "'";

try{


ps.execute();

}



return(false);

}

return(true);

}

public boolean actualizaISBN(String isbn,String nuevo){

String query="UPDATE libros SET isbn=’" + nuevo + "’ WHERE isbn='" + isbn + "'";

try{


ps.execute();

}



return(false);

}

return(true);

}

public boolean actualizaAnio(String isbn,int anio){

String query="UPDATE libros SET anio=" + anio + " WHERE isbn='" + isbn + "'";

try{


ps.execute();

}



return(false);

}

return(true);

}

public boolean actualizaEdicion(String isbn,int edicion){

String query="UPDATE libros SET edicion=" + edicion + " WHERE isbn='" + isbn + "'";

try{


ps.execute();

}



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

q. Ya que tenemos terminada la clase “SQL”, modificamos la clase “Test” para realizar pruebas. Primero, importamos

lo siguiente:

import uam.azc.mx.control.SQL;

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

s. 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.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.eliminaLibro("222111000");

System.out.println("Libro eliminado");


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




ISBN: 107013151

Año: 2001

Edicion: 2

----------------------------------------------------------




ISBN: 113802745

Año: 1997

Edicion: 4

----------------------------------------------------------


Titulo: BIG JAVA

Editorial: Wilew

ISBN: 326902040

Año: 2008

Edicion: 3

----------------------------------------------------------



Editorial: Pearson

ISBN: 842054003

Año: 2004

Edicion: 2

----------------------------------------------------------



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

----------------------------------------------------------




ISBN: 107013151

Año: 2001

Edicion: 2

----------------------------------------------------------




ISBN: 113802745

Año: 1997

Edicion: 4

----------------------------------------------------------


Titulo: BIG JAVA

Editorial: Wilew

ISBN: 326902040

Año: 2008

Edicion: 3

----------------------------------------------------------



Editorial: Pearson

ISBN: 842054003

Año: 2004

Edicion: 2

----------------------------------------------------------



Editorial: Pearson

ISBN: 970260548

Año: 2003

Edicion: 5

----------------------------------------------------------

Año actualizado

Autor actualizado

Edición actualizada

Editorial actualizado

ISBN actualizado

Titulo actualizado




ISBN: 107013151

Año: 2001

Edicion: 2

----------------------------------------------------------




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

----------------------------------------------------------


Titulo: BIG JAVA

Editorial: Wilew

ISBN: 326902040

Año: 2008

Edicion: 3

----------------------------------------------------------



Editorial: Pearson

ISBN: 842054003

Año: 2004

Edicion: 2

----------------------------------------------------------



Editorial: Pearson

ISBN: 970260548

Año: 2003

Edicion: 5

----------------------------------------------------------

Libro eliminado




ISBN: 107013151

Año: 2001

Edicion: 2

----------------------------------------------------------




ISBN: 113802745

Año: 1997

Edicion: 4

----------------------------------------------------------


Titulo: BIG JAVA

Editorial: Wilew

ISBN: 326902040

Año: 2008

Edicion: 3

----------------------------------------------------------



Editorial: Pearson

ISBN: 842054003

Año: 2004

Edicion: 2

----------------------------------------------------------



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.

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

Con esto comprobamos que el código escrito es correcto.

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

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.

d. 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. 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;

f. Agregamos un atributo privado de tipo “SQL” llamado “conexion”:

private SQL conexion;

g. 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);

h. En el método que se creó para realizar la acción del botón “Conectar” (private void

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 de

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");

i. En el método que se creó para realizar la acción del botón “Desconectar” (private void

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");

j. En el método que se creó para realizar la acción del botón “Agregar” (private void

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()){

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);

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


l. 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())){


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()))){


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())){


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())){


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())){


return;

}

}

BotonVerLibrosActionPerformed(null);

JOptionPane.showMessageDialog(this,"Libro actualizado con


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");

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);

n. 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);

o. 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{


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);

}

}



}

return(libs);

}

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

mailto:[email protected]

instructivo de instalación de manejador de base de datos...

Documents