Database
 sql >> Database >  >> RDS >> Database

Come creare un documento Excel da un programma Java utilizzando Apache POI

Il PDI di Apache è una popolare libreria open source utilizzata per leggere, scrivere e manipolare file MS Office e Open Office utilizzando codice Java. La libreria è uno dei tanti prodotti open source gestiti da Apache Software Foundation (ASF) ha contribuito alla comunità Java. La libreria contiene classi e metodi per decodificare i formati di file basati sugli standard Open Office XML e Microsoft OLE2. Sebbene la libreria sia in grado di manipolare file di Word, Excel e PowerPoint, questo articolo si concentra principalmente sui fogli di calcolo, solo per renderlo breve.

Impara JAVA e inizia la tua prova gratuita oggi!

La libreria PDI di Apache

È interessante notare che nel nome Apache POI, POI sta per "Poor Offuscation Implementation" e l'obiettivo della libreria è fornire API Java per manipolare vari formati di file basati sugli standard Office Open XML (OOXML) e sul formato di documento composto OLE 2 di Microsoft (OLE2). In breve, ciò consente di leggere e scrivere file MS Excel, MS Word e MS PowerPoint utilizzando il codice Java. La maggior parte dei file di Microsoft Office, come XLS, DOC, PPT e formati di file basati su API di serializzazione MFC, sono basati sullo standard OLE2. L'OLE, fondamentalmente, è una tecnica proprietaria sviluppata di Microsoft e fornisce il formato per collegare oggetti e incorporare oggetti all'interno di documenti contenitore. Il primo formato è denominato formato OLE1.0 in cui l'oggetto collegato ei dati dell'oggetto incorporato sono disposti come una sequenza di byte all'interno del documento contenitore. La seconda versione, il formato OLE2.0, sfrutta OLE Compound File Technology (MS-CFB) in cui l'oggetto collegato oi dati dell'oggetto incorporato sono contenuti in questo archivio sotto forma di oggetti OLE Compound File Stream. Fare riferimento ai formati OLE1.0 e OLE2.0 per ulteriori dettagli su questo. La libreria Apache POI fornisce API di libreria per il file system OLE2 chiamato POIFS e OLE2 Document Properties chiamato HPSF.

Componenti PDI di Apache

La libreria Apache POI fornisce classi e metodi per lavorare con i documenti composti OLE2 di MS Office. Ecco una breve panoramica di quelli più comunemente usati:

  • POIFS per i documenti OLE2:POIFS sta per Poor Offuscation Implementation File System . Questo è l'elemento POI di base implementato nella libreria per trasferire il documento composto OLE2. Supporta la funzionalità di lettura e scrittura per il formato binario Microsoft Office non XML. Tutte le API della libreria POI sono basate su questo.
  • HSSF e XSSF:HSSF sta per Horrible Spread Sheet Format . È una porta di implementazione Java per il formato di file Excel 97 o per i file .xls. XSSF sta per Formato foglio elettronico XML ed è una porta per il formato file OOXML o il formato file .xlsx.
  • HWPF e XWPF:HWPF sta per Horrible Word Processor Format . È una porta di sola lettura limitata per il vecchio formato di file Word 6 o Word 95. XWPF sta per XML Word Processor Format . È una porta di implementazione Java per il formato di file .docx di Word 2007. Entrambe le implementazioni supportano funzionalità limitate.
  • HSLF e XSLF:HSLF sta per Horrible Slide Layout Format . XSLF sta per Formato layout diapositiva XML . Entrambi forniscono funzionalità di lettura, scrittura, creazione e modifica di presentazioni PowerPoint, mentre HSLF supporta il formato PowerPoint 97 e XSLF supporta versioni successive.
  • HPSF :HPSF sta per Horrible Property Set Format . È particolarmente utilizzato per lavorare con le proprietà del documento come l'impostazione del titolo, della categoria, dell'autore, della data di modifica e così via di un documento
  • HDGF e XDGF:HDGF sta per Horrible Diagram Format . Questo componente contiene classi per lavorare con il formato di file binario di Visio. Fornisce API di sola lettura di basso livello per accedere ai documenti Visio e ai file VSD. XDGF sta per XML Diagram Format . È per il formato di file XML di Visio oi file VSDX.
  • HPBF :HPBF sta per Horrible Publisher Format . È una porta Java limitata per funzionare con il formato di file MS Publisher.

Gli acronimi suonano divertenti perché questi file system avrebbero dovuto essere chiusi e Microsoft ha fatto del suo meglio per offuscare il codice in modo che non fossero solo difficili da capire ma anche difficili da decodificare. Ma gli sviluppatori di Apache lo hanno hackerato con facilità e lo hanno decodificato con successo. Forse, in segno di gioia o di totale condanna del sistema chiuso, li hanno scherzosamente chiamati come tali.

Lavorare con file HSSF e XSSF

I componenti HSSF e XSSF della libreria Apache forniscono tre modelli di accesso a un foglio di calcolo secondo la documentazione HSSF e XSSF. Sono:

  • Strutture di basso livello per bisogni speciali
  • Le API eventmodel per l'accesso in sola lettura ai documenti Excel
  • Le API usermodel per la creazione, la lettura e la modifica di file Excel

Le API eventmodel limitate possono essere utilizzate solo per leggere i dati del foglio di calcolo. Queste API si trovano in org.apache.poi.hssf.eventusermodel pacchetto e org.apache.poi.xssf.eventusermodel pacchetto, dove il primo viene utilizzato per leggere i dati da .xls formato file e il secondo è usato per leggere i dati da .xlsx formato file.

Il modello utente è molto più flessibile e facile da usare; può leggere, scrivere, creare e modificare un foglio di calcolo Excel. Tuttavia, ha un footprint di memoria molto più elevato rispetto al modello di eventi di basso livello.

Inoltre, l'accesso e la manipolazione del nuovo formato di file basato su OOXML con XSSF ha un footprint di memoria molto più elevato rispetto ai vecchi file binari supportati da HSSF.

Dal POI 3.5 in poi, il modello HSSF e XSSF è stato inserito nel modello SS, piuttosto ottimizzato per funzionare con entrambi i modelli. È più una modifica del nome che un vero cambiamento. In un certo senso, possiamo dire che SS=HSSF+XSSF.

Migrazione dei dati della tabella del database in un foglio di calcolo Excel

Qui creeremo un semplice programma di utilità per migrare alcuni dati del database in un foglio Excel. Questo può anche essere ottimizzato per funzionare con altri modi, come la migrazione dei dati di Excel in una tabella di database. Questo è lasciato come esercizio per il lettore. Il programma è semplice e autoesplicativo. Visita la documentazione Apache POI per informazioni dettagliate su qualsiasi classe o metodo. Per provare il seguente esempio, quello che abbiamo usato è il seguente:

  • JDK 8
  • MS Excel 2007
  • IDE INtellij IDEA
  • Apache PDI 3.17
  • Apache Derby 10.14

Visita i documenti appropriati e i file della guida per l'impostazione del progetto. Ecco i contenuti del file Maven pom.xml che abbiamo usato.

<project 
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>com.mano.examples</groupId>
   <artifactId>apache-poi-demo</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>apache-poi-demo</name>
   <url>http://maven.apache.org</url>

   <properties>
      <project.build.sourceEncoding>
         UTF-8
      </project.build.sourceEncoding>
   </properties>

   <build>
      <plugins>
         <plugin>
            <artifactId>
               maven-compiler-plugin
            </artifactId>
            <version>3.7.0</version>
            <configuration>
               <source>1.8</source>
               <target>1.8</target>
            </configuration>
         </plugin>
      </plugins>
   </build>

   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>
         <version>3.8.1</version>
         <scope>test</scope>
      </dependency>

      <!-- https://mvnrepository.com/artifact
         /org.apache.maven.plugins/maven-compiler-plugin -->
      <dependency>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-compiler-plugin</artifactId>
         <version>3.7.0</version>
      </dependency>

      <!-- https://mvnrepository.com/artifact/
         org.apache.poi/poi -->
      <dependency>
         <groupId>org.apache.poi</groupId>
         <artifactId>poi</artifactId>
         <version>3.17</version>
      </dependency>

      <!-- https://mvnrepository.com/artifact/
         org.apache.poi/poi-ooxml -->
      <dependency>
         <groupId>org.apache.poi</groupId>
         <artifactId>poi-ooxml</artifactId>
         <version>3.17</version>
      </dependency>

      <!-- https://mvnrepository.com/artifact/
         org.apache.derby/derby -->
      <dependency>
         <groupId>org.apache.derby</groupId>
         <artifactId>derby</artifactId>
         <version>10.14.1.0</version>
         <scope>test</scope>
      </dependency>

      <!-- https://mvnrepository.com/artifact/
         org.apache.derby/derbyclient -->
      <dependency>
         <groupId>org.apache.derby</groupId>
         <artifactId>derbyclient</artifactId>
         <version>10.14.1.0</version>
      </dependency>

   </dependencies>
</project>

Listato 1: pom.xml

Viene creata una tabella di database con alcuni record fittizi prima di eseguire il programma di utilità. Ecco il codice di quel file.

package com.mano.examples;

import java.sql.*;


public class DummyDatabase {

   public static void createDummyDatabase()
         throws SQLException {
      Connection con=DriverManager.getConnection
         ("jdbc:derby:D:/temp/dummy;create=true");
      Statement stmt=con.createStatement();
      stmt.executeUpdate("drop table semester2");
      stmt.executeUpdate("CREATE TABLE semester2(STUDENT_ID int,
         CARCH INT, DCE INT, WEBTECH INT, JAVA INT, SAD_MIS INT,
         PRIMARY KEY(STUDENT_ID))");

      // Insert 2 rows
      stmt.executeUpdate("insert into semester2
         values (23567932,56,78,97,58,85)");
      stmt.executeUpdate("insert into semester2
         values (47250001,96,34,75,68,12)");
      stmt.executeUpdate("insert into semester2
         values (99568955,45,68,69,78,29)");
      stmt.executeUpdate("insert into semester2
         values (89376473,75,23,56,89,47)");
      stmt.executeUpdate("insert into semester2
         values (29917740,85,78,55,15,48)");
      stmt.executeUpdate("insert into semester2
         values (85776649,23,56,78,25,69)");
      stmt.executeUpdate("insert into semester2
         values (38846455,68,95,78,53,48)");
      stmt.executeUpdate("insert into semester2
         values (40028826,63,56,48,59,75)");
      stmt.executeUpdate("insert into semester2
         values (83947759,85,54,69,36,89)");
      stmt.executeUpdate("insert into semester2
         values (92884775,78,59,25,48,69)");
      stmt.executeUpdate("insert into semester2
         values (24947389,12,10,14,54,68)");
      stmt.executeUpdate("insert into semester2
         values (77399465,44,33,26,88,77)");

      // Query
      ResultSet rs = stmt.executeQuery
      ("SELECT * FROM semester2");

      // Print out query result
      while (rs.next()) {
         System.out.printf
               ("%dt%dt%dt%dt%dt%dn",
            rs.getLong("STUDENT_ID"),
            rs.getInt("CARCH"),
            rs.getInt("DCE"),
            rs.getInt("WEBTECH"),
            rs.getInt("JAVA"),
            rs.getInt("SAD_MIS"));
      }
      stmt.close();
      con.close();
   }
}

Listato 2: DummyDatabase.java.

Questo è il programma di utilità di cui stiamo parlando. Il codice è stato scritto in grande fretta e la struttura non molto elegante. Tuttavia, funziona. Ristrutturalo o modificalo come ritieni opportuno.

package com.mano.examples;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.*;
import org.apache.poi.xssf.usermodel.XSSFWorkbook;


import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.sql.*;

public class SSFile {

   private static String[] header={"STUDENT_ID",
      "CARCH", "DCE", "WEBTECH", "JAVA",
      "SAD_MIS", "TOTAL", "AVERAGE"};

   public static void databaseToExcel(File file)
         throws IOException, SQLException {
      Workbook workbook = null;
      if (file.getName().endsWith(".xls"))
         workbook = new HSSFWorkbook();
      else if (file.getName().endsWith(".xlsx"))
         workbook = new XSSFWorkbook();
      else {
         System.out.println("Invalid filename!");
         return;
      }
      Sheet sheet = workbook.createSheet();
      Connection con = DriverManager.getConnection
         ("jdbc:derby:D:/temp/dummy;create=true");
      Statement stmt = con.createStatement();
      ResultSet rs = stmt.executeQuery("SELECT * FROM semester2");



      Row rr = sheet.createRow(0);
      for(int i=0;i<header.length;i++){
         createHeaderCell(rr, (short) i, header[i]);
      }

      int i = 1;
      while (rs.next()) {
         rr = sheet.createRow(i++);
         for(int j=0;j<header.length-2;j++){
            createDataCell(rr, (short) j,
               rs.getLong(header[j]));
         }
      }
      rr = sheet.getRow(1);
      Cell total = rr.createCell(6);
      total.setCellType(CellType.FORMULA);
      total.setCellFormula("SUM(B2:F2)");
      Cell avg = rr.createCell(7);
      avg.setCellType(CellType.FORMULA);
      avg.setCellFormula("AVERAGE(B2:F2)");

      FileOutputStream outFile = new
         FileOutputStream(file);
      workbook.write(outFile);
      outFile.flush();
      outFile.close();
      stmt.close();
      con.close();
   }

   private static void createHeaderCell(Row row,
         short col, String cellValue) {
      Cell c = row.createCell(col);
      c.setCellValue(cellValue);
   }

   private static void createDataCell(Row row,
         short col, Number cellValue) {
      Cell c = row.createCell(col);
      c.setCellType(CellType.NUMERIC);
      c.setCellValue(cellValue.doubleValue());
   }
}

Listato 3: SSFile.java

Questo è il pannello di controllo da cui viene richiamato il programma di utilità.

package com.mano.examples;

import java.io.File;
import java.io.IOException;
import java.sql.SQLException;

public class App
{
   public static void main( String[] args )
         throws IOException,SQLException{
      // DummyDatabase.createDummyDatabase();
      SSFile.databaseToExcel(new
         File("d://temp//test1.xls"));
   }
}

Listato 4 :App.java

Prima di correre...

Assicurati che test1.xls o test1.xlsx i file non esistono in d://temp directory prima di eseguire il programma perché il programma non sovrascrive né controlla il file con lo stesso nome nella directory in cui dovrebbe essere creato il file. Assicurati di farlo ogni volta che il programma viene eseguito; in caso contrario, il codice fornisce un brutto messaggio di errore. Tuttavia, puoi modificare il codice per controllare.

Conclusione

Esiste un'altra alternativa al lavoro con i fogli di calcolo, come suggerisce la documentazione Apache POI tramite il serializzatore Cocoon, sebbene utilizzi ancora HSSF indirettamente. Cocoon può serializzare qualsiasi origine dati XML applicando il foglio di stile e designando il serializzatore. Il modello HSSF e XSSF è piuttosto potente e fornisce una serie di classi e metodi per gestire diversi aspetti di un documento Excel. Questo articolo ha cercato di dare un'idea di cosa possiamo fare con Apache POI. Spesso abbiamo bisogno di scrivere un programma di utilità per collegare un sistema aperto e chiuso. Apache POI può sicuramente servire al nostro scopo come unico nel suo genere.

Riferimenti

  • Apache POI:l'API Java per documenti Microsoft
  • POI-HSSF e POI-XSSF:API Java per accedere ai file in formato Microsoft Excel