022 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Compilando Proyecto.

Llegado a este punto lo que nos resta es compilar el proyecto y obtener el ejecutable “.jar”. El primer paso es configurar ciertas propiedades del proyecto. En la imagen siguiente se especifican los pasos. (Clic para ampliar imagen).
Ya configurado las propiedades específicas, ahora nos resta compilar el proyecto. Para esto debemos hacer clic derecho sobre la carpeta del proyecto, como en la imagen más arriba y seleccionar “Limpiar y construir”. Si no se han encontrado errores, se crearán las carpetas necesaria y el archivo “.jar”. (Imagen de referencia, clic para ampliar).
Por último, el proyecto completo para descargar. Tomar en cuenta que hay que tener todas las bibliotecas necesarias para trabajar con el proyecto. En relación a la base de datos, tener instalado y configurado el MySQL. Verificar que el “hibernate.cfg” este configurado de forma correcta, principalmente en relación al nombre de base de datos y contraseña.

Clic en la imagen para descargar...

021 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. Creando pantalla principal.

Después de haber diseñado todos los formularios de referencia, movimientos y reportes, debemos de crear un formulario tipo “JFrame” que servirá de pantalla principal o acceso para cada módulo de nuestro sistema. La pantalla principal estará compuesta por una “Barra de Menú” y una “Barra de Herramientas”. El nombre del JFrame será “Principal”. A continuación una imagen con la descripción general del diseño. (Clic sobre la imagen para ampliar).
Imagen con la especificación de cada elemento. Estos elementos como cualquier otro con las que se haya trabajado, se agregan desde la paleta con “arrastrar y soltar” al lugar correspondiente. (Clic sobre la imagen para ampliar).
La “Barra de Menú” está compuesta por los siguientes “Menús”: Archivos, Referenciales, Transacciones, Informes y Ayuda. Cada elemento se agrega arrastrando y soltando al lugar correspondiente desde la paleta y modificando el nombre por defecto del elemento. A su vez cada “menú” tiene sus elementos que se van a desplegar al hacer clic sobre el ella. Una imagen con los elementos desplegados para entender mejor. (Clic sobre la imagen para ampliar).
A continuación vemos una imagen con ciertos métodos agregados en el constructor de formulario “Principal” que hay que tener en cuenta y las importaciones que necesitamos. También hay que tener en presente el “LookAndFeel”, normalmente para que no se deforme el formulario utilizamos el "Windows". (Clic sobre la imagen para ampliar).
Completado la parte del diseño debemos de crear los métodos que nos permitirán ejecutar cada uno de los formularios que hemos creada hasta ahora. Abajo todos los métodos que estaremos utilizando en el formulario “Principal”.
Código Java
    private void llamarVentas(){
//Creamos una instancia del formulario VentaApp en este caso.
//Se le pasan dos parámetros (this, true), el primero indica el formulario padre, en este caso "Principal".
//El segundo si es modal o no.
VentaApp v = new VentaApp(this, true);
//Indicamos que se muestren las opciones "minimizar", "maximizar" y "cerrar"
v.setDefaultCloseOperation(HIDE_ON_CLOSE);
//Indicamos el título del formulario.
v.setTitle("Formulario de Ventas");
//La hacemos visible.
v.setVisible(true);
}
//Los pasos para llamar cada formulario son iguales a la anterior.
private void llamarCompras(){
CompraApp c = new CompraApp(this, true);
c.setDefaultCloseOperation(HIDE_ON_CLOSE);
c.setTitle("Formulario de Compras");
c.setVisible(true);
}

private void llamarTipo(){
TipoApp t = new TipoApp(this, true);
t.setDefaultCloseOperation(HIDE_ON_CLOSE);
t.setTitle("Formulario de Tipos de Artículos");
t.setVisible(true);
}

private void llamarArticulo(){
ArticuloApp a = new ArticuloApp(this, true);
a.setDefaultCloseOperation(HIDE_ON_CLOSE);
a.setTitle("Formulario de Artículos");
a.setVisible(true);
}

private void llamarCliente(){
ClienteApp cl = new ClienteApp(this, true);
cl.setDefaultCloseOperation(HIDE_ON_CLOSE);
cl.setTitle("Formulario de Clientes");
cl.setVisible(true);
}

private void llamarFuncionario(){
FuncionarioApp f = new FuncionarioApp(this, true);
f.setDefaultCloseOperation(HIDE_ON_CLOSE);
f.setTitle("Formulario de Funcionarios");
f.setVisible(true);
}

private void llamarProveedor(){
ProveedorApp p = new ProveedorApp(this, true);
p.setDefaultCloseOperation(HIDE_ON_CLOSE);
p.setTitle("Formulario de Proveedores");
p.setVisible(true);
}

private void llamarReporteVenta(){
ReporteVenta rv = new ReporteVenta(this, true);
rv.setDefaultCloseOperation(HIDE_ON_CLOSE);
rv.setTitle("Reportes de Ventas");
rv.setVisible(true);
}

private void llamarReporteCompra(){
ReporteCompra rc = new ReporteCompra(this, true);
rc.setDefaultCloseOperation(HIDE_ON_CLOSE);
rc.setTitle("Reportes de Compras");
rc.setVisible(true);
}
El siguiente paso es agregar eventos a nuestros “Menús” y “Botones”. El tipo de evento que utilizaremos es el “ActionPerformed”. Los métodos que creamos más arriba, cada una tiene el nombre bien especificado para saber a que formulario llama, por tanto será cuestión de enlazar con cada menú y botón correspondiente. Abajo una imagen de referencia para manejar los eventos y la lista de “Eventos” respectivos.
Código Java
    private void jMenuItem1ActionPerformed(java.awt.event.ActionEvent evt) {                                           
//Evento para menú "Salir"
System.exit(0);
}

private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
llamarVentas();
}

private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
llamarCompras();
}

private void jMenuItem7ActionPerformed(java.awt.event.ActionEvent evt) {
llamarVentas();
}

private void jMenuItem8ActionPerformed(java.awt.event.ActionEvent evt) {
llamarCompras();
}

private void jMenuItem2ActionPerformed(java.awt.event.ActionEvent evt) {
llamarTipo();
}

private void jMenuItem3ActionPerformed(java.awt.event.ActionEvent evt) {
llamarArticulo();
}

private void jMenuItem4ActionPerformed(java.awt.event.ActionEvent evt) {
llamarCliente();
}

private void jMenuItem5ActionPerformed(java.awt.event.ActionEvent evt) {
llamarFuncionario();
}

private void jMenuItem6ActionPerformed(java.awt.event.ActionEvent evt) {
llamarProveedor();
}

private void jMenuItem9ActionPerformed(java.awt.event.ActionEvent evt) {
llamarReporteVenta();
}

private void jMenuItem10ActionPerformed(java.awt.event.ActionEvent evt) {
llamarReporteCompra();
}
Completado todo lo anterior podremos ejecutar nuestro “Principal”. El último punto que veremos en otra entrada del blog será como compilar y obtener el “Executable Jar File (.jar)”. (Clic en la imagen para ampliar).

020 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. iReport. Reporte para transacción Compra.

Como vimos anteriormente al trabajar con reportes para “Ventas”; las transacciones requieren de un formulario que servirá como base para lanzar los reportes, estos reportes pueden ser generales o específicos utilizando diferentes variables, como fechas, funcionarios, clientes, proveedores u otros. El diseño para reportes de compras es similar al de ventas, por tanto se puede utilizar el mismo diseño y procedimiento.
En primer lugar vemos el diseño del formulario, este formulario lanza dos reportes diferente, una de tipo general y otra tomando como variable un proveedor y los rangos de fechas inicio y fin. En el diseño se especifican los nombres de variable para los campos y botones (están en letra roja como etiqueta), esto es importante ya que a través de estas se llaman los objetos desde los métodos. Se puede cambiar el “Nombre de variable” de cada objeto haciendo clic derecho sobre la misma y clic en “Cambiar nombre de variable…”. Para la introducción de fechas utilizamos “JFormattedTextField” o “Cuadro formateado” si el IDE está en español, en esta entrada del blog se trata sobre la utilización de un cuadro formateado ((Fecha y Hora con objeto Calendar). La “Lista desplegable” o “jComboBox” va almacenar los nombres de proveedores.
En las transacciones se suelen utilizar varias tablas para obtener datos de referencia y trabajar con ellas. En este caso “CompraCab”, “CompraDet”, “Funcionario”, “Proveedor” y “Articulo” respectivamente, para confeccionar una lista única con los datos que necesitamos, debemos de crear una clase que servirá como plantilla para nuestros reportes. El nombre de la clase será “CompraR”, la única diferencia con el de “Ventas” será que está en vez de cliente tendrá proveedores, por tanto la misma nos sirve como referencia, y tendrá los siguientes elementos. Tomar en cuenta que esta clase debe ir almacenada dentro del paquete que corresponde a informes.
Código Java
package com.informes;

/**
*
* @author Ariel
*/

public class CompraR {
private int id;
private String funcionario;
private String proveedor;
private String fecha;
private String articulo;
private int cantidad;
private long importe;

public CompraR(int id, String funcionario, String proveedor, String fecha, String articulo, int cantidad, long importe) {
this.id = id;
this.funcionario = funcionario;
this.proveedor = proveedor;
this.fecha = fecha;
this.articulo = articulo;
this.cantidad = cantidad;
this.importe = importe;
}


public String getArticulo() {
return articulo;
}

public void setArticulo(String articulo) {
this.articulo = articulo;
}

public int getCantidad() {
return cantidad;
}

public void setCantidad(int cantidad) {
this.cantidad = cantidad;
}

public String getFecha() {
return fecha;
}

public void setFecha(String fecha) {
this.fecha = fecha;
}

public String getFuncionario() {
return funcionario;
}

public void setFuncionario(String funcionario) {
this.funcionario = funcionario;
}

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public long getImporte() {
return importe;
}

public void setImporte(long importe) {
this.importe = importe;
}

public String getProveedor() {
return proveedor;
}

public void setProveedor(String proveedor) {
this.proveedor = proveedor;
}
}
Vemos el diseño del primer reporte que será de tipo general, el nombre del archivo será “ReportCompra”. Se puede consultar este enlace del blog si hay dudas sobre algunos elementos que componen el reporte …(iReport. Introducción para crear informes). La configuración de la hoja es el A4 tipo vertical.
En la imagen de más abajo se puede ver el diseño del reporte terminado, con los “Fields” correspondientes, “Variables” y demás.
Elementos del diseño del reporte: 1) Un “Label” como descripción del reporte. 2) Una “Variable” para el número de páginas. 3) “Labels” para describir datos de columnas. 4) “Fields” o campos para la banda de detalles. Para el borde se utiliza “Rectangle” de fondo y sin borde. 5) Una “Variable” para indicar la suma total de ventas, en la imagen se especifica los parámetros necesarios para que funcione correctamente. Es importante respetar los nombres de los “Fields” al igual que los tipos de datos correspondientes ya que deben de coincidir con las que le pasaremos desde la lista más arriba creada.(clic para ampliar imagen)
Ahora vemos el segundo reporte que será de tipo específico, utilizando como filtro un proveedor especificado desde el combo. El nombre del archivo será “ReportCompraDos”. La configuración de la hoja es también A4 tipo vertical.
Los elementos del diseño son iguales que la anterior, la diferencia se ve en que ubicamos el nombre del proveedor en “Column Header” ya que será única para el reporte.(clic para ampliar imagen)
Completado el diseño debemos de compilar cada uno de los reportes y obtener los archivos necesarios que tienen la extensión “*.jasper” y “*.jrxml” respectivamente. Estos archivos de reporte debemos de copiar en nuestra carpeta “informes”, que creamos al inicio del proyecto.
El siguiente paso es crear un método que lance cada uno de los reportes creados y también los métodos que harán funcionar nuestro formulario. Más abajo tenemos los métodos creados, el nombre de cada una específica su función. Los comentarios explican que función cumple cada línea de código. Cada método de informe se llama desde su respectivo botón utilizando el evento “ActionPerformed”. Botón “verG” le corresponde el método “informeGeneral()” y el botón “verF” le corresponde el método “informeProveedor()”.
Código Java
private void hibernateSession(){
//Método para abrir una sesión hibernate.
st = HibernateUtil.getSessionFactory().openSession();
}
private void arranque(){
//Metodo para configurar los elementos de arranque
Calendar cal = Calendar.getInstance();
String fecha = retornarString(cal);
inicioG.setText(fecha);
finG.setText(fecha);
inicioF.setText(fecha);
finF.setText(fecha);
//Creamos una lista de proveedores para llenar nuestro lista desplegable o comboBox.
List<Proveedor> listF = (List<Proveedor>)st.createQuery("From Proveedor").list();
//Otra forma de navegar por una lista a diferencia de Iterator.
for (int i = 0; i < listF.size(); i++) {
Proveedor p = listF.get(i);
listaP.addItem(p.getDes());
}
}
//Métodos para trabajar con objeto Calendar.
public String retornarString(Calendar fecha){
//Método que retorna un String de fecha pasándole como argumento un objeto Calendar.
String retorno=null;
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
if (fecha != null) {
retorno = sdf.format(fecha.getTime());
}
return retorno;
}
public Calendar retornarCalendar(String fecha){
//Método que retorna un objeto Calendar pasando un String de fecha preformateado.
SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
Calendar cal = Calendar.getInstance();
try {
cal.setTime(sdf.parse(fecha));
} catch (ParseException ex) {
JOptionPane.showMessageDialog(null, "Error; compruebe formato de fecha: " + ex);
}
return cal;
}
public void informeGeneral(){
//Método para nuestro informe general
//try - para controlar las excepciones.
try {
//Iniciamos una transacción
st.beginTransaction();
//Utilizamos un Lista para almacenar los datos combinados.
//Inicializamos nuestra lista como ArrayList().
List compraList = new ArrayList();
//Creamos una Query utilizando nuestra sesión y HQL (Hibernate Query Language)
//Las condiciones son - fecha de inicio y fin.
Query query = (Query) st.createQuery("From CompraCab c Where c. fecha>=? and c. fecha<=?");
//A diferencia del SQL, las condiciones se pasan como parámetros.
//El primer parámetro indica el orden que empieza de "0", el segundo la variable.
query.setParameter(0, retornarCalendar(inicioG.getText()));
query.setParameter(1, retornarCalendar(finG.getText()));
//Obtenemos la lista de "CompraCab"
List<CompraCab> lista = query.list();
int id=0;
//Navegamos la lista utilizando Iterator.
for (Iterator<CompraCab> it = lista.iterator(); it.hasNext();) {
CompraCab compraCab = it.next();
String funcionario = compraCab.getFuncionario().getNombres();
String proveedor = compraCab.getProveedor().getDes();
String fecha = retornarString(compraCab.getFecha());
List<CompraDet> compraDets = compraCab.getCompraDets();
//Navegamos por la lista de detalles utilizando también iterator.
for (Iterator<CompraDet> it1 = compraDets.iterator(); it1.hasNext();) {
id++;
CompraDet compraDet = it1.next();
//Llenamos nuestro lista creada más arriba con los elementos necesarios.
compraList.add(new CompraR(id, funcionario, proveedor, fecha, compraDet.getArticulo().getDes(), compraDet.getCantidad(),compraDet.getImporte()));
}
}
//Utilizamos el método siguiente para cargar el reporte "*.jasper"
//El "JRLoader.loadObject" es el cargador.
JasperReport report = (JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/ReportCompra.jasper"));
//El método siguiente nos permite pasarle los datos al reporte utilizando JRBeanCollectionDataSource y como argumento la lista que creamos más arriba.
JasperPrint fillReport = JasperFillManager.fillReport(report, null,new JRBeanCollectionDataSource(compraList));
//El JasperViewer para visualizar, le pasamos como argumento nuestro "fillReport" de arriba.
JasperViewer jviewer = new JasperViewer(fillReport,false);
//Le damos un título al reporte.
jviewer.setTitle("Compras Generales.");
//La hacemos visible.
jviewer.setVisible(true);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Error cargando reporte." + e);
}
}
public void informeProveedor(){
//Este método es similar al de más arriba, por tanto se saltan algunos comentarios.
//try - para controlar las excepciones.
try {
//Iniciamos una transacción
st.beginTransaction();
//Utilizamos un Lista para almacenar los datos.
List compraList = new ArrayList();
Query query = (Query) st.createQuery("From CompraCab c Where c. fecha>=? and c. fecha<=?");
query.setParameter(0, retornarCalendar(inicioF.getText()));
query.setParameter(1, retornarCalendar(finF.getText()));
List<CompraCab> lista = query.list();
int id=0;
for (Iterator<CompraCab> it = lista.iterator(); it.hasNext();) {
CompraCab compraCab = it.next();
String funcionario = compraCab.getFuncionario().getNombres();
String proveedor = compraCab.getProveedor().getDes();
String fecha = retornarString(compraCab.getFecha());
List<CompraDet> compraDets = compraCab.getCompraDets();
for (Iterator<CompraDet> it1 = compraDets.iterator(); it1.hasNext();) {
id++;
CompraDet compraDet = it1.next();
//Una condición para filtrar la lista, obteniendo solo la de un proveedor en específico.
if( proveedor.equals(listaP.getSelectedItem().toString())){
compraList.add(new CompraR(id, funcionario, proveedor, fecha, compraDet.getArticulo().getDes(), compraDet.getCantidad(),compraDet.getImporte()));
}
}
}
//Utilizamos el método siguiente para cargar el reporte "*.jasper"
//El "JRLoader.loadObject" es el cargador.
JasperReport report = (JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/ReportCompraDos.jasper"));
//El método siguiente nos permite pasarle los datos al reporte utilizando JRBeanCollectionDataSource y como argumento la lista que creamos más arriba.
JasperPrint fillReport = JasperFillManager.fillReport(report, null,new JRBeanCollectionDataSource(compraList));
//El JasperViewer para visualizar, le pasamos como argumento nuestro "fillReport" de arriba.
JasperViewer jviewer = new JasperViewer(fillReport,false);
//Le damos un título al reporte.
jviewer.setTitle("Lista de Compras por Proveedores.");
//La hacemos visible.
jviewer.setVisible(true);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Error cargando reporte.");
}
}
Obs.: Se anexa una imagen con elementos a tomar en cuenta al crear el formulario al igual que los códigos que corresponden a los eventos para los botones. (clic para ampliar imagen)
Código Java
    private void verGActionPerformed(java.awt.event.ActionEvent evt) {                                     
//Condición agregada para ejecutar el informe.
if(!inicioG.getText().isEmpty() && !finG.getText().isEmpty()){
informeGeneral();
}
else{
JOptionPane.showMessageDialog(null, "Especifique una fecha correcta.");
}
}

private void verFActionPerformed(java.awt.event.ActionEvent evt) {
//Condición agregada para ejecutar el informe.
if(!inicioF.getText().isEmpty() && !finF.getText().isEmpty() && !listaP.getSelectedItem().toString().isEmpty()){
informeProveedor();
}
else{
JOptionPane.showMessageDialog(null, "Especifique los datos necesarios. -Fecha- y -Proveedor-");
}
}
En caso de que el IDE indique error de sintaxis, verificar si tenemos todas las importaciones necesarias. A continuación la lista.
Código Java
import com.entidades.CompraCab;
import com.entidades.CompraDet;
import com.entidades.Proveedor;
import com.informes.CompraR;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;
import java.util.List;
import javax.swing.JOptionPane;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import net.sf.jasperreports.engine.util.JRLoader;
import net.sf.jasperreports.view.JasperViewer;
import org.hibernate.Query;
import org.hibernate.Session;
import util.HibernateUtil;
Por último el formulario en ejecución junto con el reporte. En caso que el reporte aparezca detrás del formulario, modificar la propiedad “modalityType” del “JDialog”, indicando que sea “DOCUMENT_MODAL”. (clic para ampliar imagen)

019 - Aplicación de Stock con Java. Hibernate – MySQL – JPA. iReport. Reporte para referencial Proveedor.

Iniciamos el diseño para nuestro reporte, debemos de crear un archivo nuevo en nuestro iReport, el nombre del archivo será “ProveedorReport”. Para tener más datos sobre los diferentes elementos de un reporte podemos consultar el siguiente enlace (iReport. Introducción para crear informes). La configuración de la hoja normal es el A4.
En la imagen de más abajo se puede ver el diseño del reporte terminado, con los “Fields” correspondientes, “Variables” y demás. Hay que respetar el nombre para cada “Field”, como también tipo de datos, este último se puede cambiar consultando las propiedades de cada “Field”. Se puede ampliar la imagen haciendo clic en ella.
Elementos del diseño del reporte: 1) Un “Label” como descripción del reporte. 2) Una “Variable” para el número de páginas. 3) “Labels” para describir datos de columnas. 4) “Fields” o campos para la banda de detalles. Para el borde se utiliza “Rectangle” de fondo y sin borde. En (iReport. Introducción para crear informes) vimos cómo trabajar con cada elemento. Un detalle importante a tener en cuenta es el nombre para cada “Field” ya que serán iguales a las que le pasaremos desde Java con nuestra lista creada.
Completado el diseño debemos de compilar el reporte y obtener los archivos necesarios “ProveedorReport.jasper” y “ProveedorReport.jrxml” respectivamente. Estos archivos de reporte debemos de copiar en nuestra carpeta “informes”, que creamos al inicio del proyecto.
El siguiente paso es crear un método para ejecutar el reporte. Abajo el método “informe()” para ejecutar el reporte. Los comentarios explican que función cumple cada línea de código. Este método la llamamos desde el botón “Informe” de nuestro formulario “ProveedorApp” utilizando el evento “ActionPerformed”.
Código Java
public void informe(){
//try - para controlar las excepciones.
try {
//Creamos una lista de los datos de la tabla "Proveedor" utilizando "List".
//Iniciamos una transacción.
st.beginTransaction();
List<Proveedor> lista = (List<Proveedor>)st.createQuery("From Proveedor").list();
//Utilizamos el método siguiente para cargar el reporte "ProveedorReport.jasper"
//El "JRLoader.loadObject" es el cargador.
JasperReport report = (JasperReport)JRLoader.loadObject(ClassLoader.getSystemResource("com/informes/ProveedorReport.jasper"));
//El método siguiente nos permite pasarle los datos al reporte utilizando JRBeanCollectionDataSource y como argumento la lista que creamos más arriba.
//La lista posee todos los campos necesarios para pasarle datos al reporte.
JasperPrint fillReport = JasperFillManager.fillReport(report, null,new JRBeanCollectionDataSource(lista));
//El JasperViewer para visualizar, le pasamos como argumento nuestro "fillReport" de arriba.
JasperViewer jviewer = new JasperViewer(fillReport,false);
//Le damos un título al reporte.
jviewer.setTitle("Lista de Proveedores");
//La hacemos visible.
jviewer.setVisible(true);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Error cargando reporte.");
}
}
En caso de que el IDE indique error de sintaxis, verificar si tenemos todas las importaciones necesarias. A continuación la lista.
Código Java
import com.entidades.Proveedor;
import java.util.Iterator;
import java.util.List;
import javax.swing.JOptionPane;
import javax.swing.table.DefaultTableModel;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import net.sf.jasperreports.engine.util.JRLoader;
import net.sf.jasperreports.view.JasperViewer;
import org.hibernate.Session;
import util.HibernateUtil;
Por último el formulario en ejecución junto con el reporte. En caso que el reporte aparezca detrás del formulario, modificar la propiedad “modalityType” del “JDialog” indicando que sea “DOCUMENT_MODAL”. (clic para ampliar imagen)