Como crear Ventanas con Ejemplo de Persistencia, grabando datos con Java, usando Oracle Express como base de datos
En este tutorial se mostrará como guardar los campos de un formulario de una ventana JFrame, grabando los mismos en una base de datos Oracle Express.
Mostraré un programa muy sencillo, sin muchos campos. La ventana tendrá los datos de dos campos y luego un objeto que también se guardará en la base de datos, pero con los datos escritos manualmente. La objetivo es hacer el proceso completo a modo de prueba a ver si todo funciona como se espera.
Para este ejercicio se debe tener instalada la Base de Datos Oracle Express 11g edition. Si no la tienes instalada aqui tienes un enlace para hacerlo, en Ubuntu 16.04 LTS:
Instalar y configurar Oracle Expess 11g R2
Aunque no es estrictamente necesario, pero si una gran ayuda, es aconsejable tener instalado el Oracle SQL Developer. Con vamos a crear la table y los tipo objeto que van a contener los datos que pasemos desde el programa.
Vamos de una vez al código y ponernos a trabajar.
Creamos un proyecto con el nombre que mejor nos parezca. Sino no sabes como hacerlo puedes seguir este enlace
Ya tenemos hechas parcialmente las ventanas que vamos a utilizar, en otro proyecto, y puedes copiar el código desde este enlace:
Crear Ventanas en Java rápida y fácilmente.
Empezaremos accediendo a la base de datos, nosotros vamos a utilizar Oracle SQL Developer. Iniciamos el Developer y una vez dentro pulsamos en SQL como vemos en la imagen y vamos a escribir las sentencias SQL indicadas, en el mismo orden
CREATE OR REPLACE TYPE TIPO_DATOS AS OBJECT
(
EMAIL VARCHAR2(30),
TELEFONO VARCHAR2(12)
);
CREATE TABLE AGENDA
(
NOMBRE VARCHAR2(30),
APELLIDOS VARCHAR2(30),
DATOS TIPO_DATOS
);
Es obligatorio primero la creación del tipo de datos como objeto y luego la creación de la tabla. Como podemos ver estamos programando para aprender a como insertar dato de tipo objeto en la base de datos de Oracle.
Ahora estamos en capacidad de hacer la grabación de los datos, pero lo ideal es probar que nuestra base de datos, funciona ejecutando la sentencia SQL que luego vamos a utilizar en el programa.
Evidentemente, hemos hecho eso por adelantado y de aquí que la clase grabarBD, ya tenga una sentencia SQL que funciona, pero la misma fue probada previamente como vamos a verlo en este momento.
Volvemos al Área de trabajo Generador de consultas del Developer y allí probamos la sentencia que deseemos.
Primero vamos acceder a la tabla que recién creamos, la tabla AGENDA
Para ver que contiene TIPO_DATOS, pues vamos a tipos en la columna izquierda que esta debajo de las tablas
Ya tenemos la tabla y tipo objeto creados, en la base de datos.
Vamos ahora muestro IDE (NetBeans, Eclipse...) a crear una clase imprescindible para la conexión a la base de datos oracle. Debemos recordar que cada base de datos funciona de forma distinta, con lo cual debemos tener cada versión las base de datos en una o varias clases. Lo mas apropiado es usar una sola clase, pero ese depende del estilo de programación que consideremos mas adecuado cada uno.
Con el proyecto creado y código de las ventanas copiado, tendremos algo igual o similar a la siguiente:
Lo mejor es ver que todo funciona, aunque hay algunas cosas que falta por implementar. Eso lo haremos aquí, porque son datos que necesitamos con respecto al ejemplo que vamos a realizar.
Para probar el código nos ubicamos en la clase Inicio y con el botón derecho pulsamos sobre la opción Run File, para correr el programa.
Debemos obtener un resultado igual o similar a lo siguiente:
Si pulsamos sobre registrar debe saltar la siguiente ventana:
Si compruebas veras que los botones Salir y Cancelar no hace nada y que Guardar simplemente lanza un mensaje por consola que te informa de un proceso que se debe realizar de grabación de datos. Este último es el que vamos a implementar.
Ahora si vamos a codificar nuestra clase OracleDB, que no es otra cosa sino la preparación del servidor Oracle para conectarse con nuestro programa en Java.
Para ello vamos a crear un nuevo paquete que llamaremos persistencia, nos ubicamos en la carpeta Source Packages del proyecto, pulsamos botón derecho, seleccionamos New y luego pulsamos sobre la opción Java Package.
Nos abre la siguiente ventana en donde escribimos como nombre del package persistencia y pulsamos sobre Finish.
Luego sobre el nuevo paquete persistencia recién creado que estará de un color gris oscuro, pulsamos nuevamente el botón derecho del ratón, seleccionamos New y luego pulsamos sobre la opción Java Class
Escribimos como nombre de la clase OracleDB y pulsamos Finish.
Se nos abre la siguiente pantalla:
Aquí es donde vamos a escribir el siguiente código, para la clase OracleDB, pero antes de que lo escribamos, quiero señalar que la sentencia import oracle.jdbc.pool.OracleDataSource va a generar un error, que no va a desaparecer sino hasta cuando importemos el driver correspondiente desde Oracle, luego lo veremos, por ahora este es el código a escribir:
Ahora este código debe estar generando un error o mas errores si estás utilizando un IDE (NetBeans,Eclipse...) que sea capaz de detectar errores y deficiencias en el código escrito de JAVA. La razón como dije antes es la falta de la librería correspondiente al driver de Oracle. Tu código debe tener un aspecto igual o similar a las dos siguientes:
En nuestro caso escribimos en Google: driver oracle express, que es la base de datos que estamos utilizando y pulsamos sobre la versión de Oracle que estemos utilizando. En este caso la base de datos que tenemos instalada es la 11g, que es la primera opción que nos da el buscador, así que pulsamos sobre esa opción.
En ella como vemos tenemos que aceptar el License Agreement y luego pulsar sobre el driver ojdbc6.jar como indican las flechas.
Lo anterior provoca que la web pida que se valide el usuario que va a descargar el driver, así que pedirá que se le indique el nombre del usuario inscrito en Oracle y la contraseña. Si no tienes cuenta en Oracle debes inscribirte.
Una vez validado el usuario saltará la siguiente pantalla que pide donde descargar el driver o simplemente se iniciara la descarga que normalmente será descargada en la carpeta de Descargas del sistema operativo sea Windows o Linux.
Una vez descargado el driver procedemos a instalarlo en nuestro proyecto y para ello vamos al IDE (NetBeans, Eclipse...), nos ubicamos con el ratón sobre Libraries como indica la imagen y pulsamos el botón del derecho del mismo. Esto abre el menú contextual y cual vamos a escoger la opción Add JAR/Folder pulsando sobre ella con el ratón.
Vemos aquí en la imagen cuando se añade el driver, como desaparecen los errores, antes indicados.
OracleDataSource es una clase que está definida en la librería que se descarga desde Oracle y dentro de esa clase está todo el código necesario para que Java se pueda conectar a la base de datos de Oracle, y lo único que necesita para funcionar es que le suministremos algunos datos, para poder ubicar el servidor de la base de datos y conectarse al servidor. Los datos necesarios son la URL, el usuario y la contraseña, que ya debemos tener previamente porque ya debe estar instalado el servidor Oracle y tener una base definida con un usuario y una contraseña.
Al crear el objeto ods, podemos utilizar los métodos set necesarios para insertar estos datos en el objeto que son básicamente setURL, setUser y setPassword.
El URL es importante ya que indica donde esta instalado el servidor y en que puerto. Veamos su estructura:
"jdbc:oracle:thin:@//127.0.0.1:"+1521+"/"+"xe"
La parte jdbc:oracle:thin:@// es siempre la misma, no va ha cambiar.
La siguiente parte es simplemente la ip del PC donde está instalado el servidor. Vemos aqui 127.0.0.1 porque es la ip por defecto el servidor y significa que está instalado en el mismo equipo donde está JAVA instalado.
La siguiente parte es el número de puerto asignado al servidor, que en nuestro caso es el utilizado por defecto por Oracle al instalarlo. Si cambias este número al instalar el servidor Oracle Express, deberas usar ese número en lugar del 1521.
Por ultimo, la parte final es el espacio de nombres en donde se trabajara la base datos. En Oracle Express si utiliza por defecto "xe".
Si quieres ver los métodos que tiene la clase, escribe el objeto y luego un punto y esperas.
Ejemplo ods. y la ayuda del IDE (NetBeans, Eclipse), mostrará todos los métodos que puedes utilizar de la clase.
Continuemos ahora con la siguiente clase que ya nos mete en materia, o sea, grabar en la base de datos.
Vamos a crear la clase grabarBD, para ello vamos al paquete persistencia y volvemos a pulsar el botón derecho del ratón sobre el mismo, y cuando aparezca el menú contextual, ponemos el puntero del ratón sobre New, y luego seleccionamos la opción Java Class y pulsamos sobre ella:
Se abre un a ventana en la cual escribimos grabarBD en la casilla Class Name y pulsamos sobre el botón Finish
Se nos abre una pestaña en el área de trabajo del IDE (NetBeans, Eclipse..) con el nombre de la clase, como la siguiente:
Ahora escribimos el siguiente código dentro en la clase:
Aquí básicamente importamos las librerías PreparedStatement y SQLException. PreparedStatement es la clase que combinada con la nuestra Clase OracleDB mediante el objeto db (que inicia la conexión con la base de datos) se creará el objeto ps mostrado en el código y que va a contener la sentencia sql, a la cual va añadir los valores de los campos utilizando los métodos los métodos set según el tipo de datos del campo, que formaran el registro que va ser insertado luego en la base de datos.
La ejecución de la inserción se logra mediante el método ps.executeUpdate. Luego tenemos la clausula finally en el try catch, para cerrar el objeto ps mediante ps.close() y db.cerrarDB() que cierra la conexión con la base de datos.
SQLException, maneja los errores de excepción que pueda generar el SQL.
Ya con esto estamos listos para añadir a nuestro código que crean las ventanas, aquellas sentencias necesarias para poder guardar los datos que contengan sus formularios.
Como sabemos nuestras ventanas son muy modestas, porque en la realidad solo la ventana del Modulo Registros tiene un formulario y apenas hemos programado en ella dos campos.
Pero la idea es programar por partes, lo cual hace mas fácil de manejar y controlar que todo vaya funcionando como se espera e ir completando todo el proceso, de tal manera de probar todos los pasos hasta el final, para luego complicar el código con mas campos.
cual es el objetivo? Muy sencillo, hacer todo el camino que van a seguir los datos desde que se inicia el programa con el menú hasta que se pulsa el botón grabar y cerrar luego el programa.
Vamos a ver como para entender mejor lo que buscamos hacer.
Ahora pongamos la atención en el código de la ventana Registro. Si vamos hasta el final del código, veremos algo similar a lo siguiente:
Como vemos, el método que captura el momento en que se pulsa sobre el botón Guardar, ejecuta la sentencia que lanza un mensaje a la consola y luego simplemente se cierra la ventana de Registro y se devuelve el control a la ventana Menu.
Pues justamente aquí vamos a insertar el siguiente código:
OracleDB conn=new OracleDB();
if(conn!=null){
System.out.println("Base datos conectada "+conn);
String dat1=txtNombres.getText();
String dat2=txtApellidos.getText();
String dat3="correo@email.com";
String dat4="+34912680071";
if(grabarBD.grabandoBD(dat1,dat2,dat3,dat4)){
System.out.println("\nGrabación echa ok");
}
}
Lo escribimos y nuestra sección debe quedar similar a la siguiente (la zona azul simplemente se resaltó para diferenciar lo que se agregó):
Si nos fijamos, tenemos que estamos guardando los datos de los campos del formulario txtNombres y txtApellidos, pero que adicionalmente hemos añadido nos datos más adicionales y que hemos escrito el contenido como String.
Estos lo hacemos porque vamos a probar adicionalmente que nuestra sentencia SQL que vamos a enviar a la base de datos funciona.
Evidentemente, es prácticamente obligatorio probar antes cualquier en el Servidor de la base de datos, ya sea con el Oracle SQL Developer (por algo se llama así), así como a modo de practica vayamos al SQL Developer y escribamos la sentencia:
insert into AGENDA values('Perico','DelosPalotes', TIPO_DATOS('perico@enterprise.com','+34658457890'));
Para comprobar los datos pasados, vamos a la tabla AGENDA y luego pulsamos sobre datos y luego refrescar, para que nos muestre lo que se grabó.
Nótese que TIPO_DATOS, no muestra su contenido. Eso lo solucionamos pulsando dos veces botón derecho del ratón sobre el campo y inmediatamente nos salta una ventana y el campo también muestra algo de la data que contiene.
Vemos en la ventana como el campo esta representado como objeto, es decir, el nombre del objeto y entre paréntesis, los atributos separados por comas. Fíjese así mismo como el campo muestra parcialmente el ultimo datos y al lado esta un lápiz simbolizando que esta en modo de edición. Si estiramos el campo hacia la derecha veremos como entonce aparece la data completa en el campo y entonces para que salte el ventana tendremos que pulsar sobre el lápiz.
Ahora vamos a ver la sentencia SQL que en realidad hemos escrito, para pasar los datos desde JAVA.
Vemos que los datos han sido sustituidos por interrogantes.La explicación para mi es muy sencilla, los tipos de datos son manejados internamente de forma diferente por JAVA y por Oracle. Hay que recordar que para JAVA el tipo de datos String es en realidad tratado como un objeto y no una cadenas de caracteres como lo hacen otros lenguajes.
Si tratamos de usar directamente el dato en lugar de usar los interrogantes, la ejecución de la sentencia por medio de ps.executeUpdate(), se produce un error de excepción. Esto lo podemos probar si así lo deseamos.
Eso explica el porque existe la clase PreparedStatement, ya que con su objeto ps vamos añadiendo los datos pasados, en un orden especifico que coincide con el orden en nuestra base de datos y que ademas debe de usar el tipo correspondiente para hacer la transformación que sea necesaria.
En el ejemplo, solo usamos el tipo de dato String y Object, pero podemos escribir ps.(recordar que es el objeto creado) y veremos muchas mas como vemos en la siguiente imagen:
También vemos que los datos que corresponden a un objeto definido en la base datos, estos deben ser indicados entre paréntesis, indicando de esta forma que esos datos forman parte del objeto.
Ahora es tiempo de correr el programa y probarlo para ver que sucede. Vamos a la clase inicio y pulsamos dentro del cuerpo de la clase el botón derecho del ratón y en el menú contextual pulsamos Run File.
Aparece la ventana Menu, pulsamos sobre la única opción Registrar
Y aparece la ventana de Registro. Aquí vamos a rellenar el formulario con nombre y apellidos que deseemos y luego pulsamos en Guardar.
Veremos como volvemos a la ventana Menu y que por consola el programas nos lanza los mensajes.
Ahora, si abrimos el SQL Developer y vamos a la tabla AGENDA y ver los datos veremos lo siguiente:
Vemos como se ha añadió correctamente el registro que acabamos de hacer desde nuestro programa. Evidentemente la parte TIPO_DATOS tendrá los mismos datos que vimos antes, ya que no hemos cambiado nada.
Se sigues probando el programa notarás que solo algunos botones funcionan y otros no. Como se dijo al principio el programa no está ni mucho menos terminado.
Podemos decir que tenemos un prototipo y que ha superado la pruebas que le hemos hecho en su función principal, que es operar entre ventanas, rellenar un formulario y grabar datos en una base de datos Oracle.
Ahora podemos completar algunas cosas para que el programa funcione mas coherentemente, como es que todos los botones hagan algo y añadir nuevos campos y inclusive.
Pero eso es tema otro tutorial, el cual los trataremos en un enlace que se colocara aquí.
Si alguien tiene alguna duda, pregunta, etc... sobre lo que hemos visto hasta este momento, por favor, escriba el mismo en un comentario.
Como siempre si detectas algún error u omisión, o hacer una observación importante, por favor deja un comentario, para corregir, cambiar los conceptos que sean necesarios. Muchas Gracias por visitar mi blog.
No hay comentarios:
Publicar un comentario
Tu comentario puede ser muy útil, asi que no dudes en dejar el tuyo.
Si es relacionado con algún problema, error. etc. trata de ser muy explicito, y detallar el problema y las circunstancias en las que se produjeron. Si lanza algún error trata de copiarlo y pegarlo junto con una descripción del problema, ya que a veces los errores del sistema no son en realidad la causa del problema.