{"id":5000,"date":"2010-10-26T15:04:16","date_gmt":"2010-10-26T13:04:16","guid":{"rendered":"https:\/\/www.artera.net\/it\/blog\/?p=5000"},"modified":"2023-02-27T14:53:36","modified_gmt":"2023-02-27T14:53:36","slug":"utilizzare-jasper-reports-creare-report-da-java","status":"publish","type":"post","link":"https:\/\/www.artera.net\/it\/sviluppo\/utilizzare-jasper-reports-creare-report-da-java\/","title":{"rendered":"Utilizzare Jasper Reports – Creare report da Java"},"content":{"rendered":"

\"UtilizzareNella scorsa puntata<\/a> con l’aiuto di Maven abbiamo creato la struttura di base di un progetto Java, pre-configurato con le librerie necessarie a Jasper Reports e gli automatismi necessari per compilare i report. In questo appuntamento vedremo quindi come creare i report direttamente dal nostro codice Java<\/strong>.<\/p>\n

Il codice Java<\/h3>\n

Per vedere in azione la compilazione avevamo creato il report src\/main\/jasperreports\/testReport.jrxml<\/em>, che veniva compilato in target\/classes\/testReport.jasper<\/em>. Ricordiamo che i file con estensione .jasper sono dei file binari<\/strong> (ecco perch\u00e9 devono essere compilati), pronti per essere eseguiti<\/strong>; il termine compilazione<\/em> \u00e8 usato proprio per questo motivo!<\/p>\n

La generazione automatica del progetto dovrebbe aver creato una classe App<\/em> nella directory src\/main\/java\/it\/artera\/jr\/App.java<\/em>, e il relativo test JUnit<\/a> AppTest<\/em> in src\/test\/java\/it\/artera\/jr\/AppTest.java<\/em>. Maven infatti promuove appieno le pratiche di sviluppo Agile<\/em>, ad esempio il Test-Driven Development<\/a><\/em> (TDD<\/em>), che prevede che vengano scritti prima i test e poi il codice che li fa andare a buon fine. Per questo motivo la fase di test ha un ruolo importante nel ciclo di compilazione-packaging-deploy.<\/p>\n

Scriviamo dunque il nostro primo test; aggiungiamo il seguente metodo all’interno della classe AppTest<\/em>:<\/p>\n

[java]public void test_sampleReport() throws Exception {
\n \/\/ crea l’istanza di App
\n App app = new App();
\n \/\/ esegui il report
\n app.sampleReport("target\/test\/testReport.pdf");
\n \/\/ controlla che venga scritto il file di output
\n assertTrue(new File("target\/test\/testReport.pdf").exists());
\n}[\/java]<\/p>\n

Il comando<\/p>\n

[java]mvn test[\/java]<\/p>\n

compila i file modificati ed eseguire tutti i test. Se proviamo a lanciarlo, otteniamo un errore:<\/p>\n

[java]——————————————————-
\n T E S T S
\n——————————————————-
\nRunning it.artera.jr.AppTest
\nTests run: 1, Failures: 0, Errors: 1, Skipped: 0, Time elapsed: 0.028 sec &lt;&lt;&lt; FAILURE!<\/p>\n

Results :<\/p>\n

Tests in error:
\n test_sampleReport(it.artera.jr.AppTest)<\/p>\n

Tests run: 1, Failures: 0, Errors: 1, Skipped: 0<\/pre>
\nLa classe <em>App<\/em> infatti non ha un metodo <em>sampleReport()<\/em>. Modifichiamo quindi <em>App<\/em> in questo modo:
\n<pre>package it.artera.jr;<\/p>\n

import java.io.File;
\nimport java.io.FileOutputStream;
\nimport java.io.InputStream;
\nimport java.io.OutputStream;
\nimport java.util.ArrayList;
\nimport java.util.Collection;
\nimport java.util.HashMap;
\nimport java.util.Map;<\/p>\n

import net.sf.jasperreports.engine.JasperRunManager;
\nimport net.sf.jasperreports.engine.data.JRMapCollectionDataSource;<\/p>\n

\/**
\n * Hello world!
\n *
\n *\/
\npublic class App {<\/p>\n

public void sampleReport(String outputDir) throws Exception {
\n \/\/ carica il report compilato
\n InputStream is = getClass().getResourceAsStream("\/testReport.jasper");<\/p>\n

\/\/ imposta directory e file di output
\n File outDir = new File(outputDir);
\n outDir.mkdirs();
\n OutputStream os = new FileOutputStream(new File(outDir, "testReport.pdf"));<\/p>\n

\/\/ crea una java.util.Collection contenente dei dati
\n Collection data = createSampleData();
\n \/\/ la avvolge in un’implementazione di JRDataSource
\n JRMapCollectionDataSource dataSource = new JRMapCollectionDataSource(data);<\/p>\n

JasperRunManager.runReportToPdfStream(is, os, null, dataSource);
\n }<\/p>\n

private Collection createSampleData() {
\n Map row;
\n Collection data = new ArrayList();<\/p>\n

row = new HashMap();
\n row.put("name", "Lorem");
\n data.add(row);<\/p>\n

row = new HashMap();
\n row.put("name", "Ipsum");
\n data.add(row);<\/p>\n

row = new HashMap();
\n row.put("name", "Docet");
\n data.add(row);<\/p>\n

return data;
\n }
\n}[\/java]<\/p>\n

Vi ricordate il report di prova? Aveva solamente un campo chiamato name<\/em>. Nel codice qui sopra vediamo come ai report Jasper sia possibile passare una qualsiasi collezione di dati<\/strong>, purch\u00e9 correttamente inizializzata, ed essi verranno correttamente formattati senza doversi preoccupare della loro provenienza<\/strong>!
\nIn questo caso la Collection<\/em> fornita dal metodo createSampleData()<\/em> viene avvolta (wrapped) in un oggetto JRMapCollectionDataSource<\/em>; questa classe implementa l’interfaccia net.sf.jasperreports.engine.JRDataSource<\/em>, il cui scopo \u00e8 fare da tramite fra i report e i dati. Molto comodo!<\/p>\n

Rilanciamo il comando<\/p>\n

[java]mvn test[\/java]<\/p>\n

A questo punto otterremo una schermata simile a questa:<\/p>\n

[java]——————————————————-
\n T E S T S
\n——————————————————-
\nRunning it.artera.jr.AppTest
\nTests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.812 sec<\/p>\n

Results :<\/p>\n

Tests run: 1, Failures: 0, Errors: 0, Skipped: 0<\/p>\n

[INFO] ————————————————————————
\n[INFO] BUILD SUCCESSFUL
\n[INFO] ————————————————————————
\n[\/java]<\/p>\n

Il report<\/h3>\n

Andando a controllare nella directory target\/test<\/em> scopriamo che c’\u00e8 un file testReport.pdf<\/em>: il nostro primo report!<\/p>\n

Linkografia<\/h3>\n