Cómo importar datos de formulario desde una página web a Excel
jxl.jar (se puede descargar de Internet y colocar en la carpeta lib)
Categoría abierta: java
Clase de herramienta para operar tablas de Excel a través de Java Biblioteca
Admite todas las versiones de Excel 95-2000
Genera el formato estándar de Excel 2000
Admite operaciones de fuentes, números y fechas
Capaz de modificar atributos de celda
Admite imágenes y gráficos
Cabe decir que las funciones anteriores pueden satisfacer aproximadamente nuestras necesidades. Lo más importante es que esta API es Java pura y no depende del sistema Windows. Incluso si se ejecuta en Linux, aún puede procesar archivos de Excel correctamente. También cabe señalar que este conjunto de API tiene un soporte muy limitado para gráficos y tablas, y solo reconoce el formato PNG.
Construya el entorno
Descomprima el archivo descargado para obtener jxl.jar, colóquelo en el classpath y la instalación estará completa.
Operaciones básicas
1. Crear archivo
Se planea generar un archivo Excel llamado "test data.xls", en el cual se nombra la primera hoja de trabajo. es la "primera página", el efecto aproximado es el siguiente:
Código (CreateXLS.java):
//Generar clase de Excel
importar java. io.*;
importar jxl.*;
importar jxl.write.*
clase pública CreateXLS
{
public static void main(String args[])
{
prueba
{
//Abrir archivo
WritableWorkbook book=
Workbook.createWorkbook(new File("Test.xls"));
//Generar una hoja de trabajo llamada "Primera página", el parámetro 0 significa que esta es la primera página
WritableSheetsheet=book.createSheet("First Page",0
//Nombra la unidad en el constructor del objeto Label. la posición de la celda es la primera columna y la primera fila (0,0)
//Y el contenido de la celda es prueba
Label label=new Label(0,0,"test" ) ;
//Agregar la celda definida a la hoja de trabajo
sheet.addCell(label);
/*Generar una celda que contenga números Cell
Debe usar la ruta completa del paquete de Número, de lo contrario habrá ambigüedad de sintaxis
La posición de la celda es la segunda columna, la primera fila y el valor es 789.123*/
jxl.write.Number number = new jxl.write.Number(1,0,789.123);
sheet.addCell(number);
//Escribe datos y cierra el archivo
libro.write();
libro.close();
}catch(Excepción e)
{
System.out.println(e);
}
}
}
Después de la compilación y ejecución, estará en la ubicación actual y produce un archivo de Excel.
2. Leer el archivo
Tome el archivo Excel que acabamos de crear como ejemplo para realizar una operación de lectura simple. El código del programa es el siguiente:
// Leer clase de Excel
importar java.io.*
importar jxl.*
clase pública ReadXLS
{
public static void main(String args[])
{
prueba
{
Libro de trabajo=
Workbook.getWorkbook(new File("Test.xls"));
//Obtener el primer objeto de la hoja de trabajo
Hoja hoja=book. 0);
//Obtener la celda en la primera columna y fila
Celda cell1=sheet.getCell(0,0);
String result=. cell1.getContents();
System.out.println(resultado);
libro.close()
}catch(Exception e )
p>
{
System.out.println(e
}
}
}
Resultado de la ejecución del programa: prueba
4. Modificar archivos
Utilice jExcelAPI para modificar archivos de Excel existentes. Al modificar archivos de Excel, además de abrir el archivo. otras operaciones son las mismas que crear Excel.
El siguiente ejemplo es para agregar una hoja de trabajo al archivo de Excel que hemos generado:
//Modificar la clase de Excel y agregar una hoja de trabajo
import java.io.* < /p; >
importar jxl.*;
importar jxl.write.*
clase pública UpdateXLS
{
pública estática void main(String args[])
{
prueba
{
//Excel obtiene el archivo
Workbook wb=Workbook.getWorkbook(new File("Test.xls"));
//Abra una copia del archivo y escriba los datos especificados en el archivo original
<. p >WritableWorkbook book=Workbook.createWorkbook(new File("test.xls"),wb
//Agregar una hoja de trabajo
Hoja WritableSheet); =book.createSheet("Segunda página",1);
sheet.addCell(new Label(0,0,"Datos de prueba en la segunda página")); .write();
libro.close();
}catch(Excepción e)
{
System.out. println(e);
}
}
}
3. Operaciones avanzadas
Formato de datos
Excel no implica tipos de datos complejos y puede manejar cadenas, números y fechas relativamente bien, lo cual es suficiente para aplicaciones generales.
1. Formato de cadena
El formato de cadena implica elementos como fuente, grosor, tamaño de fuente, etc. Estas funciones son las principales responsables de las clases WritableFont y WritableCellFormat. Supongamos que usamos la siguiente declaración al generar una celda que contiene una cadena. Para facilitar la descripción, hemos numerado cada línea de comandos:
WritableFont font1=
new WritableFont( WritableFont.TIMES. ,16,WritableFont.BOLD); o//Establezca el formato de fuente en el formato admitido por Excel WritableFont font3=new WritableFont(WritableFont.createFont("Kaiti_GB2312"),12,WritableFont.NO_BOLD);① WritableCellFormat format1= new WritableCellFormat( font1); ② Etiqueta etiqueta = nueva etiqueta (0,0”, prueba de datos 4”, formato1) ③ Entre ellos, ① especifica el formato de la cadena: la fuente es TIMES, el tamaño de fuente es 16 y se muestra en negrita. WritableFont tiene un conjunto muy rico de constructores para usar en diferentes situaciones. Hay una lista detallada en el documento java de jExcelAPI, que no se enumerará aquí. El código en ② usa la clase WritableCellFormat. Esta clase es muy importante. Puede especificar varias propiedades de la celda. Habrá más descripciones en el formato de celda posterior. ③El constructor de la clase Label se utiliza para especificar el formato que se le dará a la cadena.
En la clase WritableCellFormat, otro método muy importante es especificar la alineación de los datos. Por ejemplo, para nuestro ejemplo anterior, puede especificar:
//Especificar la alineación horizontal como centrada
<. p>format1.setAlignment(jxl.format.Alignment.CENTRE);//Especifica la alineación vertical como centrada
format1.setVerticalAlignment(jxl.format.VerticalAlignment.CENTRE);
//Establecer ajuste automático de palabras
format1.setWrap(true);
Operaciones de celda
Una parte muy importante de Excel It es una operación en celdas, como altura de fila, ancho de columna, combinación de celdas, etc. Afortunadamente, jExcelAPI proporciona estos soportes. Estas operaciones son relativamente simples y a continuación solo se presentan las API relevantes.
1. Fusionar celdas
WritableSheet.mergeCells(int m,int n,int p,int q
La función es de (m,n); ) a (p, q) se fusionan, por ejemplo:
WritableSheet Sheet=book.createSheet("First Page",0);
//Fusionar las primeras todas las celdas de. la primera fila de la columna a la primera fila de la sexta columna
sheet.mergeCells(0,0,5,0
La combinación puede ser horizontal o vertical); . Las celdas fusionadas no se pueden volver a fusionar; de lo contrario, se activará una excepción.
2. Alto de fila y ancho de columna
WritableSheet.setRowView(int i,int height
La función es especificar la altura de i+); 1ª fila Por ejemplo:
//Establezca la altura de la primera fila en 200
sheet.setRowView(0,200);
WritableSheet.setColumnView(int). i,int width );
La función es especificar el ancho de la i+1ª columna, por ejemplo:
//Establecer el ancho de la primera columna en 30
p>
sheet.setColumnView (0,30);
4. Imágenes de operación
public static void write() lanza una excepción{
WritableWorkbook wwb. =Workbook.createWorkbook(new File( "c:/1.xls"));
WritableSheet ws=wwb.createSheet("Test Sheet 1",0);
Archivo file=new File("C: \\jbproject\\PVS\\WebRoot\\weekhit\\1109496996281.png");
WritableImage image=new WritableImage(1, 4, 6, 18,archivo );
ws.addImage(imagen);
wwb.write();
wwb.close();
}
Very Es tan simple como insertar una celda, pero tiene más parámetros. La clase WritableImage hereda Draw, y lo anterior es solo uno de sus métodos de construcción. No hace falta decir que el último parámetro es de tipo. doble. El orden es x, y, ancho, alto. Tenga en cuenta que el ancho y el alto aquí no son el ancho y el alto de la imagen, sino el número de unidades que ocupará la imagen. Debido a que hereda Draw, su tipo debe ser. doble, específicamente no he visto cómo se implementa en detalle todavía :) Como tengo prisa, completaré las funciones primero y tendré tiempo para estudiar el resto más tarde. Continuaré escribiendo mi experiencia al usarlo en el futuro.
Lectura:
Al leer, la idea es así: primero use un flujo de entrada (InputStream) para obtener el archivo de Excel, luego use el libro de trabajo en jxl para obtener el libro de trabajo. y use Hoja para obtener el libro. Para obtener la hoja de trabajo en el libro, use Celda para obtener una celda determinada en la hoja de trabajo.
InputStream->Libro de trabajo->Hoja->Celda, obtendrá la celda en el archivo de Excel
Código:
String path="c:\\excel.xls";//URL del archivo de Excel
InputStream es = new FileInputStream (ruta);//Escribir en FileInputStream
jxl.Workbook wb = Workbook.getWorkbook(is); //Obtener el libro de trabajo
jxl.Sheet st = wb.getSheet(0) );//Obtener el libro de trabajo La primera hoja de trabajo en
Celda cell=st.getCell(0,0);//Obtener la primera celda de la hoja de trabajo, es decir, A1
Cadena content= cell.getContents();//getContents() convierte los caracteres de Cell en cadenas
wb.close();//Cerrar el libro
is.close() ;//Cerrar el flujo de entrada
Podemos obtener cualquier celda a través del método getCell(x, y) de Sheet, y x, y corresponde a las coordenadas en Excel.
Por ejemplo, A1 corresponde a (0,0), A2 corresponde a (0,1) y D3 corresponde a (3,2). Las coordenadas en Excel comienzan desde A,1, pero en jxl todas comienzan desde 0.
También puedes pasar Los métodos getRows() y getColumns() de Sheet obtienen el número de filas y columnas, y se utilizan para el control de bucle para generar todo el contenido de una hoja.
Escribir :
Escribir contenido en Excel utilizando principalmente las clases del paquete jxl.write.
La idea es la siguiente:
OutputStream<-WritableWorkbook<-WritableSheet <-Label
La etiqueta interior representa la ubicación de la celda y el contenido escrito en la hoja.
Código:
OutputStream os=new FileOutputStream("c:\ \test.xls");//URL de salida del archivo Excel
WritableWorkbook wwb = Workbook.createWorkbook(os);//Crear un libro de trabajo grabable
WritableSheet ws = wwb.createSheet( "sheet1", 0);//Crear hoja de trabajo grabable
Label labelCF=new Label(0, 0, "hello");//Crear ubicación y contenido de escritura
ws. addCell(labelCF);// Escribe la etiqueta en la hoja
Constructor de la etiqueta Label(int x, int y, String aString) xy significa xy al leer, y aString es el contenido escrito.
WritableFont wf = new WritableFont(WritableFont.TIMES, 12, WritableFont.BOLD, false);//Establecer la fuente de escritura
WritableCellFormat wcfF = new WritableCellF
ormat(wf);//Establecer CellFormat
Etiqueta labelCF=new Label(0, 0, "hello");//Crear ubicación de escritura, contenido y formato
Etiqueta Otro constructor , Etiqueta (int c, int r, String cont, CellFormat st), puede formatear el contenido escrito, configurar la fuente y otros atributos.
Ahora puedes escribir
wwb.write ();
Cerrar después de escribir
wwb.close();
Cerrar también el flujo de salida
os.close;
Bien, siempre que combine lectura y escritura, puede leer datos en N Excel y escribirlos en la nueva tabla de Excel que desee.
Lo siguiente. es un ejemplo de un programa:
Código de programa: sql = "select * from tablename";
rs = stmt.executeQuery(sql);
/ /Nuevo archivo Excel
String filePath=request.getRealPath("aaa.xls");
Archivo myFilePath=new File(filePath);
if( !myFilePath.exists())
myFilePath.createNewFile();
FileWriter resultFile=new FileWriter(myFilePath);
PrintWriter myFile=nuevo PrintWriter (resultFile );
resultFile.close();
//Utilice JXL para agregar contenido al archivo recién creado
OutputStream outf = new FileOutputStream(filePath) ;
jxl.write.WritableWorkbook wwb = Workbook.createWorkbook(outf);
jxl.write.WritableSheet ws = wwb.createSheet("sheettest", 0);
int i=0;
int j=0;
for (int k = 0; k < rs.getMetaData().getColumnCount(); k++) {
ws.addCell(new Label(k,0,rs.getMetaData().getColumnName(k+1)));
}
while( rs .next()){
out.println(rs.getMetaData().getColumnCount());
for (int k = 0; k < rs.getMetaData() . getColumnCount(); k++) {
ws.addCell(nueva etiqueta(k,j+i+1,rs.getString(k+1)));
} < / p>
i++;
}
wwb.write();
wwb.close();
} captura (Excepción e){e.printSta
ckTrace();}
finalmente{
rs.close();
conn.close();
} p>
respuesta.sendRedirect("aaa.xls");