044.- Acceso A Base De Datos - Java Y NetBeans

Acceso a Base de Datos desde una aplicación Java:

El objetivo de todas las entradas anteriores dedicadas a las bases de datos, es finalmente aprender a crear una base de datos que contenga toda la información que la empresa necesita gestionar. Es decir, crear una base de datos.

Esta base de datos se incluirá con el programa java que se realice. Nuestro programa java accederá a esta base de datos continuamente para añadir nuevos datos, o modificar datos, eliminar datos, o extraer datos según lo ordene el usuario del programa.

En este post, se verán los pasos necesarios para conectar un proyecto java con una base de datos creada en SQL Server.

Pasos Generales para preparar una Aplicación Java para acceder a una Base de Datos

Para preparar nuestra aplicación Java para que pueda acceder a una Base de Datos, es necesario realizar tres pasos:

1.  Cargar el controlador de la base de datos:

El controlador define el tipo de base de datos que se va a usar (base de datos de SQL Server, Access, MySQL, PostgreSQL o de cualquier otro gestor de base de datos).

En nuestro caso, tendremos que indicar el controlador para base de datos de SQL Server.

2.  Crear un objeto conexión (Connection):

Para crear este objeto hay que indicar la ubicación de la base de datos, el usuario y la contraseña de dicha base de datos. El objeto conexión abre la base de datos.

3.  Crear un objeto sentencia (Statement):

El objeto sentencia se crea a partir del objeto conexión anterior. Los objetos sentencia permiten realizar acciones sobre la base de datos usando instrucciones SQL.

Es decir, a través del objeto sentencia introduciremos datos en la base de datos, eliminaremos datos, haremos modificaciones, y extraeremos datos de la base de datos.

Así pues, este objeto es vital. Este objeto es el que realmente permite el acceso a los datos de la base de datos y la manipulación de dicha base de datos.

EJERCICIO GUIADO Nº 1

PLANTEAMIENTO:

En este ejercicio se pretende crear una pequeña aplicación de bases de datos que permita simplemente mostrar los datos de los trabajadores almacenados en la base de datos AMANUVA.

1. Entre en NetBeans. Crea un nuevo proyecto llamado AccesoBaseDatos. Dentro de este proyecto crea un paquete principal llamado paqueteVentanas y dentro de él un JFrame llamado VentanaPrincipal:

2. En la parte superior de la ventana añade un botón con el texto Mostrar Trabajadores que se llame btnMostrarTrabajadores:

3. Se pretende simplemente que al pulsar el botón btnMostrarTrabajadores aparezcan en un JOptionPane datos sobre los trabajadores almacenados en la base de datos.

PREPARACIÓN DEL SQL SERVER PARA QUE PERMITA ACCEDER A LA BASE DE DATOS AMANUVA:

4. Clic derecho en la instancia y escoger la opción Propiedades:

5. En la opción Security configurar según se indica en la siguiente pantalla:

6. En la opción Connections configurar según se indica en la siguiente pantalla y acepta los cambios:

7. Luego dar clic derecho en la Logins y escoger la opción New Login…:

8. En la opción General configurar según se indica en la siguiente pantalla:

9. En la opción Server Roles configurar según se indica en la siguiente pantalla:

10. En la opción Status configurar según se indica en la siguiente pantalla y acepta los cambios:

11. En el Administrador de Configuraciones dentro de la opción Protocols for NAMEINSTANCIIAA hacer clic derecho en TCP/IP (el cual debe estar habilitado) y escoger la opción Propiedades:

12. Al final de la pestaña IP Addresses en la opción TCP Port escribir 1433 y acepta los cambios:

13. Dentro de la opción SQL Server Services hacer clic derecho en la opción  SQL Server (NAMEINSTANCIIAA) y escoger la opción Restart:

PREPARACIÓN DE LA APLICACIÓN JAVA PARA EL ACCESO A LA BASE DE DATOS:

14. Descargar el archivo sqljdbc4.jar desde la página de Microsoft.
15. Agregarlo a las bibliotecas del proyecto AccesoBaseDatos haciendo clic derecho en Libraries y escogiendo la opción Add JAR/Folder… y buscando el archivo descargado (slqjdbc4.jar).
16. Para poder acceder y manipular una base de datos, es necesario tener dos objetos:

-           Un objeto del tipo Connection, al que llamaremos conexion. Este objeto define la conexión con la base de datos.

-           Un objeto del tipo Statement, al que llamaremos sentencia. Este objeto permite manipular la base de datos.

17. Así pues, lo primero que haremos será definir estos objetos como globales en la clase de la VentanaPrincipal, para así poderlos usar desde cualquier lado:

Aparecerán subrayados ya que será necesario indicar el import para las clases Connection y Statement. Estos import son respectivamente:

java.sql.Connection

y

java.sql.Statement

Agrega los import correspondientes para eliminar los errores.

18. Una vez definidos los objetos conexion y sentencia, necesarios para el acceso a la base de datos, prepararemos nuestro programa para que pueda acceder a la base de datos AMANUVA. Esto se hará en el método constructor.

19. En primer lugar, añade al método constructor una llamada al método conectarBaseDatos:

20. Crea el método conectarBaseDatos debajo del método constructor y empieza a programar lo siguiente:

El código que acabas de programar es el primer paso a realizar para el acceso a una base de datos: La carga del controlador.

Recuerda que el controlador le indica a Java que tipo de base de datos usaremos: SQL Server, PostgreSQL, Access, MySQL, etc.

El controlador que le indica a java que usaremos una base de datos de SQL Server viene definido a través de la siguiente cadena de texto:

com.microsoft.sqlserver.jdbc.SQLServerDriver

Y la forma de activar dicho controlador es a través de la instrucción:

Class.forName(controlador);

Donde controlador es una variable tipo cadena que contiene la cadena anterior.

Básicamente, lo que hacen estas dos líneas de código, es preparar a Java para poder usar SQL Server.

En el caso de que se quisiera usar una base de datos realizada en otro programa que no fuera SQL Server, habría que cambiar la cadena de texto correspondiente a su controlador.

En nuestro caso usaremos SQL Server.

También puedes observar que es obligatorio encerrar el código de la carga del controlador entre try…catch para capturar cualquier error imprevisto.

21. Ahora añade el siguiente código a continuación del anterior (dentro del método conectarBaseDatos):

El código que acabas de añadir corresponde al segundo paso para acceder a una base de datos: Crear el objeto conexion.

El objeto conexion es el que efectúa la conexión real con la base de datos. Se podría decir que es el objeto que permite abrir la puerta del fichero de base de datos para entrar en él. Para construir este objeto conexion (el cual ya está declarado en la parte global de la clase) hacen falta tres datos:

·       El nombre del usuario que manipulará la base de datos:

String usuario = "UsuarioAMANUVA";

·       El password del usuario que manipulará la base de datos:

String clave = "123";

·       El DSN de la base de datos. DSN significa “nombre del origen de datos” y es una cadena de texto algo compleja que contiene información sobre la base de datos que queremos usar:

String DSN =
"jdbc:sqlserver://servidor\\nameinstanciiaa:1433;databasename=AMANUVA;";

En esta cadena hay que indicar el nombre del ordenador donde está la base de datos, el nombre de la instancia en SQL Server, el número de puerto de conexión y el nombre de la base de datos. Observa la necesidad de escribir dos barras.

Finalmente se usa la instrucción:

conexion = DriverManager.getConnection(DSN, usuario, clave);

para crear la conexión. Será necesario añadir un import para la clase DriverManager.

Al igual que con el primer paso, es necesario rodear la creación de la conexión con un try…catch para capturar cualquier error inesperado que se pueda producir en este paso.

22. Ahora añade el siguiente código a continuación del anterior (dentro del método conectarBaseDatos):

Este código que acabas de añadir corresponde al tercer paso necesario para poder acceder a una base de datos: Creación del objeto sentencia.

El objeto sentencia será el que nos permita ejecutar órdenes SQL sobre la base de datos. Es decir, el objeto que nos permite actuar y manipular la base de datos. Este objeto es vital, y es el objetivo de toda esta preparación.

El objeto sentencia se crea a partir del objeto conexion creado en el paso anterior, usando la siguiente instrucción:

sentencia =
conexion.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);

Y como sucedió en los dos pasos anteriores, es necesario rodear esta instrucción con un try…catch para capturar cualquier tipo de error inesperado que se pudiera producir.

23. Así pues ya tenemos preparado nuestro programa para acceder a la base de datos. Esta preparación se realiza en el momento en que se ejecuta el programa, ya que hemos introducido este código en el método constructor.

Es cierto que este código puede resultar bastante abstracto y complejo, pero tiene la gran ventaja de que siempre es igual.

Si se quiere usar otra base de datos que se encuentre en el mismo ordenador de la creada anteriormente solamente tendremos que cambiar el nombre de la base de datos, nombre de usuario y la clave.

El resto del código queda igual.

Observa:

24. El objetivo de todo este código de preparación para el acceso a la base de datos es obtener un objeto llamado sentencia que nos posibilitará la manipulación de los datos de la base de datos, usando órdenes SQL.

25.En el ejercicio siguiente usaremos el objeto sentencia para averiguar información acerca de los trabajadores utilizando consultas SQL.

26. Cuando se pulse el botón Mostrar Trabajadores tendremos que extraer los datos de la tabla Trabajadores para poder mostrarlos. Para ello, escribe el siguiente código dentro del evento actionPerformed del botón btnMostrarTrabajadores:

Observa el código:

ResultSet rs = sentencia.executeQuery("SELECT * FROM Trabajadores ORDER BY nombres");

El objeto sentencia se usa para dar órdenes a la base de datos. Esas órdenes se dan usando el lenguaje de consulta SQL.

Se usa el método executeQuery  del objeto sentencia para ejecutar la consulta SQL “SELECT * FROM Trabajadores ORDER BY nombres”. Esta consulta extraerá todos los datos de la tabla Trabajadores ordenados por el campo nombres.

El método executeQuery recibe como parámetro una cadena representando la consulta SQL.

El resultado de la consulta se guarda en un objeto del tipo ResultSet al que se ha llamado “rs”. Los objetos de la clase ResultSet almacenan el resultado de una consulta SQL.  (Será necesario incluir el import necesario para la clase ResultSet).

Y como puedes observar, es necesario rodear la ejecución de una consulta SQL con un try…catch para capturar errores inesperados al realizar la consulta.

Los Objetos ResultSet:

27. Debes imaginarte el objeto ResultSet rs como una tabla que contiene el resultado de la consulta SQL que se ha ejecutado. En nuestro caso, la consulta SQL que hemos ejecutado ha extraído toda la tabla Trabajadores. Por tanto nuestro ResultSet contiene toda la tabla Trabajadores.

El objeto rs por tanto podría representarse así:

28. La fila BOF significa “comienzo de fichero” y representa una fila anterior al primer registro del ResultSet.

La fila EOF significa “final de fichero” y representa una fila posterior al último registro del ResultSet.

La flecha indica la posición actual donde estamos situados dentro de la tabla del ResultSet.

29. Añade la siguiente línea al código al evento actionPerformed:

El método next del ResultSet hará que avancemos una fila en el ResultSet. Es decir, ahora estaremos situados en la primera fila del ResultSet (la flecha avanza una posición):

30. Ahora que estamos situados en la posición del primer trabajador (GABRIEL), podemos extraer información referente a sus campos. Añade el siguiente código al actionPerformed del botón:

Lo que se ha hecho primero es declarar una variable tipo cadena llamada info.

Luego, a esta variable se le ha asignado una concatenación de cadenas:

info = "El trabajador se llama " + rs.getString("nombres") + " " + rs.getString("apellidos");

info += " y cobra " + rs.getString("sueldo");

Lo interesante de esto es el método getString del objeto ResultSet rs. El método getString permite extraer una cadena con el valor del campo indicado como parámetro.

En nuestro caso:

rs.getString("nombres")

Extrae los nombres del trabajador actual (“GABRIEL”).

rs.getString("apellidos")

Extrae los apellidos del trabajador actual (“BENITES”).

rs.getString("sueldo")

Extrae el sueldo del trabajador actual (“6000.00”).

Luego se muestra la cadena info en un simple JOptionPane.

31. Ya puedes ejecutar el programa:

32. Sigamos haciendo cambios en el código del botón para entender mejor el funcionamiento de los ResultSet. Añade la siguiente línea:

33. Se ha añadido un segundo next. Esto producirá que la flecha avance dos posiciones en el ResultSet, y por tanto se coloque en la segunda fila:

34. Esto quiere decir que si se ejecuta el programa se mostrará información sobre MARIA SANCHEZ. Compruébalo:

35. Los objetos ResultSet poseen diversos métodos para cambiar la posición actual en la tabla del ResultSet. Dicho de otro modo: “para mover la flecha”. Veamos algunos de estos métodos (se supone que el objeto ResultSet se llama rs):

rs.next();                         -->   Mueve la flecha a la siguiente fila

rs.previous();             -->   Mueve la flecha a la fila anterior

rs.first();                         -->   Mueve la flecha a la primera fila

rs.last();                          -->   Mueve la flecha a la última fila

rs.beforeFirst();         -->   Mueve la flecha a la fila BOF

rs.afterLast();            -->   Mueve la flecha a la fila EOF

rs.absolute(n);            -->   Mueve la flecha a la fila n del ResultSet.

Las filas se empiezan a numerar por 1.

36. Haga el siguiente cambio en el actionPerformed simplemente para experimentar:

En este caso la flecha se coloca en EOF (afterLast) y luego retrocede una fila (previous). Por tanto, al ejecutar el programa se mostrarán los datos del último trabajador. Compruebalo:

37. Otro experimento. Cambie ahora el código de esta forma:

Este código coloca la flecha en la fila 2 ( absolute(2) ), luego avanza una fila (next), luego retrocede una fila (previous) y finalmente retrocede una fila (previous).

Así pues, finalmente, la flecha queda colocada en la primera fila. Por lo tanto se muestran los datos del primer trabajador. Compruébalo:

38. Como ves, podemos movernos dentro del contenido del ResultSet gracias a todos estos métodos, para luego poder extraer los datos de la fila correspondiente.

Ahora, estudiaremos la forma de recorrer todas las filas del ResultSet para así extraer la información de todos sus registros.

39. Vamos a modificar nuestro código para que se muestren todos los trabajadores del ResultSet. Para ello, realiza el siguiente cambio:

En este código se ha inicializado la variable info a la cadena vacía “” y luego se ha añadido un bucle bastante interesante:

rs.beforeFirst();

while (rs.next()) {

info += rs.getString("nombres") + " " + rs.getString("apellidos") + " " + rs.getString("sueldo") + "\n";

}

Analicemos este bucle:

-           Lo primero que se hace es colocar explícitamente la flecha en la fila BOF, es decir, antes del primer trabajador:

rs.beforeFirst();

-           Luego tenemos un bucle mientras que comienza así:

while (rs.next()) {

El método next intenta colocar la flecha en la siguiente fila, y si lo hace bien, devuelve el valor verdadero. Cuando no se puede avanzar más, el método next devolverá falso.

Así pues, este while significa “mientras se haya podido avanzar una fila, haz lo siguiente”. O dicho de otro modo, este bucle se repetirá para cada fila de la tabla del ResultSet.

-           Si analizamos el contenido del bucle, básicamente veremos una concatenación de cadenas dentro de la variable info. En cada vuelta del bucle se concatenará los nombres, apellidos y sueldo de cada trabajador.

info += rs.getString("nombres") + " " + rs.getString("apellidos") + " " + rs.getString("sueldo") + "\n";

-           Finalmente se visualiza la variable info en un JOptionPane.

40. Ejecuta el programa y comprueba su funcionamiento.

41. El bucle que acabas de programar es un código “clásico” para manipular un ResultSet. Siempre que quieras recorrer todas las filas del ResultSet harás algo como esto:

rs.beforeFirst();

while (rs.next()) {

manipulación de la fila

}

42. Se ha visto que para obtener un dato de la fila actual se usa el método getString indicando como parámetro el nombre del campo que se quiere obtener.

Por ejemplo:

rs.getString("sueldo");

Obtiene el sueldo del trabajador señalado actualmente con la flecha. Este sueldo se obtiene convertido en cadena.

43. Los ResultSet poseen otros métodos para obtener los datos convertidos en números como son:

getInt(“campo”)

y

getDouble(“campo”)

para obtener el dato en entero o double, respectivamente.

Esto nos permite el realizar operaciones con los datos extraídos del ResultSet.

44. Como ejemplo de esto último, realice la siguiente mejora al programa:

En este nuevo código se ha añadido una variable double acumuladora llamada totalSum, donde sumaremos todos los sueldos.

Dentro del bucle, se van acumulando el sueldo de cada trabajador. Observa el uso del método getDouble para obtener el campo sueldo de forma numérica, en vez de usar getString:

totalSum = totalSum + rs.getDouble("sueldo");

Y finalmente usamos otro JOptionPane para ver la suma de los sueldos calculada.

Ejecuta el programa y comprueba su funcionamiento.

45. Una vez finalizado el programa, es una buena costumbre cerrar la base de datos que estamos manejando. Esto se hace cerrando la “conexión” con la base de datos.

Para hacer esto se usa el método close del objeto conexion.

Esto se hará en el momento en que se finalice el programa, es decir, en el evento windowClosing de la ventana principal:

Como ves, también hay que encerrar este código entre try…catch para capturar posibles errores.

CONCLUSIONES:

Para crear un programa Java que pueda usar una base de datos será necesario realizar los siguientes pasos:

* Preparar el acceso a la base de datos (en el método constructor).

* Se crearán dos objetos: conexion (Connection) y sentencia (Statement).

* Se cargará el controlador del tipo de base de datos a usar.

* Se creará el objeto conexion indicando la base de datos.

* Se creará el objeto sentencia a partir del objeto conexion.

* Se usará el objeto sentencia para ejecutar consultas SQL en la base de datos.

* Las consultas SQL ejecutadas en la base de datos se almacenan en objetos del tipo ResultSet.

* Un objeto ResultSet tiene forma de tabla conteniendo el resultado de la consulta SQL.

* Los objetos ResultSet tienen métodos para seleccionar el registro de la tabla.

* Los objetos ResultSet tienen métodos que permiten extraer el dato de un campo en concreto.