TOC

JasperReports mit Frühling

JasperReports mit Frühling

1. Überblick

JasperReports ist eine Open-Source-Berichtsbibliothek, mit der Benutzer pixelgenaue Berichte erstellen können, die in vielen Formaten wie PDF, HTML und XLS gedruckt oder exportiert werden können.

In diesem Artikel werden die wichtigsten Funktionen und Klassen erläutert und Beispiele implementiert, um die Funktionen zu demonstrieren.

2. Maven-Abhängigkeit

Zuerst müssen wir die Abhängigkeit vonjasperreportszu unserenpom.xmlhinzufügen: 


    net.sf.jasperreports
    jasperreports
    6.4.0

Die neueste Version dieses Artefakts befindet sich inhere.

3. Berichtsvorlagen

Berichtsentwürfe werden in JRXML-Dateien definiert. Hierbei handelt es sich um gewöhnliche XML-Dateien mit einer bestimmten Struktur, die die JasperReports-Engine interpretieren kann.

Schauen wir uns nun nur die relevante Struktur der JRXML-Dateien an, um den Java-Teil des Berichtserstellungsprozesses, der unser Hauptaugenmerk ist, besser zu verstehen.

Erstellen wir einen einfachen Bericht, in dem Mitarbeiterinformationen angezeigt werden:

3.1. Berichte erstellen

JRXML-Dateien müssen kompiliert werden, damit die Berichts-Engine sie mit Daten füllen kann.

Führen Sie diese Operation mit Hilfe der KlasseJasperCompilerManageraus: 

InputStream employeeReportStream
  = getClass().getResourceAsStream("/employeeReport.jrxml");
JasperReport jasperReport
  = JasperCompileManager.compileReport(employeeReportStream);

Um zu vermeiden, dass es jedes Mal kompiliert wird, können wir es in einer Datei speichern: 

JRSaver.saveObject(jasperReport, "employeeReport.jasper");

4. Bevölkern Berichte

Am häufigsten werden kompilierte Berichte mit Datensätzen aus einer Datenbank gefüllt. Dazu muss der Bericht eine SQL-Abfrage enthalten, die die Engine ausführt, um die Daten abzurufen.

Ändern Sie zunächst unseren Bericht, um eine SQL-Abfrage hinzuzufügen: 


    
        
    
    ...

Erstellen wir nun eine einfache Datenquelle: 

@Bean
public DataSource dataSource() {
    return new EmbeddedDatabaseBuilder()
      .setType(EmbeddedDatabaseType.HSQL)
      .addScript("classpath:employee-schema.sql")
      .build();
}

Jetzt können wir den Bericht füllen: 

JasperPrint jasperPrint = JasperFillManager.fillReport(
  jasperReport, null, dataSource.getConnection());

Beachten Sie, dass wirnull an das zweite Argument übergeben, da unser Bericht noch keine Parameter erhält.

4.1. Parameter

Parameter sind nützlich, um Daten an das Berichtsmodul zu übergeben, die es in seiner Datenquelle nicht finden kann, oder wenn sich Daten abhängig von verschiedenen Laufzeitbedingungen ändern.

Wir können auch Teile oder sogar die gesamte SQL-Abfrage mit Parametern ändern, die beim Ausfüllen des Berichts erhalten wurden.

Ändern Sie zunächst den Bericht, um drei Parameter zu erhalten: 


    
    
    
        
          
    
    // ...

Fügen wir nun einen Titelabschnitt hinzu, um den Parametertitleanzuzeigen: 


    // ...
    
        <band height="20" splitType="Stretch">
            <textField>
                <reportElement x="238" y="0" width="100" height="20"/>
                <textElement/>
                <textFieldExpression class="java.lang.String">
                  <![CDATA[$P{title}]]></textFieldExpression>
            </textField>
        </band>
    
    ...

Als Nächstes ändern wir die Abfrage so, dass die ParameterminSalary undconditionverwendet werden: 

SELECT * FROM EMPLOYEE
  WHERE SALARY >= $P{minSalary} AND $P!{condition}

Beachten Sie die unterschiedliche Syntax bei Verwendung des Parameterscondition. Dies teilt der Engine mit, dass der Parameter nicht als StandardparameterPreparedStatementverwendet werden soll, sondern als ob der Wert dieses Parameters ursprünglich in die SQL-Abfrage geschrieben worden wäre.

Zum Schluss bereiten wir die Parameter vor und füllen den Bericht aus: 

Map parameters = new HashMap<>();
parameters.put("title", "Employee Report");
parameters.put("minSalary", 15000.0);
parameters.put("condition", " LAST_NAME ='Smith' ORDER BY FIRST_NAME");

JasperPrint jasperPrint
  = JasperFillManager.fillReport(..., parameters, ...);

Beachten Sie, dass die Schlüssel vonparameters den Parameternamen im Bericht entsprechen. Wenn der Motor feststellt, dass ein Parameter fehlt, erhält er den Wert ausdefaultValueExpression des Parameters, falls vorhanden.

5. Exportieren

Um einen Bericht zu exportieren, instanziieren wir zunächst ein Objekt einer Exporter-Klasse, das dem von uns benötigten Dateiformat entspricht.

Anschließend legen wir unseren zuvor ausgefüllten Bericht als Eingabe fest und legen fest, wo die resultierende Datei ausgegeben werden soll.

Optional können wir entsprechende Berichts- und Exportkonfigurationsobjekte festlegen, um den Exportprozess anzupassen.

5.1. PDF 

JRPdfExporter exporter = new JRPdfExporter();

exporter.setExporterInput(new SimpleExporterInput(jasperPrint));
exporter.setExporterOutput(
  new SimpleOutputStreamExporterOutput("employeeReport.pdf"));

SimplePdfReportConfiguration reportConfig
  = new SimplePdfReportConfiguration();
reportConfig.setSizePageToContent(true);
reportConfig.setForceLineBreakPolicy(false);

SimplePdfExporterConfiguration exportConfig
  = new SimplePdfExporterConfiguration();
exportConfig.setMetadataAuthor("example");
exportConfig.setEncrypted(true);
exportConfig.setAllowedPermissionsHint("PRINTING");

exporter.setConfiguration(reportConfig);
exporter.setConfiguration(exportConfig);

exporter.exportReport();

5.2. XLS 

JRXlsxExporter exporter = new JRXlsxExporter();

// Set input and output ...
SimpleXlsxReportConfiguration reportConfig
  = new SimpleXlsxReportConfiguration();
reportConfig.setSheetNames(new String[] { "Employee Data" });

exporter.setConfiguration(reportConfig);
exporter.exportReport();

5.3. CSV 

JRCsvExporter exporter = new JRCsvExporter();

// Set input ...
exporter.setExporterOutput(
  new SimpleWriterExporterOutput("employeeReport.csv"));

exporter.exportReport();

5.4. HTML 

HtmlExporter exporter = new HtmlExporter();

// Set input ...
exporter.setExporterOutput(
  new SimpleHtmlExporterOutput("employeeReport.html"));

exporter.exportReport();

6. Unterberichte

Unterberichte sind nichts anderes als ein Standardbericht, der in einen anderen Bericht eingebettet ist.

Erstellen wir zunächst einen Bericht, in dem die E-Mails eines Mitarbeiters angezeigt werden:

Ändern wir nun unseren Mitarbeiterbericht so, dass er den vorherigen enthält:

Beachten Sie, dass wir den Unterbericht mit dem Namen der kompilierten Datei referenzieren und ihm dieidEmployee und die aktuelle Berichtsverbindung als Parameter übergeben.

Als nächstes kompilieren wir beide Berichte: 

InputStream employeeReportStream
  = getClass().getResourceAsStream("/employeeReport.jrxml");
JasperReport jasperReport
  = JasperCompileManager.compileReport(employeeReportStream);
JRSaver.saveObject(jasperReport, "employeeReport.jasper");

InputStream emailReportStream
  = getClass().getResourceAsStream("/employeeEmailReport.jrxml");
JRSaver.saveObject(
  JasperCompileManager.compileReport(emailReportStream),
  "employeeEmailReport.jasper");

Unser Code zum Ausfüllen und Exportieren des Berichts erfordert keine Änderungen.

7. Fazit

In diesem Artikel haben wir uns kurz mit den Kernfunktionen der JasperReports-Bibliothek befasst.

Wir konnten Berichte zusammenstellen und mit Datensätzen aus einer Datenbank füllen. Wir haben Parameter übergeben, um die im Bericht angezeigten Daten an unterschiedliche Laufzeitbedingungen anzupassen, Unterberichte eingebettet und sie in die gängigsten Formate exportiert.

Den vollständigen Quellcode für diesen Artikel finden Sie unterover on GitHub.

Related