Upload
nallely-hernandez-mendez
View
2.093
Download
8
Embed Size (px)
DESCRIPTION
jsp
Citation preview
GUARDAR DATOS DE UN JTABLE Y ABRIRLOS EN EXCEL [JAVA]
Buenas tardes a todos!, en esta entrada vengo a presentarles como guardar los datos
de un JTable en un archivo que pueda ser abierto por Excel. Para esto primeramente ya
tenemos que estar familiarizados almenos con DefaultTableModel y JTable, saber como
manipular los datos diferentes maneras de agregar,etc.
Primero que nada creando un proyecto en NetBeans o alguno similar, creamos un
JFrame(recomiendo usando el formulario de NetBeans) y agregamos un JTable y un
botón con la leyenda “Guardar”
Establecer el modelo y agregar datos predefinidos
Y ahora lo que haremos es rellenar con información la tabla para hacer la muestra, nos
vamos a la parte del constructor y haremos lo siguiente
Creamos un modelo y se lo asignamos a nuestra tabla y agregamos 2 columnas que
tendrán ya datos cada columna que es el arreglo que le estamos agregando allí
Si corremos nuestro programa tendremos la tabla con 2 columnas y esa información. Lo
que haremos para obtener esa información es crear una matriz o un arreglo
bidimensional como deseen llamarle, y ahí guardaremos toda la información contenida
en la tabla. Para esto crearemos un método llamado obtenerInformacion que devolverá
una matriz de cadenas:
Este método nos devolverá un arreglo bidimensional de cadenas que es la que
utilizaremos para guardarlo en un fichero con extensión .csv que es la que lo puede
abrir el Excel. Si se fijan lo que hace este método es simple, obtiene el tamaño de filas y
columnas actuales en la tabla y de ese numero creamos un arreglo llamado matriz, y
bloque por bloque en 2 arreglos agregamos la información a nuestra matriz
Guardar un fichero .csv
Entonces lo que haremos, en el botón que agregamos creamos un ActionEvent y
escribiremos lo siguiente:
De la línea 114 a la 119 trata de mostrar un dialogo para establecer donde
guardaremos y el nombre de nuestro archivo, si se da al botón cancel del dialogo
simplemente no hará nada y ya no seguirá con el procedimiento. Se crea un archivo
tipo File que es el que se eligió( creo ) en el dialogo y usamos la clase PrintWriter y
FileWriter para escribir en un fichero de nuestro ordenador.
Se fijan en la línea 123 llamamos al método creado anteriormente para así ya tener
toda la información en una arreglo bidimensional. En el ciclo 124 se escribe el primer
elemento que esta en (0,0) o sea la primer fila y columna y el siguiente ciclo se encarga
de seguir con las demás columnas pero de la primera fila, y así consecutivamente, el
método salida.printLn() es como si escribiéramos un “\n”, ósea un salto de línea.
Por que las comas? “,”
Por que las comas “,” ok esto es por que es la manera de interpretar las celdas en
Excel, ósea si nosotros escribimos esto
Isaac,23
Balu,20
y si lo guardamos con una extensión .csv, en Excel se mirara de esta forma
De esta manera estaremos guardando la informacion de nuestros JTables en un fichero
que puede ser abierto por Excel
Espero y les sea de ayuda como conmigo lo fue hace un par de semestres!
Code4Fun
EDITO:Ya van varios que me preguntan como hacer que aparezcan los títulos del JTable al
momento de mandarlo a imprimir para que lo abra Excel, solo hay que modificar el
metodo “obtenerInformacion”, se los dejo sin explicacion, solo noten las diferencias son
sencillas!, saludos!
exportar e importar a excel desde javaPara trabajar con excel vamos a hacerlo con el
formato csv , este formato es super simple de utilizar
Para bajar el jar que vamos añadir a nuestro proyecto
lo vamos a buscar aqui:
http://www.csvreader.com/java_csv.php
asi se guarda y es el formato con el cual tenemos que guardar
nuestro archivo
El siguiente ejemplo vamos a guardar un archivo
csv en un Arraylist el cual guarda objetos de la clase
libro( con sus get y set de atrivutos privados)
//////// clase libro /////////////////
public class libro_ingresado {
private String nombre;
private String autor;
private String edicion;
private String anio;
private String codigo;
private String area;
/** Creates a new instance of libro_ingresado */
public libro_ingresado() {
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public String getAutor() {
return autor;
}
public void setAutor(String autor) {
this.autor = autor;
}
public String getEdicion() {
return edicion;
}
public void setEdicion(String edicion) {
this.edicion = edicion;
}
public String getAnio() {
return anio;
}
public void setAnio(String anio) {
this.anio = anio;
}
public String getCodigo() {
return codigo;
}
public void setCodigo(String codigo) {
this.codigo = codigo;
}
public String getArea() {
return area;
}
public void setArea(String area) {
this.area = area;
}
}
/////// clase de manejo de csv //////////
import com.csvreader.CsvReader;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Iterator;
import javax.swing.JOptionPane;
public class leer_archivo {
public ArrayList leer_archivo_exel(String archivo){
ArrayList lista_libros = new ArrayList();
CsvReader reader = null;
try {
reader = new CsvReader(archivo,';');
} catch (FileNotFoundException ex) {
ex.printStackTrace();
JOptionPane.showInputDialog("en leer archivo");
}
try {
reader.readHeaders();
} catch (IOException ex) {
ex.printStackTrace();
}
try {
libro_ingresado libr;
while (reader.readRecord())
{
libr=new libro_ingresado();
libr.setNombre(reader.get("nombre"));
libr.setAutor(reader.get("autor"));
libr.setEdicion(reader.get("edicion"));
libr.setAnio(reader.get("anio"));
libr.setCodigo(reader.get("codigo"));
libr.setArea(reader.get("area"));
lista_libros.add(libr); // añadimos el objeto al arrayList
}
} catch (IOException ex) {
ex.printStackTrace();
System.err.println(" en while readrecord ");
}
reader.close();
return lista_libros; // retorna una objeto de ArrayList
}
}
////////////////////////////////////////////////////////
el siquiente codigo es abrir un JFileChooser donde buscamos
nuestro archivo csv , luego lo seleccionamos y es procesado.
el archivo es pasado a un jtable
////////////////// codigo evento boton ///////////////
DefaultTableModel dtm;
ArrayList libro_recivido=new ArrayList();
JFileChooser fileChooser = new JFileChooser(".");
int status = fileChooser.showOpenDialog(null); //fileChooser
if (status == JFileChooser.APPROVE_OPTION) {
File selectedFile =fileChooser.getSelectedFile();
leer_archivo l=new leer_archivo();
String direccion=selectedFile.getParent()+"/"+selectedFile.getName();
libro_recivido=l.leer_archivo_exel(direccion);
Iterator it=libro_recivido.iterator();
try{
Object datos[] = new Object [6];
dtm = (DefaultTableModel) jTable1.getModel();
for (int i = jTable1.getRowCount() - 1; i>=0; i--)
{
dtm.removeRow(i);
}
while(it.hasNext()){
libro_ingresado lib_ing;
lib_ing=(libro_ingresado) it.next();
datos[0]=lib_ing.getNombre();
datos[1]=lib_ing.getAutor();
datos[2]=lib_ing.getEdicion();
datos[3]=lib_ing.getAnio();
datos[4]=lib_ing.getCodigo();
datos[5]=lib_ing.getArea();
dtm.addRow(datos);
}
} catch(Exception e){
//manejo de error
}
} else if (status == JFileChooser.CANCEL_OPTION) {
System.out.println("cancele");
}
//////////////////////////////////////////////////
como fin un link de interes
POI, Interacción entre Java y documentos de Excel
jun27de elespaciodejaime
¿Qué les parece poder interactuar entre Java y Excel, de manera más específica, tener la capacidad de leer documentos de Excel usando Java, y la capacidad de poder crear y escribir documentos de excel también, bueno, ésto es posible usando la librería POI. Entre otras cosas que podemos hacer usando la librería POI, tenemos la capacidad de interactuar con documentos de Word, Power Point, Open Office, etc.
Propósito de POI
El proyecto POI consiste de varios API para manipular varios formatos de archivo basado en OLE 2, Office OpenXML usando código 100% Java. En pocas palabras, puedes leer y escribir archivos de MS Excel usando Java. Adicionalmente, puedes leer y escribir archivos de MS Word, y MS Power Point usando Java. POI es tu solución Java Excel (Excel 97-2007). Sin embargo, tenemos un completo API para portar documento OLE2 y le damos la bienvenida a otros formatos.
El formato OLE 2 incluye la mayoría de los documentos de Microsoft Office como XLS, DOC, así como los archivos basados en el API de serialización MFC.
El formato Office OpenXML incluye los nuevos formatos basados en XML (2007+), incluyendo los archivos XLSX, DOCX y PPTX de Microsoft Office.
Como política general tratamos de colaborar tanto como sea posible con otros proyectos para proveer esta funcionalidad. Algunos ejemplos incluyen: Cocoon, OpenOffice.org y Lucene. Cuando resulta práctico, le donamos componentes a aquellos proyectos para POI-activarlos. :)
Adaptación al español de un fragmento de: http://poi.apache.org/
Bueno, veamos un ejemplo para comenzar a familiarizarnos con esta librería, asumo que tiene un conocimiento basico/medio del lenguaje Java, y facilidad para interactuar con un IDE, en éste caso usaremos Netbeans, porque Eclipse corre muy lento en mi PC (Un modesto Xeon de 4 procesadores, sí, ya lo sé, no es una computadora de escritorio, pero Netbeans no la discrimina :) ).
El código completo para éste proyecto se encuentra aquí, puedes descargarlo y abrirlo con el Netbeans.
http://www.2shared.com/file/6472969/ebd7783d/poi.html
Lo más probable es que al abrirlo obtengamos dependencias rotas, lo más probable es que no tengas las librerías POI, y por lo tanto, que esperas para descargarlas?
http://poi.apache.org/
El vínculo de descarga se encuentra en la columna de la izquierda dentro de Project > Download
Una de las clases que veremos dentro de éste proyecto sera:
ServletExcel2.java
12
import java.io.FileInputStream;import java.io.IOException;import java.io.OutputStream;
3456789101112131415161718192021222324252627282930313233343536373839404142434445464748
import javax.servlet.ServletException;import javax.servlet.http.HttpServlet;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletRequestWrapper;import javax.servlet.http.HttpServletResponse;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;import org.apache.poi.poifs.filesystem.POIFSFileSystem;
public class ServletExcel2 extends HttpServlet {
protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String nota11 = request.getParameter("nota11"); // Juan String nota12 = request.getParameter("nota12"); String nota13 = request.getParameter("nota13");
String nota21 = request.getParameter("nota21"); // Ana String nota22 = request.getParameter("nota22"); String nota23 = request.getParameter("nota23");
String nota31 = request.getParameter("nota31"); // Luis String nota32 = request.getParameter("nota32"); String nota33 = request.getParameter("nota33");
response.setContentType("application/vnd.ms-excel");
HttpServletRequestWrapper srw = new HttpServletRequestWrapper(request); String excel2 = srw.getRealPath(""); excel2 += "/excel/alumnos.xls";
POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(excel2)); HSSFWorkbook wb = new HSSFWorkbook(fs); HSSFSheet sheet = wb.getSheetAt(0);
HSSFRow row1 = sheet.getRow(1); // Juan HSSFCell b2 = row1.getCell(1); HSSFCell c2 = row1.getCell(2); HSSFCell d2 = row1.getCell(3); b2.setCellValue(Integer.valueOf(nota11).intValue()); c2.setCellValue(Integer.valueOf(nota12).intValue()); d2.setCellValue(Integer.valueOf(nota13).intValue());
HSSFRow row2 = sheet.getRow(2); // Ana HSSFCell b3 = row2.getCell(1); HSSFCell c3 = row2.getCell(2); HSSFCell d3 = row2.getCell(3); b3.setCellValue(Integer.valueOf(nota21).intValue()); c3.setCellValue(Integer.valueOf(nota22).intValue());
49505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394
d3.setCellValue(Integer.valueOf(nota23).intValue());
HSSFRow row3 = sheet.getRow(3); // Luis HSSFCell b4 = row3.getCell(1); HSSFCell c4 = row3.getCell(2); HSSFCell d4 = row3.getCell(3); b4.setCellValue(Integer.valueOf(nota31).intValue()); c4.setCellValue(Integer.valueOf(nota32).intValue()); d4.setCellValue(Integer.valueOf(nota33).intValue());
sheet.setForceFormulaRecalculation(true); // actualiza sheet
OutputStream out = response.getOutputStream(); wb.write(out); out.close(); }
/** * Handles the HTTP <code>GET</code> method. * @param request servlet request * @param response servlet response * @throws ServletException if a servlet-specific error occurs * @throws IOException if an I/O error occurs */ @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { processRequest(request, response); }
/** * Handles the HTTP <code>POST</code> method. * @param request servlet request * @param response servlet response * @throws ServletException if a servlet-specific error occurs * @throws IOException if an I/O error occurs */ @Override protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException { processRequest(request, response); }
/** * Returns a short description of the servlet. * @return a String containing servlet description */ @Override public String getServletInfo() { return "Short description"; }// </editor-fold>}
9596979899100101102103104105106107108109110
Realmente creen que escribí todo ese código? De ninguna forma, para eso está Netbeans.
Bueno, explicaré rápidamente el ciclo de vida de nuestro Servlet:
1. El contenedor de Servlets (muy probablemente Tomcat) llama al mét0do
1 protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException;
2. Este método a su vez llama al método
1 protected void processRequest(HttpServletRequest request, HttpServletResponse response) throws
generado por Netbeans.
3. Establecemos el tipo MIME de respuesta, en éste caso Microsoft Excel.
1 response.setContentType("application/vnd.ms-excel");
4. Cargamos un archivo de excel(Este se encuentra en el proyecto que descargaste… lo descargaste no?)
1 POIFSFileSystem fs = new POIFSFileSystem(new FileInputStream(excel2));
5. Cargamos un libro de trabajo usando el constructor siguiente
1 public HSSFWorkbook(POIFSFileSystem fs) throws IOException12
HSSFWorkbook wb = new HSSFWorkbook(fs);HSSFSheet sheet = wb.getSheetAt(0);
6. Bueno, lo que sigue es bastante intuitivo, obtenemos una fila, y establecemos el valor para cada una de las celdas.
12345678
HSSFRow row1 = sheet.getRow(1); // Juan
HSSFCell b2 = row1.getCell(1); HSSFCell c2 = row1.getCell(2); HSSFCell d2 = row1.getCell(3); b2.setCellValue(Integer.valueOf(nota11).intValue()); c2.setCellValue(Integer.valueOf(nota12).intValue()); d2.setCellValue(Integer.valueOf(nota13).intValue());
7. Hacemos ésto, para evitar que el resultado de las fórmulas no se actualize, si no están seguros de lo que ésto hace, solo háganlo, nos podría evitar problemas difíciles de debugear.
1 sheet.setForceFormulaRecalculation(true); // actualiza sheet
8. Escribimos en el buffer de salida y cerramos la conexión.
1234
OutputStream out = response.getOutputStream();
wb.write(out); out.close();
En este tutorial voy a mostrar la manera de generar un archivo compatible con Microsoft Excel que consiste en valores separados por espacios tabuladores muy elemental y sin gráficos o estilos.
Primero hay que partir diciendo qué opciones de formatos compatibles con Excel hay:
CSV
Es el más conocido, y consiste en un archivo de texto plano, generalmente con la extención .csv donde los valores de cada celda van separados por una coma (,) en el caso de las columnas, y un salto de línea para las filas.
TSV
TSV es una variación al anterior CSV, donde las columnas van separadas por un espacio tabulador y las filas por un salto de línea. Esto permite que se puedan introducir celdas con valores que incluyan una coma y no sean confundidas por un salto de columna, por ejemplo.
XLS
El formato Microsoft Excel tradicional que es un archivo binario para Windows donde se guardan en hojas, gráficos y macros. Mucho tiempo su especificación fue cerrada, pero desde que se comenzó a documentar el formato con ingeniería inversa y debido a las presiones de las cortes para aceptar su formato como un estándar, Microsoft se vio obligada a publicar su estructura de funcionamiento bien particular.
XLSX
Esta es la última especificación Office Open XML que Microsoft no sé cómo logró estandarizar, y que consiste en una serie de archivos XML y otros, organizados en una carpeta todo comprimido en un archivo ZIP (al igual que el estándarOpenDocument que también es soportado por Microsoft Office 2007 pero que no es de propiedad de Microsoft).
Y otros más menos importantes.
El formato
El formato que voy a exportar desde el JSP en este tutorial es el TSV, pero con extensión .xls. El archivo siguiente:
Uno Due Tre QuattroUno Dos Tres CuatroOne TwoIchi Ni San ShiOdin Dva Tri
Se vería así en la planilla de cálculo:
A B C D
1 Uno Due Tre Quattro
2 Uno DosTres
Cuatro
3 One Two
4 Ichi Ni San Shi
5Odin
Dva Tri
La librería
Yo encontré una librería de etiquetas para generar estos archivos y así evitarme el problema de generar el caracter de tabulación y todos los espacios (whitespaces) que se generan.
Descarga
La página para descargar el archivo exceltag.jar eshttp://www.servletsuite.com/servlets/exceltag.htm
Instalación
Para instalar la librería en Netbeans, es igual que en todas las librerías. Se va a las propiedades del proyecto,
elegimos Agregar JAR/Carpeta (o Add JAR/Folder); buscamos el archivo exceltag.jar recién descargado y seleccionamos Elegir.
Aceptar
El modo de uso
Ahora que está la librería instalada, hacemos uso de ella de la siguiente forma:
Hola, mundo
Para el primer ejemplo, voy a crear un nuevo archivo llamadoNumberwang.jspx como de costumbre:
Y el código con sintaxis XML sería...
Numberwang.jspx
<?xml version="1.0" encoding="UTF-8"?><!-- Document : Numberwang Created on : 15-ago-2009, 9:58:09 Author : ooscarr--><jsp:root xmlns:jsp="http://java.sun.com/JSP/Page" xmlns:ms="http://www.servletsuite.com/servlets/exceltag" version="2.0">
<jsp:directive.page contentType="application/vnd.ms-excel;charset=UTF-8" pageEncoding="UTF-8"/>
<ms:Excel> <ms:cell>Uno</ms:cell> <ms:cell>Due</ms:cell> <ms:cell>Tre</ms:cell> <ms:cell>Quattro</ms:cell> <ms:row/> <ms:cell>Uno</ms:cell> <ms:cell>Dos</ms:cell> <ms:cell>Tres</ms:cell> <ms:cell>Cuatro</ms:cell> <ms:row/> <ms:cell>One</ms:cell> <ms:cell>Two</ms:cell> <ms:row/> <ms:cell>Ichi</ms:cell> <ms:cell>Ni</ms:cell> <ms:cell>San</ms:cell> <ms:cell>Shi</ms:cell> <ms:row/> <ms:cell>Odin</ms:cell> <ms:cell>Dva</ms:cell> <ms:cell>Tri</ms:cell> </ms:Excel>
</jsp:root>Resultado
Cuando visite la página Numberwang.jspx, el navegador reconocerá elcontentType="application/vnd.ms-excel;charset=UTF-8" y dará la opción de descargarlo o, en ciertos casos, en Windows, desplegará la planilla de cálculo dentro de la ventana del browser.
Nombre de archivo personalizado
Para elegir otro nombre para el archivo Excel, basta agregar la siguiente línea en el principio del documento:
<jsp:directive.page contentType="application/vnd.ms-excel;charset=UTF-8"
pageEncoding="UTF-8"/><jsp:scriptlet> response.setHeader("Content-Disposition","attachment;filename=nombre_de_archivo.xls");</jsp:scriptlet>
Otro ejemplo con base de datos
Un último ejemplo que lee los datos de la base de datos, sería:
Productos.jspx
<?xml version="1.0" encoding="UTF-8"?><jsp:root xmlns:jsp="http://java.sun.com/JSP/Page" xmlns:c="http://java.sun.com/jsp/jstl/core" xmlns:sql="http://java.sun.com/jsp/jstl/sql" xmlns:ms="http://www.servletsuite.com/servlets/exceltag" version="2.0">
<jsp:directive.page contentType="application/vnd.ms-excel;charset=UTF-8" pageEncoding="UTF-8"/>
<jsp:directive.include file="/WEB-INF/jspf/conexion.jspf"/><c:catch var="excepcion"> <sql:transaction dataSource="${bdatos}"> <sql:query var="productos"> SELECT nombre_prod AS nombre,precio AS precio FROM inventario_productos; </sql:query> </sql:transaction></c:catch><c:if test="${empty excepcion}">
<!-- Si encontró productos --> <c:if test="${productos.rowCount>0}"> <!-- Forma la tabla --> <ms:Excel> <ms:cell>Producto</ms:cell> <ms:cell>Precio</ms:cell>
<!-- Llena la tabla --> <c:forEach items="${productos.rows}" var="producto" varStatus ="status"> <ms:row/> <ms:cell>${producto.nombre}</ms:cell> <ms:cell>${producto.precio}</ms:cell>
<!-- En la última fila --> <c:if test="${status.last}"> <ms:row/> <ms:cell><c:out value=" "/></ms:cell> <!-- Se pueden ingresar fórmulas --> <ms:cell>=SUM(B2:B${status.index+2})</ms:cell> </c:if> </c:forEach> </ms:Excel> </c:if>
</c:if> </jsp:root>Resultado leído de la base de datos
A B
1 ProductoPrecio
2 Lápiz 200
3Cuaderno
1000
4 1200
¿Qué opinan las aplicaciones de planillas de cálculo?
Cuando se abre el archivo excel generado con una apliación de planillas de cálculo, estos son algunos de los resultados:
Software Resultado
Microsoft Office
No dice nada y abre el archivo correctamente.
OpenOffice.orgAparece un asistente de importación con una vista previa y si no se modifica ninguna opción, abre la planilla correctamente.
iWork Numbers
Aparece un pequeño aviso de que no es un formato Excel válido, pero lo muestra correctamente.
Google Docs Produce un error. A la fecha, no está preparado para el formato.