Java JTable cargar consulta PostgreSQL y exportar a Excel

Java JTable cargar consulta PostgreSQL y exportar a excel

Seguimos con los ejemplos de Java Swing en este caso vamos a ver dos cosas, la primera es como cargar una consulta a una base de datos utilizando JDBC en un javax.swing.JTable, y en la segunda veremos como exportar el contenido del javax.swing.JTable a Excel con un método genérico, es decir, válido para cualquier JTable usando Apache Poi Java API para Excel.

Cargar consulta en JTable y exportar a Excel con Java y PostgreSQL

Tecnologías utilizadas

logo-apache-POI-project


 

1. ¿Qué vamos a hacer?

Vamos a crear un clase con un constructor al que le podamos pasar por parámetros los datos para cargar en un javax.swing.JTable cualquier consulta, una vez hecho esto crearemos un botón que nos permita exportar los datos cargados a una hoja Excel.

Así definimos nuestra clase con las siguientes condiciones:

  • Constructor: pasaremos por parámetros la consulta, los nombres de las columnas a presentar, el tipo de datos de cada columna, y por último, el ancho que ocupará cada una en la presentación.
  • Conexión a la base de datos: utilizamos JDBC para conectar con la base de datos y obtener los resultados de la consulta.
  • DefaultTableModel: el modelo de datos de la tabla será variable y adaptable a cada consulta que se pase por parámetros con las condiciones especificadas anteriormente en el constructor, esto implica que para cada consulta se construirá automáticamente un javax.​swing.​table.​DefaultTableModel adaptado para cargar la consulta en el javax.swing.JTable.
  • Carga de la consulta: para facilitar la comprensión del ejemplo fijaremos una conexión a una base de datos PostgreSQL, incluiremos todas las acciones necesarias para la carga en este método, para que en otros ejemplos posteriores se pueda usar como método de actualización de la tabla.
  • Exportar a excel: crearemos un botón para ejecutar la acción de exportación, para ello crearemos un método genérico que se pueda reutilizar con cualquier javax.swing.JTable.


 

2. Defimos la tabla y la consulta de ejemplo

Vamos a crear la tabla cb_language con la siguiente estructura en base de datos:

Esquema de la tabla cb_language

Esquema de la tabla cb_language

La tabla cb_language la utilizo en otros ejemplos dentro de mi proyecto Learning Project, y es simplemente, una tabla con los idiomas registrados en la aplicación

Para crear esta tabla en PostgreSQL y para la instalación de esta base de datos tienes toda la información en la publicación: Tutorial Postgresql (1): Preparando el entorno con los enlaces necesarios para la descarga y configuración básica.
 

Cuando expliquemos la conexión a la base de datos explicaré como puedes hacer este ejemplo fácilmente también con MySQL (MariaDB).

 

3. Creamos la clase y definimos el constructor

En este ejemplo, no me voy a parar mucho en explicar todos los elementos que se utilizan de Java Swing nos centraremos en explicar la creación del javax.swing.JTable y como adaptarlo a nuestras necesidades.

Vamos al lío, en mi caso tengo creado en Netbeans el paquete org.xulescode.swing que es donde voy a crear la clase JFrameJTableDatabaseToExcelExample, como siempre utilizo nombres explícitos que identifiquen rápidamente la clase. Para crear una nueva clase usamos la opción New > JFrame form, una vez creado usaremos el editor visual para añadir los elementos que vamos a utilizar.

Esto es lo que yo hice, añado un javax.swing.JPanel para añadirle directamente un javax.swing.JTable ya que por defecto añade un javax.swing.JScrollPane, elemento sobre el que cargamos habitualmente nuestra tabla, y que nos proporciona un scroll horizontal y vertical entre otras utilidades, para finalizar añado los dos elementos para las acciones dos javax.swing.JButton uno para salir de la pantalla y otro para hacer la exportación de la que hablamos a Excel. A continuación, puedes ver el resultado final:

JFrame JTable Database To Excel - Diseño del form

JFrame JTable Database To Excel – Diseño del form


Como puedes en el resultado de la imagen utilizando el editor de Netbeans ya he actualizado los títulos y nombres de los elementos, esto lo puedes hacer de forma sencilla, si tienes alguna duda, no dudes en consultarme en los comentarios de esta publicación.


 

Definimos el constructor

Definamos el constructor con las especificaciones dadas inicialmente, solo incluimos la llamada al método initComponents() que se utiliza para cargar la presentación que creamos en el diseñador de Netbeans:

    /**
     * We create a constructor to load a SQL query by passing parameters which define the query, 
     * the column name, data type columns.
     * Creamos un constructor para cargar una consulta SQL mediante el paso de 
     * parámetros donde definimos la consulta, los nombre de las columnas, el tipo de datos de las columnas
     * @param query <code>String</code> we pass the query we want to load (pasamos la consulta que queremos a cargar).
     * @param columns <code>String[]</code> we define the names of the columns (definimos los nombre de las columnas).
     * @param types <code>Class[]</code> we define the data types of the columns (definimos el tipo de datos de las columnas.).
     * @param editable <code>boolean[]</code> we define if columns are editable or not (definimos si las columnas son editables o no).
     * @param columnsWidth <code>int[]</code> the width of each column to present in the table (el ancho de cada columna para presentar en la tabla).
     */
    public JFrameJTableDatabaseToExcelExample(String query, String[] columns, Class[] types, boolean[] editable, int[] columnsWidth) {
        initComponents();
        // Aquí añadiremos los métodos para cargar la consulta.
    }

Como puede ver en el código definimos el tipo de datos que usamos para los parámetros:

  • query: de tipo String pasamos la consulta que queremos a cargar.
  • columns: de tipo String[] definimos los nombre de las columnas.
  • types: de tipo Class[] definimos el tipo de datos de las columnas.
  • editable: de tipo boolean[]definimos si las columnas son editables o no.
  • columnsWidth: de tipo int[] especificamos el ancho de cada columna para presentar en la tabla.


 

4. Creamos los métodos para cargar la consulta

Vamos a separar el código en dos métodos principales, el primera para crear la conexión a la base de datos: connectDatabase(String host, String port, String database, String user, String password), y el segundo, para la carga de la consulta en la tabla: cargaConsulta(String query, String[] columns, Class[] types, boolean[] editable, int[] columnsWidth).

Ahora explicaremos el contenido de estos métodos pero para que te hagas una idea de lo que haremos nuestro constructor quedaría así definido (las explicaciones en el código):

    public JFrameJTableDatabaseToExcelExample(String query, String[] columns, Class[] types, boolean[] editable, int[] columnsWidth) {
        initComponents();
        // Establecemos la conexión y si todo va bien cargamos la consulta
        boolean testConnection = connectDatabase("192.168.0.26", "5432", "customerdb","xulescode", "xulescode");
        if (testConnection){
            // Cargamos la consulta con los parámetros que pasamos.
            cargaConsulta(query, columns, types, editable, columnsWidth);
            // Centramos nuestro JFrame y lo hacemos visible.
            setLocationCenter();
            setVisible(true);
        }else{
            System.out.println("No se ha podido conectar con la base de datos.");
        }
    }


 

Conexión a la base de datos

Para establecer conexión con un base de datos tenemos que incorporar el driver JDBC a nuestro proyecto en mi caso PostgreSQL, por lo tanto descargamos el driver (descargalo aquí) e incorpóralo al nuestro proyecto.
Una vez hecho esto añadimos este código genérico, donde puedes ver las explicaciones en el código:

    /**
     * Method to connect to the database by passing parameters.
     * Método para establecer la conexión a la base de datos mediante el paso de parámetros.
     * 
     * @param host <code>String</code> host name or ip. Nombre del host o ip.
     * @param port <code>String</code> listening database port. Puerto en el que escucha la base de datos.
     * @param database <code>String</code> database name for the connection. Nombre de la base de datos para la conexión.
     * @param user <code>String</code> user name. Nombre de usuario.
     * @param password  <code>String</code> user password. Password del usuario.
     */
    private boolean connectDatabase(String host, String port, String database,
            String user, String password) {
        String url = "";
        try {
            // We register the PostgreSQL driver
            // Registramos el driver de PostgresSQL
            try {
                Class.forName("org.postgresql.Driver");
            } catch (ClassNotFoundException ex) {
                System.out.println("Error al registrar el driver de PostgreSQL: " + ex);
            }            
            url = "jdbc:postgresql://" + host + ":" + port + "/" + database;
            // Database connect
            // Conectamos con la base de datos
            setConnection(DriverManager.getConnection(
                    url,
                    user, password));           
            boolean valid = connection.isValid(50000);
            System.out.println(valid ? "TEST OK" : "TEST FAIL");
            return valid;
        } catch (java.sql.SQLException sqle) { 
            System.out.println("Error al conectar con la base de datos de PostgreSQL (" + url + "): " + sqle);
            return false;
        }
    }

Si necesitas más información o si quieres utilizar MySQL (MariaDB) en estos enlaces te lo cuento:


 

Carga de la consulta

Para cargar la consulta creamos el método public void cargaConsulta(String query, String[] columns, Class[] types, boolean[] editable, int[] columnsWidth) donde agrupamos todo lo que necesitamos para cargar la tabla, esto nos permitirá su reutilización creando por ejemplo un botón para recargar la consulta.
En este método vamos a hacer las siguientes acciones:

  • Primero definimos el modelo de datos con los parámetros indicados, lo hacemos con el método initJTable(columns, types, editable, columnsWidth) que explicamos más adelante aquí
  • Ejecutamos la consulta utilizando java.sql.Statement, que nos permite obtener el resultado en un java.sql.ResultSet ejecutando la consulta con: statement.executeQuery(query)
  • Finalmente, recorremos el ResultSet para ir añadiendo las filas a la tabla según el modelo definido.

A continuación, el código utilizado donde se incluyen más explicaciones:

    /**
     * Method where we group all we need to load the table, this will allow us 
     * to reuse creating for example a button to reload the query.
     * Método donde agrupamos todo lo que necesitamos para cargar la tabla, esto nos permitirá su reutilización
     * creando por ejemplo un botón para recargar la consulta.
     * @param query <code>String</code> we pass the query we want to load (pasamos la consulta que queremos a cargar).
     * @param columns <code>String[]</code> we define the names of the columns (definimos los nombre de las columnas).
     * @param types <code>Class[]</code> we define the data types of the columns (definimos el tipo de datos de las columnas.).
     * @param editable <code>boolean[]</code> we define if columns are editable or not (definimos si las columnas son editables o no).
     * @param columnsWidth <code>int[]</code> the width of each column to present in the table (el ancho de cada columna para presentar en la tabla).
     */
    public void cargaConsulta(String query, String[] columns, Class[] types, boolean[] editable, int[] columnsWidth){
        try {
            // We define the data model table with the parameters.
            // Definimos el modelo de datos de la tabla con los parámetros.
            initJTable(columns, types, editable, columnsWidth);
            // Execute the query using java.sql.Statement.
            // Ejecutamos la consulta utilizando java.sql.Statement.
            Statement statement = getConnection().createStatement();
            ResultSet resultSet = statement.executeQuery(query); 
            int row = 0;
            /*
                If we get results we go through the java.sql.ResultSet to obtain 
                the data and load them into our model table.
                Si obtenemos resultados recorremos el java.sql.ResultSet para 
                obtener los datos y cargarlos en nuestro modelo de tabla.
            */
            while (resultSet.next()){                
                Object[] newRow = new Object[columns.length];            
                for (int i = 0; i < columns.length; i++) {
                    newRow&#91;i&#93; = resultSet.getObject(i + 1);
                }
                // We add the rows to our table.
                // Vamos añadiendo las filas a nuestra tabla
                tableModelQuery.insertRow(row++, newRow);                
            }
        } catch (SQLException ex) {
            Logger.getLogger(JFrameJTableDatabaseToExcelExample.class.getName()).log(Level.SEVERE, null, ex);
        }
    }


 

Definición del modelo de datos

Para definir el modelo de datos creamos un método genérico, lo llamo así porque lo podríamos poner en una clase utilidades y reutilizarlo, por ello pasamos como parámetros los elementos que utilizamos en Java Swing para la presentación de la tabla: JTable, JScrollPane y DefaultTableModel, como puedes ver en el método también pasamos las variables con las que definimos nuestro modelo de datos.

Ahora veamos la implementación en el código encontrarás las explicaciones:

 /**
     * We create a specific JTable with parameters passed to the method.
     * Creamos un JTable específico con los parámetros que se pasan en el método.
     * @param jTable <code>JTable</code> tabla del JFrame que volvemos a definir en esta clase.
     * @param jScrollPane <code>JScrollPane</code> pasamos de nuevo el JScrollPane para vincularlo de nuevo con el nuevo JTable.
     * @param tableModel <code>tableModel</code> modelo nuevo de tabla que definimos con los parámetros que pasamos.         
     * @param columns <code>String[]</code> we define the names of the columns (definimos los nombre de las columnas).
     * @param types <code>Class[]</code> we define the data types of the columns (definimos el tipo de datos de las columnas.).
     * @param editable <code>boolean[]</code> we define if columns are editable or not (definimos si las columnas son editables o no).
     * @param columnsWidth <code>int[]</code> the width of each column to present in the table (el ancho de cada columna para presentar en la tabla).
     * @return <code>Object[]</code> returns an array with the values of jTable, jScrollPane y tableModel ( devuelve una array con los nuevos valores
     * de jTable, jScrollPane y tableModel).
     */
    private Object[] initJTableQuery(JTable jTable, JScrollPane jScrollPane, DefaultTableModel tableModel, 
            String[] columns, Class[] types, boolean[] editable, int[] columnsWidth) {
        Object[] object = null;
        final Class[] columnsTypes = types;
        final boolean[] canEdit = editable;
        // We define the data model with the type of the columns and whether or not editable.
        // Definimos el modelo de datos con el tipo de las columnas y si son o no editables.
        tableModel = new DefaultTableModel(
                new Object[][]{},
                columns
        ) { 
            /**
             * We override the method to define our type of columns.
             * Sobreescribimos el método para definir nuestro tipo de columnas.
             * @param columnIndex the column being queried (la columna que está consultando)
             * @return the Object.class (la clase del objeto)
             */
            @Override
            public Class getColumnClass(int columnIndex) {
                return columnsTypes[columnIndex];
            }
            /**
             * We override the method to select the editable columns.
             * Sobre escribimos el método para seleccionar las columnas editables.
             * @param rowIndex the row being queried (la fila que está consultando)
             * @param columnIndex the column being queried  (la columna que está consultando)
             * @return the Object.class (la clase del objeto)
             */
            @Override
            public boolean isCellEditable(int rowIndex, int columnIndex) {
                return canEdit[columnIndex];
            }
        };
        // We create the table.
        // Creamos una nueva tabla.
        jTable = new JTable();
        // We assign our data model to the JTable.
        // Le asignamos nuestro modelo de datos al JTable.
        jTable.setModel(tableModel);
        // We associate our table again to JScrollPane.
        // Asociamos de nuevo nuestra tabla al JScrollPane.
        jScrollPane.setViewportView(jTable);
        for (int i = 0; i < jTable.getColumnModel().getColumnCount(); i++) {
            jTable.getColumnModel().getColumn(i).setPreferredWidth(columnsWidth&#91;i&#93;);
        }
        // With this method we generate automatic sorting in columns.
        // Con este método generamos ordenación automática en las columnas.
        jTable.setAutoCreateRowSorter(true);
        object = new Object&#91;&#93;{jTable, jScrollPane, tableModel};
        return object;
    }   

En nuestro ejemplo usamos un método auxiliar, ya que la idea es el que método anterior se encuentre externalizado en otra clase como ya comentamos, por la tanto, en initJTable(…) simplemente llamamos al método anterior y asignamos los nuevos valores de nuestros objetos de presentación de la tabla, como ya vimos anteriormente:

    /**
     * Helper method which define the presentation of the table.
     * Método auxiliar donde definimos la presentación de la tabla. 
     * @param columns <code>String[]</code> we define the names of the columns (definimos los nombre de las columnas).
     * @param types <code>Class[]</code> we define the data types of the columns (definimos el tipo de datos de las columnas.).
     * @param editable <code>boolean[]</code> we define if columns are editable or not (definimos si las columnas son editables o no).
     * @param columnsWidth <code>int[]</code> the width of each column to present in the table (el ancho de cada columna para presentar en la tabla).
     */
    private void initJTable(String[] columns, Class[] types, boolean[] editable, int[] columnsWidth) {       
        Object[] newObjectItems = initJTableQuery(jTableQuery, jScrollPaneQuery, tableModelQuery, columns, types, editable, columnsWidth);
        tableModelQuery = (DefaultTableModel) newObjectItems[2];
        jTableQuery = (JTable) newObjectItems[0];
        jScrollPaneQuery = (JScrollPane) newObjectItems[1];

    }


 

Otros métodos y variables utilizados

Definimos dos variables para manejar la conexión y el modelo de datos, creando los getters y setters para la variable de conexión:

    // Variable to manage database connection (variable para manejar la conexión a la base de datos).
    private Connection connection = null;
    // Table model variable (variable para el modelo de datos).
    private DefaultTableModel tableModelQuery;

En está clase también usamos los métodos para colocar el JFrame en el lugar de la pantalla que queramos y son los siguientes:

  • public void setLocationMove(int moveWidth, int moveHeight): este código lo puedes consultar en el código completo que muestro al final, las explicaciones, las encontrarás en JFrame en el centro de la pantalla

Una vez hecho esto ya podemos ejecutar nuestro código y obtener el siguiente resultado para la consulta de idiomas de la base de datos:

JFrame JTable Database To Excel - Mostramos los datos

JFrame JTable Database To Excel – Mostramos los datos


 

5. Exportación a Excel

Para la creación de este método utilizamos las explicaciones sobre la utilización de Java Apache POI para crear un hoja excel: Java escribir excel con Apache Poi Java API.

Adaptamos el método para que sea válida para cualquier JTable que se pase como parámetro, como veremos más adelante esta clase la añadiremos a una clase genéricas de utilidades de ahí que entre los parámetros se encuentre el JTable que queremos exportar. El resto de parámetros son el fichero ExcelExcelJTable:

    /**
     * Explanation of the method by which we read the JTable we pass as
     * parameter, and where we copy its content in a excel spreadsheet passed 
     * as a parameter.
     * Método con el que leemos cualquier JTable que pasamos como
     * parámetro, y donde copiamos su contenido en una hoja excel que se pasa 
     * como parámetro.
     * <h3>Example (Ejemplo)</h3>
     * <pre>
     *     utilJTableToExcel(jTable2, new File("excelJTable.xls"), getTitle() + " (Código Xules)", "JTable");
     * </pre>
     *
     * @param jTable <code>JTable</code> 
     *      the JTable we are going to extract to excel 
     *      El Jtable que vamos a extraer a excel.
     * @param excelNewFile <code>String</code> 
     *      excel File we are going to write. 
     *      Fichero excel en el que vamos a escribir. 
     * @param title <code>String</code> 
     *      title
     *      Título
     * @param sheetName <code>String</code> 
     *      Name of the sheet
     *      Nombre de la hoja
     */
    public void utilJTableToExcel(JTable jTable, File excelNewFile, String title, String sheetName){        
        OutputStream excelNewOutputStream = null;
        try {            
            excelNewOutputStream = new FileOutputStream(excelNewFile);
            // High level representation of a workbook.
            // Representación del más alto nivel de la hoja excel.            
            HSSFWorkbook hssfWorkbookNew = new HSSFWorkbook();
            // We create the new sheet we are going to use.
            // Creamos la hoja nueva que vamos a utilizar.
            HSSFSheet hssfSheetNew = hssfWorkbookNew.createSheet(sheetName);
            // An object that allows us to read a row of the excel sheet, and extract from it the cell contents.
            // Objeto que nos permite leer un fila de la hoja excel, y de aquí extraer el contenido de las celdas.            
            HSSFRow hssfRowNew;
            // Initialize the object to read the value of the cell 
            // Inicializo el objeto que leerá el valor de la celda
            HSSFCell cellNew;
            
            // Creating title row (creando una fila con el título)            
            hssfRowNew = hssfSheetNew.createRow(1); 
            cellNew = hssfRowNew.createCell(1);
            cellNew.setCellType(HSSFCell.CELL_TYPE_STRING);
            cellNew.setCellValue(title);
            
            // We create the titles of the columns.
            hssfRowNew = hssfSheetNew.createRow(4);               
            for (int column = 0; column < jTable.getColumnCount(); column++) {  
                cellNew = hssfRowNew.createCell(column);  
                cellNew.setCellType(HSSFCell.CELL_TYPE_STRING);  
                cellNew.setCellValue((String)jTable.getColumnName(column));
            }
            // Now we fill the excel spreatsheet.
            // Ahora llenamos la hoja de cálculo excel.
            for (int row = 0; row < jTable.getRowCount(); row++) {
                hssfRowNew = hssfSheetNew.createRow(row + 5);   
                for (int column = 0; column < jTable.getColumnCount(); column++) {    
                    cellNew = hssfRowNew.createCell(column);                                      
                    if (jTable.getColumnClass(column).equals(java.lang.Boolean.class)){                        
                        cellNew.setCellValue((Boolean)jTable.getValueAt(row, column));
                    }else if (jTable.getColumnClass(column).equals(java.util.Date.class)){
                        cellNew.setCellValue((java.util.Date)jTable.getValueAt(row, column));    
                    }else if (jTable.getColumnClass(column).equals(java.lang.Integer.class) ||
                            jTable.getColumnClass(column).equals(java.lang.Float.class) ||
                            jTable.getColumnClass(column).equals(java.lang.Double.class)){
                        cellNew.setCellType(HSSFCell.CELL_TYPE_NUMERIC);  
                        cellNew.setCellValue((Double)jTable.getValueAt(row, column));    
                    }else{
                        cellNew.setCellType(HSSFCell.CELL_TYPE_STRING);  
                        cellNew.setCellValue((String)jTable.getValueAt(row, column));
                    }
                }                
            }                    
            hssfWorkbookNew.write(excelNewOutputStream);
            excelNewOutputStream.close();
            JOptionPane.showMessageDialog(this.jPanelQuery, "Your excel file has been generated!(¡Se ha generado tu hoja excel!",
                    "RESULTADO", JOptionPane.INFORMATION_MESSAGE);
        } catch (FileNotFoundException fileNotFoundException) {
            JOptionPane.showMessageDialog(this.jPanelQuery, "The file not exists (No se encontró el fichero): " + fileNotFoundException,
                    "ERROR", JOptionPane.ERROR_MESSAGE);
        } catch (IOException ex) {
            JOptionPane.showMessageDialog(this.jPanelQuery, "Error in file procesing (Error al procesar el fichero): " + ex,
                    "ERROR", JOptionPane.ERROR_MESSAGE);
        } 
    }  

Para ejecutar este método simplemente creamos el método que responde a la acción sobre el botón y añadimos la llamada:

    /**
     * Button to export the table to excel.
     * Botón para exportar the table to excel.
     * @param evt button event (evento del botón).
     */
    private void jButtonExcelExportActionPerformed(java.awt.event.ActionEvent evt) {                                                   
        utilJTableToExcel(jTableQuery, new File("excelJTable.xls"), getTitle() + " (Código Xules)", "JTable");
    } 

Como puedes ver el fichero se generará en la carpeta de nuestro proyecto, esta opción es fácilmente modificable, en otra publicación veremos como abrir automáticamente este fichero.


 

6. Probamos nuestro código

Para probar el código puedes descargar el fichero:


 

O sino, cópialo directamente, este es:

package org.xulescode.swing;

import java.awt.*;
import java.io.*;
import java.sql.*;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.DefaultTableModel;
import org.apache.poi.hssf.usermodel.HSSFCell;
import org.apache.poi.hssf.usermodel.HSSFRow;
import org.apache.poi.hssf.usermodel.HSSFSheet;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;

/**
 * We create a table where we load an SQL query to PostgreSQL database, 
 * parameters defined by the column names, type and whether they are editable 
 * for presentation.
 * Creamos una tabla donde cargamos una consulta SQL sobre la base de datos PostgreSQL, 
 * definimos por parámetros su presentación.
 * <pre>
 * SELECT   idlanguage, namelanguage, isactive, languageiso, countrycode, 
 *          isbaselanguage, issystemlanguage
 *          FROM cb_language;
 * </pre>
 * 
 * @author xules You can follow me on my website http://www.codigoxules.org/en
 * Puedes seguirme en mi web http://www.codigoxules.org
 */
public class JFrameJTableDatabaseToExcelExample extends javax.swing.JFrame {
    // Variable to manage database connection (variable para manejar la conexión a la base de datos).
    private Connection connection = null;
    // Table model variable (variable para el modelo de datos).
    private DefaultTableModel tableModelQuery;
    /**
     * We create a constructor to load a SQL query by passing parameters which define the query, 
     * the column name, data type columns.
     * Creamos un constructor para cargar una consulta SQL mediante el paso de 
     * parámetros donde definimos la consulta, los nombre de las columnas, el tipo de datos de las columnas
     * @param query <code>String</code> we pass the query we want to load (pasamos la consulta que queremos a cargar).
     * @param columns <code>String[]</code> we define the names of the columns (definimos los nombre de las columnas).
     * @param types <code>Class[]</code> we define the data types of the columns (definimos el tipo de datos de las columnas.).
     * @param editable <code>boolean[]</code> we define if columns are editable or not (definimos si las columnas son editables o no).
     * @param columnsWidth <code>int[]</code> the width of each column to present in the table (el ancho de cada columna para presentar en la tabla).
     */
    public JFrameJTableDatabaseToExcelExample(String query, String[] columns, Class[] types, boolean[] editable, int[] columnsWidth) {
        initComponents();
        boolean testConnection = connectDatabase("192.168.0.26", "5432", "customerdb","xulescode", "xulescode");
        if (testConnection){
            cargaConsulta(query, columns, types, editable, columnsWidth);
            setLocationCenter();
            setVisible(true);
        }else{
            System.out.println("No se ha podido conectar con la base de datos.");
        }
    }
    /**
     * Method where we group all we need to load the table, this will allow us 
     * to reuse creating for example a button to reload the query.
     * Método donde agrupamos todo lo que necesitamos para cargar la tabla, esto nos permitirá su reutilización
     * creando por ejemplo un botón para recargar la consulta.
     * @param query <code>String</code> we pass the query we want to load (pasamos la consulta que queremos a cargar).
     * @param columns <code>String[]</code> we define the names of the columns (definimos los nombre de las columnas).
     * @param types <code>Class[]</code> we define the data types of the columns (definimos el tipo de datos de las columnas.).
     * @param editable <code>boolean[]</code> we define if columns are editable or not (definimos si las columnas son editables o no).
     * @param columnsWidth <code>int[]</code> the width of each column to present in the table (el ancho de cada columna para presentar en la tabla).
     */
    public void cargaConsulta(String query, String[] columns, Class[] types, boolean[] editable, int[] columnsWidth){
        try {
            // We define the data model table with the parameters.
            // Definimos el modelo de datos de la tabla con los parámetros.
            initJTable(columns, types, editable, columnsWidth);
            // Execute the query using java.sql.Statement.
            // Ejecutamos la consulta utilizando java.sql.Statement.
            Statement statement = getConnection().createStatement();
            ResultSet resultSet = statement.executeQuery(query); 
            int row = 0;
            /*
                If we get results we go through the java.sql.ResultSet to obtain 
                the data and load them into our model table.
                Si obtenemos resultados recorremos el java.sql.ResultSet para 
                obtener los datos y cargarlos en nuestro modelo de tabla.
            */
            while (resultSet.next()){                
                Object[] newRow = new Object[columns.length];            
                for (int i = 0; i < columns.length; i++) {
                    newRow&#91;i&#93; = resultSet.getObject(i + 1);
                }
                // We add the rows to our table.
                // Vamos añadiendo las filas a nuestra tabla
                tableModelQuery.insertRow(row++, newRow);                
            }
        } catch (SQLException ex) {
            Logger.getLogger(JFrameJTableDatabaseToExcelExample.class.getName()).log(Level.SEVERE, null, ex);
        }
    }
    
    /**
     * Method to connect to the database by passing parameters.
     * Método para establecer la conexión a la base de datos mediante el paso de parámetros.
     * 
     * @param host <code>String</code> host name or ip. Nombre del host o ip.
     * @param port <code>String</code> listening database port. Puerto en el que escucha la base de datos.
     * @param database <code>String</code> database name for the connection. Nombre de la base de datos para la conexión.
     * @param user <code>String</code> user name. Nombre de usuario.
     * @param password  <code>String</code> user password. Password del usuario.
     */
    private boolean connectDatabase(String host, String port, String database,
            String user, String password) {
        String url = "";
        try {
            // We register the PostgreSQL driver
            // Registramos el driver de PostgresSQL
            try {
                Class.forName("org.postgresql.Driver");
            } catch (ClassNotFoundException ex) {
                System.out.println("Error al registrar el driver de PostgreSQL: " + ex);
            }            
            url = "jdbc:postgresql://" + host + ":" + port + "/" + database;
            // Database connect
            // Conectamos con la base de datos
            setConnection(DriverManager.getConnection(
                    url,
                    user, password));           
            boolean valid = connection.isValid(50000);
            System.out.println(valid ? "TEST OK" : "TEST FAIL");
            return valid;
        } catch (java.sql.SQLException sqle) { 
            System.out.println("Error al conectar con la base de datos de PostgreSQL (" + url + "): " + sqle);
            return false;
        }
    }


    /**
     * Helper method which define the presentation of the table.
     * Método auxiliar donde definimos la presentación de la tabla. 
     * @param columns <code>String[]</code> we define the names of the columns (definimos los nombre de las columnas).
     * @param types <code>Class[]</code> we define the data types of the columns (definimos el tipo de datos de las columnas.).
     * @param editable <code>boolean[]</code> we define if columns are editable or not (definimos si las columnas son editables o no).
     * @param columnsWidth <code>int[]</code> the width of each column to present in the table (el ancho de cada columna para presentar en la tabla).
     */
    private void initJTable(String[] columns, Class[] types, boolean[] editable, int[] columnsWidth) {       
        Object[] newObjectItems = initJTableQuery(jTableQuery, jScrollPaneQuery, tableModelQuery, columns, types, editable, columnsWidth);
        tableModelQuery = (DefaultTableModel) newObjectItems[2];
        jTableQuery = (JTable) newObjectItems[0];
        jScrollPaneQuery = (JScrollPane) newObjectItems[1];

    }

    /**
     * We create a specific JTable with parameters passed to the method.
     * Creamos un JTable específico con los parámetros que se pasan en el método.
     * @param jTable <code>JTable</code> tabla del JFrame que volvemos a definir en esta clase.
     * @param jScrollPane <code>JScrollPane</code> pasamos de nuevo el JScrollPane para vincularlo de nuevo con el nuevo JTable.
     * @param tableModel <code>tableModel</code> modelo nuevo de tabla que definimos con los parámetros que pasamos.         
     * @param columns <code>String[]</code> we define the names of the columns (definimos los nombre de las columnas).
     * @param types <code>Class[]</code> we define the data types of the columns (definimos el tipo de datos de las columnas.).
     * @param editable <code>boolean[]</code> we define if columns are editable or not (definimos si las columnas son editables o no).
     * @param columnsWidth <code>int[]</code> the width of each column to present in the table (el ancho de cada columna para presentar en la tabla).
     * @return <code>Object[]</code> returns an array with the values of jTable, jScrollPane y tableModel ( devuelve una array con los nuevos valores
     * de jTable, jScrollPane y tableModel).
     */
    private Object[] initJTableQuery(JTable jTable, JScrollPane jScrollPane, DefaultTableModel tableModel, 
            String[] columns, Class[] types, boolean[] editable, int[] columnsWidth) {
        Object[] object = null;
        final Class[] columnsTypes = types;
        final boolean[] canEdit = editable;
        // We define the data model with the type of the columns and whether or not editable.
        // Definimos el modelo de datos con el tipo de las columnas y si son o no editables.
        tableModel = new DefaultTableModel(
                new Object[][]{},
                columns
        ) { 
            /**
             * We override the method to define our type of columns.
             * Sobreescribimos el método para definir nuestro tipo de columnas.
             * @param columnIndex the column being queried (la columna que está consultando)
             * @return the Object.class (la clase del objeto)
             */
            @Override
            public Class getColumnClass(int columnIndex) {
                return columnsTypes[columnIndex];
            }
            /**
             * We override the method to select the editable columns.
             * Sobre escribimos el método para seleccionar las columnas editables.
             * @param rowIndex the row being queried (la fila que está consultando)
             * @param columnIndex the column being queried  (la columna que está consultando)
             * @return the Object.class (la clase del objeto)
             */
            @Override
            public boolean isCellEditable(int rowIndex, int columnIndex) {
                return canEdit[columnIndex];
            }
        };
        // We create the table.
        // Creamos una nueva tabla.
        jTable = new JTable();
        // We assign our data model to the JTable.
        // Le asignamos nuestro modelo de datos al JTable.
        jTable.setModel(tableModel);
        // We associate our table again to JScrollPane.
        // Asociamos de nuevo nuestra tabla al JScrollPane.
        jScrollPane.setViewportView(jTable);
        for (int i = 0; i < jTable.getColumnModel().getColumnCount(); i++) {
            jTable.getColumnModel().getColumn(i).setPreferredWidth(columnsWidth&#91;i&#93;);
        }
        // With this method we generate automatic sorting in columns.
        // Con este método generamos ordenación automática en las columnas.
        jTable.setAutoCreateRowSorter(true);
        object = new Object&#91;&#93;{jTable, jScrollPane, tableModel};
        return object;
    }    
    
    /**
     * Explanation of the method by which we read the JTable we pass as
     * parameter, and where we copy its content in a excel spreadsheet passed 
     * as a parameter.
     * Método con el que leemos cualquier JTable que pasamos como
     * parámetro, y donde copiamos su contenido en una hoja excel que se pasa 
     * como parámetro.
     * <h3>Example (Ejemplo)</h3>
     * <pre>
     *     utilJTableToExcel(jTable2, new File("excelJTable.xls"), getTitle() + " (Código Xules)", "JTable");
     * </pre>
     *
     * @param jTable <code>JTable</code> 
     *      the JTable we are going to extract to excel 
     *      El Jtable que vamos a extraer a excel.
     * @param excelNewFile <code>String</code> 
     *      excel File we are going to write. 
     *      Fichero excel en el que vamos a escribir. 
     * @param title <code>String</code> 
     *      title
     *      Título
     * @param sheetName <code>String</code> 
     *      Name of the sheet
     *      Nombre de la hoja
     */
    public void utilJTableToExcel(JTable jTable, File excelNewFile, String title, String sheetName){        
        OutputStream excelNewOutputStream = null;
        try {            
            excelNewOutputStream = new FileOutputStream(excelNewFile);
            // High level representation of a workbook.
            // Representación del más alto nivel de la hoja excel.            
            HSSFWorkbook hssfWorkbookNew = new HSSFWorkbook();
            // We create the new sheet we are going to use.
            // Creamos la hoja nueva que vamos a utilizar.
            HSSFSheet hssfSheetNew = hssfWorkbookNew.createSheet(sheetName);
            // An object that allows us to read a row of the excel sheet, and extract from it the cell contents.
            // Objeto que nos permite leer un fila de la hoja excel, y de aquí extraer el contenido de las celdas.            
            HSSFRow hssfRowNew;
            // Initialize the object to read the value of the cell 
            // Inicializo el objeto que leerá el valor de la celda
            HSSFCell cellNew;
            
            // Creating title row (creando una fila con el título)            
            hssfRowNew = hssfSheetNew.createRow(1); 
            cellNew = hssfRowNew.createCell(1);
            cellNew.setCellType(HSSFCell.CELL_TYPE_STRING);
            cellNew.setCellValue(title);
            
            // We create the titles of the columns.
            hssfRowNew = hssfSheetNew.createRow(4);               
            for (int column = 0; column < jTable.getColumnCount(); column++) {  
                cellNew = hssfRowNew.createCell(column);  
                cellNew.setCellType(HSSFCell.CELL_TYPE_STRING);  
                cellNew.setCellValue((String)jTable.getColumnName(column));
            }
            // Now we fill the excel spreatsheet.
            // Ahora llenamos la hoja de cálculo excel.
            for (int row = 0; row < jTable.getRowCount(); row++) {
                hssfRowNew = hssfSheetNew.createRow(row + 5);   
                for (int column = 0; column < jTable.getColumnCount(); column++) {    
                    cellNew = hssfRowNew.createCell(column);                                      
                    if (jTable.getColumnClass(column).equals(java.lang.Boolean.class)){                        
                        cellNew.setCellValue((Boolean)jTable.getValueAt(row, column));
                    }else if (jTable.getColumnClass(column).equals(java.util.Date.class)){
                        cellNew.setCellValue((java.util.Date)jTable.getValueAt(row, column));    
                    }else if (jTable.getColumnClass(column).equals(java.lang.Integer.class) ||
                            jTable.getColumnClass(column).equals(java.lang.Float.class) ||
                            jTable.getColumnClass(column).equals(java.lang.Double.class)){
                        cellNew.setCellType(HSSFCell.CELL_TYPE_NUMERIC);  
                        cellNew.setCellValue((Double)jTable.getValueAt(row, column));    
                    }else{
                        cellNew.setCellType(HSSFCell.CELL_TYPE_STRING);  
                        cellNew.setCellValue((String)jTable.getValueAt(row, column));
                    }
                }                
            }                    
            hssfWorkbookNew.write(excelNewOutputStream);
            excelNewOutputStream.close();
            JOptionPane.showMessageDialog(this.jPanelQuery, "Your excel file has been generated!(¡Se ha generado tu hoja excel!",
                    "RESULTADO", JOptionPane.INFORMATION_MESSAGE);
        } catch (FileNotFoundException fileNotFoundException) {
            JOptionPane.showMessageDialog(this.jPanelQuery, "The file not exists (No se encontró el fichero): " + fileNotFoundException,
                    "ERROR", JOptionPane.ERROR_MESSAGE);
        } catch (IOException ex) {
            JOptionPane.showMessageDialog(this.jPanelQuery, "Error in file procesing (Error al procesar el fichero): " + ex,
                    "ERROR", JOptionPane.ERROR_MESSAGE);
        } 
    }    
    /**
     * We get the database connection.
     * Obtenemos la conexión a la base de datos.
     * @return <code>Connection</code> database connection (conexión a la base de datos).
     */
    public Connection getConnection() {
        return connection;
    }
    /**
     * We set the database connection.
     * Definimos la conexíoin a la base de datos.
     * @param connection <code>Connection</code> set database connection (definimos la conexión a la base de datos).
     */
    public void setConnection(Connection connection) {
        this.connection = connection;
    }
    
    /**
     * Set the JFrame in the center of the screen. Colocamos nuestro JFrame en
     * el centro de la pantalla.
     */
    public void setLocationCenter() {
        setLocationMove(0, 0);
    }


    
    /**
     * Place the JFrame with the parameters by moving the component relative to
     * the center of the screen. Colocamos el JFrame con los parámetros
     * desplazando el componente respecto al centro de la pantalla.
     *
     * @param moveWidth int positive or negative offset width (desplazamiente de
     * width positivo o negativo).
     * @param moveHeight int Positive or negative offset height (desplazamiento
     * de height positivo o negativo).
     */
    public void setLocationMove(int moveWidth, int moveHeight) {
        // Obtenemos el tamaño de la pantalla.
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        // Obtenemos el tamaño de nuestro frame.
        Dimension frameSize = this.getSize();
        frameSize.width = frameSize.width > screenSize.width ? screenSize.width : frameSize.width;
        frameSize.height = frameSize.height > screenSize.height ? screenSize.height : frameSize.height;
        // We define the location. Definimos la localización.
        setLocation((screenSize.width - frameSize.width) / 2 + moveWidth, (screenSize.height - frameSize.height) / 2 + moveHeight);
    }    
    /**
     * This method is called from within the constructor to initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is always
     * regenerated by the Form Editor.
     */
    @SuppressWarnings("unchecked")
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                          
    private void initComponents() {

        jPanelQuery = new javax.swing.JPanel();
        jScrollPaneQuery = new javax.swing.JScrollPane();
        jTableQuery = new javax.swing.JTable();
        jButtonExcelExport = new javax.swing.JButton();
        jButtonOut = new javax.swing.JButton();

        setDefaultCloseOperation(javax.swing.WindowConstants.DO_NOTHING_ON_CLOSE);
        setTitle("CARGAR CONSULTA PARA EXPORTAR");
        addWindowListener(new java.awt.event.WindowAdapter() {
            public void windowClosing(java.awt.event.WindowEvent evt) {
                formWindowClosing(evt);
            }
        });

        jPanelQuery.setBorder(javax.swing.BorderFactory.createTitledBorder("Carga consulta para exportar"));

        jTableQuery.setModel(new javax.swing.table.DefaultTableModel(
            new Object [][] {
                {null, null, null, null},
                {null, null, null, null},
                {null, null, null, null},
                {null, null, null, null},
                {null, null, null, null},
                {null, null, null, null},
                {null, null, null, null},
                {null, null, null, null}
            },
            new String [] {
                "Title 1", "Title 2", "Title 3", "Title 4"
            }
        ));
        jScrollPaneQuery.setViewportView(jTableQuery);

        javax.swing.GroupLayout jPanelQueryLayout = new javax.swing.GroupLayout(jPanelQuery);
        jPanelQuery.setLayout(jPanelQueryLayout);
        jPanelQueryLayout.setHorizontalGroup(
            jPanelQueryLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addComponent(jScrollPaneQuery, javax.swing.GroupLayout.DEFAULT_SIZE, 488, Short.MAX_VALUE)
        );
        jPanelQueryLayout.setVerticalGroup(
            jPanelQueryLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, jPanelQueryLayout.createSequentialGroup()
                .addComponent(jScrollPaneQuery)
                .addContainerGap())
        );

        jButtonExcelExport.setText("EXPORTAR A EXCEL");
        jButtonExcelExport.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButtonExcelExportActionPerformed(evt);
            }
        });

        jButtonOut.setText("SALIR");
        jButtonOut.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                jButtonOutActionPerformed(evt);
            }
        });

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(jPanelQuery, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                .addContainerGap())
            .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
                .addGap(84, 84, 84)
                .addComponent(jButtonExcelExport)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                .addComponent(jButtonOut, javax.swing.GroupLayout.PREFERRED_SIZE, 159, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(66, 66, 66))
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addContainerGap()
                .addComponent(jPanelQuery, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
                .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
                    .addComponent(jButtonOut)
                    .addComponent(jButtonExcelExport))
                .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
        );

        pack();
    }// </editor-fold>                        
    /**
     * Button to export the table to excel.
     * Botón para exportar the table to excel.
     * @param evt button event (evento del botón).
     */
    private void jButtonExcelExportActionPerformed(java.awt.event.ActionEvent evt) {                                                   
        utilJTableToExcel(jTableQuery, new File("excelJTable.xls"), getTitle() + " (Código Xules)", "JTable");
    }                                                  
    /**
     * Exit button.
     * Botón de salida.
     * @param evt button event (evento del botón).
     */
    private void jButtonOutActionPerformed(java.awt.event.ActionEvent evt) {                                           
        try {
            getConnection().close();
        } catch (SQLException ex) {
            Logger.getLogger(JFrameJTableDatabaseToExcelExample.class.getName()).log(Level.SEVERE, null, ex);
        }
        dispose();        
    }                                          
    /**
     * Exit JFrame.
     * Salida de JFrame.
     * @param evt button event (evento del botón).
     */
    private void formWindowClosing(java.awt.event.WindowEvent evt) {                                   
        try {
            // Connection close (cierre de la conexión).
            getConnection().close();
        } catch (SQLException ex) {
            Logger.getLogger(JFrameJTableDatabaseToExcelExample.class.getName()).log(Level.SEVERE, null, ex);
        }
        dispose(); 
    }                                  

    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        /* Set the Nimbus look and feel */
        //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
        /* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
         * For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html 
         */
        try {
            for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
                if ("Nimbus".equals(info.getName())) {
                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
                    break;
                }
            }
            // Load the System look and feel (cargamos el "look and feel" del sistema.
            javax.swing.UIManager.setLookAndFeel(javax.swing.UIManager.getSystemLookAndFeelClassName());
        } catch (ClassNotFoundException ex) {
            java.util.logging.Logger.getLogger(JFrameJTableDatabaseToExcelExample.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (InstantiationException ex) {
            java.util.logging.Logger.getLogger(JFrameJTableDatabaseToExcelExample.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (IllegalAccessException ex) {
            java.util.logging.Logger.getLogger(JFrameJTableDatabaseToExcelExample.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        } catch (javax.swing.UnsupportedLookAndFeelException ex) {
            java.util.logging.Logger.getLogger(JFrameJTableDatabaseToExcelExample.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
        }
        //</editor-fold>
        //</editor-fold>

        /** 
         * Create and display the form.
         * Creamos y mostramos el form.
         */
        java.awt.EventQueue.invokeLater(new Runnable() {
            /**
             * 
             */
            public void run() {
                String consulta = 
                    "SELECT idlanguage, namelanguage, isactive, languageiso, countrycode, \n" +
                    "            isbaselanguage, issystemlanguage\n" +
                    "            FROM cb_language";
                JFrameJTableDatabaseToExcelExample jFrameJTableDatabaseToExcelExample = 
                        new JFrameJTableDatabaseToExcelExample(consulta, 
                    new String[] {"IDIOMA", "NOMBRE", "ACTIVO", "ISO", "PAÍS", "BASE", "SISTEMA"},
                    new Class[] {java.lang.String.class, java.lang.String.class, java.lang.String.class, 
                        java.lang.String.class, java.lang.String.class, java.lang.String.class,  java.lang.String.class},
                    new boolean[]{false, false, false, false, false, false, false},
                    new int[]{100, 100, 80, 80, 80, 60, 60}    
                );
                jFrameJTableDatabaseToExcelExample = 
                        new JFrameJTableDatabaseToExcelExample(consulta, 
                    new String[] {"IDIOMA", "NOMBRE", "ACTIVO", "ISO", "PAÍS"},
                    new Class[] {java.lang.String.class, java.lang.String.class, java.lang.String.class, 
                        java.lang.String.class, java.lang.String.class},
                    new boolean[]{false, false, false, false, false},
                    new int[]{100, 100, 80, 80, 80}    
                );
            }
        });
    }

    // Variables declaration - do not modify                     
    private javax.swing.JButton jButtonExcelExport;
    private javax.swing.JButton jButtonOut;
    private javax.swing.JPanel jPanelQuery;
    private javax.swing.JScrollPane jScrollPaneQuery;
    private javax.swing.JTable jTableQuery;
    // End of variables declaration                   
}

Para mostrar la funcionalidad de nuestro código mostramos como podemos variar fácilmente los datos presentados vía parámetros utilizando la misma consulta, este es el primer ejemplo donde definimos con arrays nuestra columnas:

                String consulta = 
                    "SELECT idlanguage, namelanguage, isactive, languageiso, countrycode, \n" +
                    "            isbaselanguage, issystemlanguage\n" +
                    "            FROM cb_language";
                JFrameJTableDatabaseToExcelExample jFrameJTableDatabaseToExcelExample = 
                        new JFrameJTableDatabaseToExcelExample(consulta, 
                    new String[] {"IDIOMA", "NOMBRE", "ACTIVO", "ISO", "PAÍS", "BASE", "SISTEMA"},
                    new Class[] {java.lang.String.class, java.lang.String.class, java.lang.String.class, 
                        java.lang.String.class, java.lang.String.class, java.lang.String.class,  java.lang.String.class},
                    new boolean[]{false, false, false, false, false, false, false},
                    new int[]{100, 100, 80, 80, 80, 60, 60}    
                );

Este es el resultado del form:

JFrame JTable Database To Excel - Redimension

JFrame JTable Database To Excel – Redimension

Si lo exportamos a Excel obtendremos el siguiente fichero:

Antes de la exportación hemos incluido un mensaje de confirmación:

JFrame JTable Database To Excel - Mensaje de confirmación de exportación

JFrame JTable Database To Excel – Mensaje de confirmación de exportación

Para el siguiente ejemplo, reducimos el número de consultas utilizando la misma consulta:

                jFrameJTableDatabaseToExcelExample = 
                        new JFrameJTableDatabaseToExcelExample(consulta, 
                    new String[] {"IDIOMA", "NOMBRE", "ACTIVO", "ISO", "PAÍS"},
                    new Class[] {java.lang.String.class, java.lang.String.class, java.lang.String.class, 
                        java.lang.String.class, java.lang.String.class},
                    new boolean[]{false, false, false, false, false},
                    new int[]{100, 100, 80, 80, 80}    
                );

Este es el resultado del form:

JFrame JTable Database To Excel - Cargamos la consulta modificada

JFrame JTable Database To Excel – Cargamos la consulta modificada

Espero que te haya sido útil

3 respuestas en “Java JTable cargar consulta PostgreSQL y exportar a Excel

    1. Julio Yáñez Novo Autor de la entrada

      Hola Víctor, muchas gracias por tu valoración y comentario, me alegra mucho que te sea útil mi publicación, simplemente te pediría que compartieras la publicación para que llegue a más gente.

      En mi web puedes ver como añadir la impresión directa y la exportación a PDF con iText, directamente sobre JTable, te dejo los enlaces por si fuera de tu interés:

      Así, fácilmente le puedes añadir más funcionalidad a tus listados.

      Saludos.

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos necesarios están marcados *