Está en la página 1de 25

Three Headed Monkey

Manual de creacin de Interfaces de Usuario en Netbeans


Versin 3.0
Jess Omar lvarez Mrquez ngel Antonio Muoz Berbel

Sbado, 15 de Mayo de 2010

Manual de creacin de Interfaces de Usuario en 2010 Netbeans


Contenido
Introduccin .................................................................................................................. 2 Propsito del documento ........................................................................................... 2 Programas necesarios .............................................................................................. 2 Preparacin del Proyecto .............................................................................................. 3 Interfaz de GUI Builder ................................................................................................. 5 Zona de diseo ......................................................................................................... 5 Paleta ........................................................................................................................ 6 Propiedades de elementos ........................................................................................ 6 Inspector ................................................................................................................... 6 Nociones bsicas de diseo ......................................................................................... 7 Aadir un elemento ................................................................................................... 7 Modificar atributos ..................................................................................................... 7 Anclaje ...................................................................................................................... 8 Adicin de Imgenes al Formulario ............................................................................... 9 Crear una interfaz que interacte con una BD ............................................................ 12 Creacin del proyecto ............................................................................................. 12 Botones Personalizados ............................................................................................. 14 Navegar entre JFrames mostrando nicamente un JFrame........................................ 16 Modelo vista controlador (MVC) en JAVA ................................................................... 17 Unidades de Persistencia ........................................................................................... 19 Conceptos Bsicos.................................................................................................. 19 Conexin con al BD................................................................................................. 20 Creacin de Entity Manager .................................................................................... 21 Adicin de Entidades al proyecto ............................................................................ 22 Trabajando con Entidades....................................................................................... 23 Consulta .............................................................................................................. 23 Modificacin o aadir ........................................................................................... 23

Manual de creacin de Interfaces de Usuario en 2010 Netbeans Introduccin


Propsito del documento
Este manual est pensado para ser utilizado como gua de referencia a la hora de crear interfaces de usuario en JAVA utilizando la herramienta GUI Builder que viene incluida en NetBeans. Los mtodos aqu descritos no son ni mucho menos exhaustivos, pues lo que se pretende es dar a conocer unas pautas bsicas que sirvan como base de la creacin de interfaces simples, dejando al interesado la tarea de investigar en mayor profundidad a la hora de utilizar tcnicas ms avanzadas.

Programas necesarios
Para poder llevar a cabo lo descrito en este manual slo ser necesario bajarse NetBeans de la siguiente pgina: http://netbeans.org/index.html En la fecha de creacin de este documento, la ltima versin disponible es la 6.8, aunque segn la propia pgina de descarga se pueden conseguir los mismos resultados desde la 6.5.

Manual de creacin de Interfaces de Usuario en 2010 Netbeans Preparacin del Proyecto


Para poder utilizar GUI Builder en un proyecto, ste se debe crear de una manera especfica, siguiendo los pasos que se detallan a continuacin: 1. Elegimos File > New Project o pulsamos directamente en el botn de New Project en la barra de herramientas. 2. Seleccionamos la carpeta que pone Java, y de ah la opcin que dice Java Application. Pulsamos Next.

3. Rellenamos con los datos deseados el formulario, pero dejando marcadas las casillas Create Main Class y Set as Main project. Pulsamos Finish.

Manual de creacin de Interfaces de Usuario en 2010 Netbeans


4. Ahora tenemos que crear el archivo que contendr la GUI. Para ello pulsamos con el botn derecho sobre el icono del proyecto que hemos creado y elegimos New > JFrame Form.

5. Rellenamos el formulario ponindole el nombre que deseemos y el paquete que contendr la interfaz. Pulsamos Finish.

6. Se nos debera abrir el archivo que hemos creado, mostrando la interfaz del GUI Builder.

Manual de creacin de Interfaces de Usuario en 2010 Netbeans Interfaz de GUI Builder

Zona de diseo
Esta es la zona que est contenida en el cuadrado rojo y que en un comienzo tan slo contendr un rectngulo vaco. Sirve para colocar los distintos elementos de la interfaz que estemos creando, cambiando sus parmetros (color, tamao, etc) y, en definitiva, amoldndolos a los que queramos conseguir. En la parte superior tiene una barra de herramientas con diferentes elementos: 1. Source Design: estos dos botones nos permiten cambiar entre modo de vista de cdigo y grfico. En el Grfico podremos aadir los distintos elementos de la interfaz, mientras que en el de vista de cdigo les daremos funcionalidad. Ntese que en la parte de cdigo aparecern zonas sombreadas de azul, lo que significar que ese trozo de cdigo slo puede ser editado mediante el GUI Builder y no de forma manual. 2. En esta parte tenemos 3 botones muy tiles. a. Modo Seleccin: nos permite seleccionar los elementos de la interfaz y moverlos o cambiar su tamao. b. Modo Conexin: nos deja definir la relacin entre dos elementos de la interfaz, sin tener que entrar en la vista de cdigo. c. Vista previa: aparece una interfaz preliminar para que podamos evaluar su funcionalidad antes de compilar. 3. Botones de autoajuste: con ellos podemos alinear los elementos de la interfaz de forma automtica. 4. Pautas de autoredimensionamiento: indican si al ampliar la ventana principal de la interfaz los elementos que contenga se redimensionan con ella o no.

Manual de creacin de Interfaces de Usuario en 2010 Netbeans


Paleta
Es la parte que contenida en el rectngulo verde. En ella podremos elegir qu nuevo elemento queremos aadir al diseo de la interfaz y colocarlo segn nuestras preferencias. Contiene varios apartados diferenciados: Swing Containers: en esta parte se encuentran los elementos que slo sirven para contener a otros, pero que por s mismos no hacen nada. Ejemplos de ello son las barras de herramientas o los mens tabulares. Si queremos que contengan algo, debemos aadirlo en su interior. Swing Controls: aqu se almacenan los elementos mediante los que se crea o almacena informacin y rdenes, y que pueden estar contenidos en los descritos anteriormente o no. Como ejemplos, tenemos botones, etiquetas, barras deslizantes o tablas. Swing Menus: aqu hay distintos elementos que ayudan a la creacin de barras de mens, aadiendo los mens propiamente dichos y sus elementos. Swing Windows: en esta seccin tenemos una serie de ventanas que aparecen como dilogos, y que son tiles a la hora de crear eventos de advertencia y similares. AWP: estos elementos son similares a los visto con anterioridad en Swing Containers y Swing Controls, pero con un diseo anticuado y simple, pues AWP es una biblioteca de clases para el desarrollo de interfaces anterior a Swing, la cual no es ni ms ni menos que una extensin de la primera. Java Persistence: en este ltimo apartado se hallan los elementos correspondientes a consultas sobre bases de datos.

Propiedades de elementos
Es la parte que est en el recuadro azul. Aqu se mostrarn las propiedades del elemento que tengamos seleccionado en ese momento, permitiendo a su vez su alteracin.

Inspector
A parte de las zonas anteriores, existe una zona ms, en la esquina inferior izquierda, llamada Inspector. Es aqu donde encontramos un resumen en forma de rbol de todos los elementos que hemos ido aadiendo a la interfaz, pudiendo adems seleccionarlos directamente o cambiar sus propiedades pinchando en opcin adecuada al hacer clic con el botn derecho del ratn sobre ellos, sin necesidad de buscarlos en la propia interfaz.

Manual de creacin de Interfaces de Usuario en 2010 Netbeans Nociones bsicas de diseo


A la hora de disear en GUI Builder, hay 3 pasos que son claves para dar forma a la interfaz que se desea crear: aadir, modificar propiedades y definir el anclaje.

Aadir un elemento
Basta con seleccionar el que queramos y arrstralo hasta la zona de diseo. En un principio suele ser mejor insertar primero los elementos contenedores, tales como paneles o mens, para luego ir aadiendo los dems. En el ejemplo hemos aadido 2 paneles:

*Nota: ahora mismo se ven ambos paneles porque estn seleccionados, pero de no ser as no se vera nada, pues los paneles por defecto no traen borde.

Modificar atributos
Lo primero que debemos hacer es redimensionarlos hasta estar conformes con el resultado. Despus, seleccionamos el que queramos y en la zona de propiedades los modificamos a nuestro gusto. En este caso, hemos aadido un borde con titulo a las paletas, y de camino unos cuando elementos ms, como botones o eqtiquetas:

Manual de creacin de Interfaces de Usuario en 2010 Netbeans


Para llevar a cabo su colocacin son muy tiles las prcticas lneas que GUI Builder nos muestra para ayudarnos a conocer la distancia entre elementos. Pero estas lneas tienen otra utilidad: relacionar los elementos con el tamao de la ventana de forma automtica, lo que nos lleva al siguiente punto.

Anclaje
EL anclaje se refiere a la capacidad de un elemento de adaptarse al tamao de la ventana o del objeto que la contiene (algo as como una interfaz dinmica en cuanto a tamao). Se puede realizar de forma automtica si acercamos un el elemento hasta el borde de la tabla de diseo o del contenedor, cuando aparece una lnea punteada (imagen anterior). Para hacerlo de forma manual simplemente basta con seleccionar o deseleccionar las opciones que vimos en la zona de diseo nmero 4, y que relacionan contenedor con contenido en ancho, alto, o ambos a la vez. Vase la diferencia en la siguiente imagen:

Se puede comprobar cmo el Panel 1 tiene definida la propiedad de autorredimensionarse con el ancho de la ventana, mientras que el Panel 2 queda intacto sea cual sea. Del mismo modo, jTectField1 est relacionado con Panel 1, puesto que si no lo estuviera ocurrira lo que se en la siguiente imagen.

Manual de creacin de Interfaces de Usuario en 2010 Netbeans

Otro tipo de anclaje es el que se da entre un elemento y otro al mismo nivel (ninguno contiene al otro), que hace que se conserve la posicin relativa entre ambos(como pasa con el Botn del ejemplo, que conserva la posicin con respecto al borde). Esto se consigue usando las guas que aparecen mientras se arrastra un objeto: si lo ponemos a la distancia de una de las lneas que aparecen en otro elemento, esa distancia no se alterar nunca:

Adicin de Imgenes al Formulario


La opcin de aadir una imagen en si misma no est presente, pero se puede conseguir tras realizar una serie de pasos: 1. Aadimos una etiqueta al proyecto (aunque parezca raro, esta etiqueta ser la imgagen):

Manual de creacin de Interfaces de Usuario en 2010 Netbeans


2. Creamos un paquete especfico para guardar las imgenes

3. Seleccionamos la etiqueta que pusimos y elegimos Properties de las opciones que aparecen al pulsar con el botn secundario del ratn. Dentro de las propiedades, le damos a la parte del la propiedad icon:

4. Seleccionamos Import to Project, en donde buscamos la imagen que deseamos y despus en donde queremos guardarla, tras lo cual la imagen aparece en el mismo recuadro que la etiqueta:

10

Manual de creacin de Interfaces de Usuario en 2010 Netbeans

5. Slo queda modificar el nombre de la etiqueta para que ste no aparezca, si es lo que deseamos.

6. Ya tenemos una imagen dentro del formulario, la cual quedar guardada en el .jar resultante. Qu bien, eh?

11

Manual de creacin de Interfaces de Usuario en 2010 Netbeans Crear una interfaz que interacte con una BD
Creacin del proyecto
Para crear una interfaz que sea capaz de visualizar y modificar campos de una base de datos existente, necesitamos seguir los siguientes pasos: 1. Pulsamos File>New Project. 2. En el wizard que aparece, expandimos Java, y dentro de l seleccionamos Java Desktop Application. Pulsamos Next. 3. En esta ventana, debemos seleccionar rellenar los campos con el nombre y el directorio del proyecto, pero adems es necesario seleccionar la opcin Database Application y marcar Set as Main Project. Tras ello, pulsamos Next. 4. En este nuevo formulario, tenderemos que seleccionar la BD a la que nos conectaremos. Si es la primera vez, tendremos que elegir New Database Conection y rellenar los datos de la conexin. En el ejemplo que se ve, se han usado los datos para conectares a una de las bases de datos que Xammp trae por defecto en MySQL.

12

Manual de creacin de Interfaces de Usuario en 2010 Netbeans

5. Por ltimo aparecer otro formulario que nos preguntar cmo queremos visualizar las columnas de las tablas. Elegimos la opcin que queramos y finalizamos. Llegados a este punto, debera haberse creado una interfaz con un formulario que realiza las tareas ms sencillas sobre nuestra BD: consultar, aadir y borrar. A partir de aqu, le podemos aadir la funcionalidad y el formato que deseemos, como barras deslizantes para dar valor a los campos.

13

Manual de creacin de Interfaces de Usuario en 2010 Netbeans Botones Personalizados


En el caso de que queramos personalizar los botones de nuestra interfaz, se pueden modificar los que trae por defecto el GUI Builder, siempre y cuando contemos con al menos 2 imgenes del botn que queremos obtener, una para indicar su estado normal, y otra para cuando sea presionado:

Ahora lo que hacemos es aadir un nuevo botn al formulario y entrar en sus propiedades, para modificar los siguientes campos del mismo modo en el que aadamos una imagen a una etiqueta en el apartado anterior: Icon: en donde metemos la imagen del botn en estado normal. Pressed Icon: aqu pondremos la imagen del botn presionado

Text: borramos lo que ponga (jButton por defecto). Border: seleccionamos No Border. Content Area Filled: desmarcamos esta opcin. Cursor: si deseamos que al poner el cursor encima, ste cambie, seleccionaremos el cursor que deseemos que aparezca en esta parte. FocusPainted: desmarcamos esta opcin tambin.

Haciendo todo esto, obtendremos los resultados que se observan en la pgina siguiente.

14

Manual de creacin de Interfaces de Usuario en 2010 Netbeans

15

Manual de creacin de Interfaces de Usuario en 2010 Netbeans Navegar entre JFrames mostrando nicamente un JFrame
Si tenemos una aplicacin compuesta por varios JFrames, por ejemplo un JFrame inicial que represente un men, y varios JFrames para cada una de las opciones del men, lo ms lgico es que solo se muestre un JFrame al usuario, en lugar de ir acumulando JFrames cada vez que se seleccione un opcin. Para ello utilizaremos la funcin setVisible de la clase JFrame. As supongamos que tenemos el siguiente JFrame al que llamaremos Inicio:

Dentro del JFrame inicio se debe crear un JFrame por cada posible opcin, supongamos que el JFrame que se mostrar si seleccionamos la opcin Consultar Stock de Bebidas se llama Bebida. Lo que debemos hacer es colocar el siguiente cdigo dentro de la accin asignada al botn Consultar Stock de Bebidas: this.setVisible(false); Bebida.setVisible(true); En primer lugar indicamos que se deje de mostrar el JFrame inicio y que se muestre el JFrame Bebida. Tras esto puede surgir una pregunta Cmo podemos volver a mostrar el men inicial desde el segundo JFrame? Una forma muy sencilla de hacer esto es crear dentro del JFrame Bebida una variable que almacene el JFrame padre, en este caso Inicio. De esta forma lo nico que

16

Manual de creacin de Interfaces de Usuario en 2010 Netbeans


tendramos que hacer dentro de Bebida para la opcin de volver al men principal sera: this.setVisible(false); padre.setVisible(true); Podemos indicar a un JFrame cul es su padre pasndolo como parmetro al constructor del hijo.

Modelo vista controlador (MVC) en JAVA


La arquitectura modelo vista controlador es una de las arquitecturas ms usadas dentro de la programacin de aplicaciones con interfaces grficas. Java permite implementar una aplicacin basada en esta arquitectura gracias a la interfaz Observer y a la case Observable. Observer: Es cualquier objeto que desee ser notificado cuando el estado de otro objeto sea alterado. Observable: Es cualquier objeto cuyo estado puede representar inters y sobre el cual otro objeto ha demostrado ese inters As para implementar el modelo utilizaremos la clase Observable, mientras que para la vista utilizaremos la interfaz Observer. A continuacin comentaremos brevementa las funciones ms importantes de Observer y Observable:

Observer
public void update( Observableobs,Object obj )

Llamada cuando se produce un cambio en el estado de un objeto Observable que est siendo observado.

Observable
public void addObserver( Observer obs )

Aade un observador a la lista interna de observadores


protected void setChanged()

Levanta el flag interno que indica que el Observable ha cambiado de estado

public void notifyObservers()

Comprueba el flag interno para ver si el Observable ha cambiado de estado y lo notifica a todos los observadores

17

Manual de creacin de Interfaces de Usuario en 2010 Netbeans


Una vez conocemos las funciones que usaremos podemos definir los pasos para implementar una aplicacin siguiendo la arquitectura MVC: 1. En primer lugar haremos que clase encargada de la vista, por ejemplo un JFrame implemente la interfaz Observer. Ejemplo: public class vistaBebidas extends javax.swing.JFrame implements Observer { Esto nos obligar a implementar el mtodo update dentro de la clase vista. Dentro de este mtodo colocaremos el cdigo que se ejecutar cuando sucede un cambio dentro de algn objeto Observable que este siendo observado: public class VistaBebidas extends javax.swing.JFrame implements Observer { public void update(Observable o, Object arg) { //Actualizamos lista de bebidas } Como puede verse en el ejemplo anterior, el metodo update recibe el objeto de la clase Observable que notific el cambio, de esta forma podramos distinguir, en caso de estar observando varios objetos, qu objeto en concreto fue el que cambio su estado, y actuar en consecuencia. 2. En segundo lugar haremos que la clase encargada del modelo extienda la clase Observable. Ejemplo: public class GestorStock extends Observable { . En el ejemplo anterior vemos como podramos querer tener una clase que se encargue de gestionar el Stock. 3. Aadir nuestra clase encargada de la vista a la lista de observadores asociada al Observable encargado del modelo. Ejemplo: VistaBebidas vistaBeb = new VistaBebidas (); GestorStock GS = new GestorStock(); GS.addObserver(vistaBeb); Tras esto, siempre que el objeto GS de la clase que GestorStock notifique un cambio, el objeto vistaBeb invocar a su mtodo update.

18

Manual de creacin de Interfaces de Usuario en 2010 Netbeans


4. Notificar un cambio en el modelo. Como hemos comentado en el paso anterior, siempre que un objeto que extienda a la clase Observable notifique un cambio, los observables que se encuentres observndolo (fueron aadidos con addObserver) invocaran el mtodo update. Pero como puede un objeto de la clase observable notificar un cambio? Para ello usaremos el siguiente cdigo: public class GestorStock extends Observable { Public void modificarStock(){ //hacemos los cambios necesarios en el //stock //notificamos a los observers setChanged(); //levantamos el flag //de cambio notifyObservers(); //notificamos }

Unidades de Persistencia
Conceptos Bsicos
Cuando se trabaja con bases de datos, debemos antes conocer 3 conceptos bsicos: Unidades de Persistencia: Las unidades de persistencia contienen los datos necesarios para realizar una conexin con la BD, y estn descritas en un fichero xml, dentro del paquete llamado META-INF. Entity Manager: Para poder modificar la base de datos con la que conectamos, se hace necesario el uso de EntityManagers, un tipo especial de clase que nos permite consultar y cambiar la BD a travs de nuestras propias entidades. Entidad: Son clases marcadas con @Entity. Las entidades son necesarias para trabajar con los datos que se obtienen de los EntityManager, pues se corresponden con las tablas que se almacenan en la BD, y cada nueva instancia de una entidad es una fila de la tabla a la que representa. Tendremos que tener una entidad para cada tabla que queramos poder consultar o modificar.

Una vez visto esto, lo siguiente que debemos saber es el modo de configurar la conexin y cmo trabajar con ella, temas que se tratarn en los siguientes apartados.

19

Manual de creacin de Interfaces de Usuario en 2010 Netbeans


Conexin con al BD
Para llevar a cabo la conexin hay distinto mtodos. En el apartado anterior Crear una interfaz que interacte con una Base de Datos vimos un mtodo sencillo y muy bsico para lograr esto. Siguiendo esos pasos, obtenemos en el proyecto un paquete llamado META-INF, con un fichero xml, el cual contiene la informacin de la Unidad de Persistencia que se crea automticamente. Si por el contrario, queremos crearlo de forma manual, deberemos seguir el siguiente mtodo: 1. Pinchamos con el botn secundario sobre uno de los paquetes existentes o sobre el propio proyecto y seleccionamos: New Persistence Unit. En caso de no aparecer, elegiremos en su lugar Other en donde nos desplazaremos hasta la carpeta Persistence y ah encontraremos lo que buscamos.

2. Se nos pedir despus que rellenemos un formulario con el nombre de la unidad, la librera de persistencia a usar (nosotros elegiremos toplink) y la conexin de la BD, que se realiza de forma similar a como se explic en el punto Crear una interfaz que interacte con una Base de Datos.

3. Una vez hecho esto, pulsamos finalizar, y vemos que aparecer una nueva carpeta llamada META-INF:

20

Manual de creacin de Interfaces de Usuario en 2010 Netbeans


Siguiendo estos pasos, ya tenemos configurada la unidad de persistencia. Pulsando en persistence.xml se nos mostrarn todas las unidades de persistencia que tenemos en este momento, pudiendo aadir nuevas de forma sencilla simplemente pulsando el botn add, caracterstica que nos permite a su vez tener varias conexiones a varias bases de datos en un mismo momento.

Creacin de Entity Manager


Existen 2 modos de crear un manager de entidades, una visual utilizando el Gui Builder y otra mediante cdigo. Mediante cdigo, debemos en un principio declarar la variable:

private javax.persistence.EntityManager entityManagerDePrueba;

Para despus inicializarla como sigue: entityManagerDePrueba = java.beans.Beans.isDesignTime() ? null : javax.persistence.Persistence.createEntityManagerFactory("UnidadDePrue ba").createEntityManager(); De forma visual, simplemente arrastraremos desde la paleta del Gui Builder el icono Entity Manager (en la parte de Java Persistence) hasta el interior de la interfaz. En la propia interfaz no aparecer nada, pero si nos fijamos, en el Inspector tendremos un nuevo elemento, al cual le podemos cambiar el nombre y modificar sus propiedades para que se conecte a la unidad de persistencia (o sase, a la BD) que deseemos.

Ahora ya tenemos un nexo de unin entre nuestras entidades y las tablas de la base de datos, pero espera un momento, no tenemos entidades!

21

Manual de creacin de Interfaces de Usuario en 2010 Netbeans


Adicin de Entidades al proyecto
Hacer entidades puede ser una trabajo tedioso y largo, por ellos demos gracias de que el entorno con el que trabajamos nos lo pone realmente fcil, con tan solo un par de clics. Veamos cmo se hace: 1. Botn secundario sobre el paquete en el que queramos generar la base de datos, para despus seleccionar New Entity Classes from Database. Si no aparece, toca buscarlo en Other Persistence

2. Aparecer una ventana, en donde elegiremos la conexin de la DB que deseemos. Tras ello, se llenar el campo blanco de la izquierda con las tablas de la BD, dejndonos seleccionar las que queramos aadir como entidades al proyecto.

3. Por ltimo, pulsando en next y cambiando las opciones que deseemos (las que vienen por defecto no dan ningn tipo de problema), las tablas sern aadidas como nuevas entidades. (*nota: por algn motivo, cuando se seleccionan ms de una tabla a la vez para ser aadida, no crea bien las entidades, sino que las deja en blanco. Por ello es mejor aadirlas de una en una).

22

Manual de creacin de Interfaces de Usuario en 2010 Netbeans


Trabajando con Entidades
Llegados a este punto slo nos queda hacer uso de todo lo que hemos hecho con anterioridad. Bsicamente sern 2 las operaciones que podremos llevar a cavo: consultar datos de la base de datos e introducirlos o modificarlos. Consulta Para realizar una consulta, basta con escribir la una instruccin como la que sigue (en la que se est obteniendo ): List <Pedidoplatos> PP = entityManagerDePrueba.createNativeQuery ("SELECT * FROM pedidoplatos", Pedidoplatos.class).getResultList() Analicmosla: List <Pedidoplatos> PP Estamos creando una lista donde almacenar el resultado de la consulta, dndole como tipo de la lista el nombre de la entidad que se corresponde con la tabla devuelta. entityManagerDePrueba.createNativeQuery ("SELECT * FROM pedidoplatos", Pedidoplatos.class) Hacemos una consulta en SQL nativo sobre el entity manager que creamos antes, indicndole adems que el tipo que se espera devuelto es Pedidoplatos. Esto nos devolver una variable de tipo Query con los resultados. getResultList() Al utilizar este mtodo, nos aseguramos de que la Query devuelta venga en modo de lista, para poder recogerla en la variable de tipo List creada con aterioridad. Una vez que tenemos la lista es fcil moverse por los resultados, pudiendo incluso asignar un resultado concreto a una instancia de la entidad con la que estamos trabajando. Modificacin o aadir Para modificar o aadir una fila de la BD, hace falta meter el cdigo entre las instrucciones de comienzo y fin de transaccin: entityManagerDePrueba.getTransaction().begin(); entityManagerDePrueba.getTransaction().commit(); Si lo que queremos es modificar un elemento ya existente, lo primero es hacer una instancia de la entidad que describe ese elemento, y despus modificar su correspondiente en la BD con el mtodo merge(intancia de la entidad), el cual buscar la fila en la BD con la misma clave nica que la instancia y la sobrescribir con los cambios. Veamos un ejemplo, en el que se quiere cambiar la cantidad de una bebida.

23

Manual de creacin de Interfaces de Usuario en 2010 Netbeans


//empezamos la transaccion entityManagerDePrueba.getTransaction().begin(); //buscamos el ingrediente a modificar Bebida beb = entityManagerDePrueba.find(Bebida.class, idBebida); //cambiamos la cantidad if(beb != null){ beb.setCantidadActual(15); } //metemos los cambios en la BD entityManagerDePrueba.merge(beb); //terminamos la transaccin confirmando los cambios entityManagerDePrueba.getTransaction().commit(); Por otro lado, si lo que buscamos es aadir un nuevo elemento a la base de datos, en lugar de merge(intancia de la entidad), usaremos persist(intancia de la entidad) como se ve en el siguiente ejemplo, en el que tratamos de aadir una nueva fila de modificarstockbebidas: //empezamos la transaccion entityManagerDePrueba.getTransaction().begin(); //creamos la nueva instancia y metemos sus datos Modificarstockbebidas mod = new Modificarstockbebidas(); mod.setFecha(fecha); mod.setCantidadActual(nuevaCantidad); mod.setIdBebida(idBebida); mod.setMotivo(motivo); mod.setIncremento(incremento); //lo aadimos al entity manager entityManagerDePrueba.persist(mod); //terminamos la transaccin confirmando los cambios entityManagerDePrueba.getTransaction().commit(); Otra funcin que puede resultar de especial ayuda es refresh(intancia de la entidad), que nos permite actualizar los datos que tenemos de la BD con los que estn actualmente en ella. Por ltimo, decir que si las alteraciones de la BD afectan a ms de una ventana del controlador, es oportuno realizar las transacciones en la clase gestora, para que los datos sean convenientemente actualizados en todas.

24