iReport: come creare facilmente report in Java
La generazione di report è una di quelle cose che nell’informatica capita spesso su diversi progetti. In questo articolo vedremo come è possibile utilizzare un semplice ma potente tool che ci aiuta nella creazione dei report
Introduzione
iReport è un programma Java realizzato da Giulio Toffoli e che si basa su un altro grande framework che sicuramente avrete sentito nominare: JasperReport. Quest’ultimo è un potente framework per la generazione di report in tutte le salse e come ogni tool che offre tante funzionalità è anche leggermente complicato in qualche sua feature. Proprio per questo motivo possiamo utilizzare iReport che ci permette in maniera visuale di costruire dei report anche molto complicati.
Setup dell’ambiente
Come primo esempio utilizzeremo alcuni dati presenti sul nostro database MySQL, in una tabella MAGAZZINO definita nel seguente modo
CREATE TABLE `test`.`MAGAZZINO` ( `ID` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT, `ITEM` VARCHAR(45) NOT NULL DEFAULT '', `QUANTITA` INTEGER UNSIGNED NOT NULL DEFAULT '', `DISLOCAZIONE` VARCHAR(45) NOT NULL DEFAULT '', `FORNITORE` VARCHAR(45) NOT NULL DEFAULT '', PRIMARY KEY(`ID`) )ENGINE = InnoDB;
Dovremo inserire alcuni dati in questo database, in modo tale che il nostro report contenga chiaramente qualche informazione. Successivamente possiamo passare all’installazione di iReport, che potete scaricare dal sito ufficiale : http://www.jasperforge.org/jaspersoft/opensource/business_intelligence/ireport/.
Una volta installato, prima di avviarlo dovrete inserire nella cartella lib della sua installazione le librerie JDBC che servono per il collegamento a MySQL (se non sono già presenti con la distribuzione). A questo punto potete avviare il programma.
Costruzione del report
Per descrivere meglio la costruzione passo passo del report potete cliccare sul seguente link che è un semplice filmato dove vengono fatti un pò di esperimenti con il nostro iReport
Il file JRXML
Quello che viene salvato alla fine della nostra elaborazione con iReport è un file JRXML (JasperReports XML), che descrive come deve essere fatto il nostro report per filo e per segno. Di seguito potete trovare il pezzo all’interno del file JRXML, risultante dal report che abbiamo realizzato nel filmato, relativo alla sezione SUMMARY dove abbiamo inserito un grafico a torta collegandolo ai nostri dati
<summary>
<band height="300" isSplitAllowed="true" >
<pie3DChart>
<chart hyperlinkTarget="Self" >
<reportElement x="73" y="13" width="377" height="271" key="element-91"/>
<box></box>
<chartLegend textColor="#000000" backgroundColor="#FFFFFF" >
</chartLegend>
</chart>
<pieDataset>
<dataset >
</dataset>
<keyExpression><![CDATA[$F{ITEM}]]></keyExpression>
<valueExpression><![CDATA[$F{QUANTITA}]]></valueExpression>
<labelExpression><![CDATA[$F{ITEM}]]></labelExpression>
<sectionHyperlink >
</sectionHyperlink>
</pieDataset>
<pie3DPlot >
<plot />
</pie3DPlot>
</pie3DChart>
</band>
</summary>
La sintassi è abbastanza semplice ma comunque dover elaborare un complesso report richiederebbe uno skill elevato su JasperReport, mentre nella maggior parte dei casi quello che serve è qualcosa di semplice, che può essere appunto generata tramite iReport
Un Bean Datasource
La situazione che abbiamo descritto precedentemente, ovvero quella di raccogliere i dati che ci interessano da un datasource JDBC è quella ottimale, perchè i dati sono già lì pronti e noi dobbiamo fare ben poco per organizzarli nel report. JasperReports permette di avere a disposizione diversi tipi di DataSource da cui attingere le informazioni ed ora ne vedremo un altro che può permetterci di realizzare dei report senza dover necessariamente immagazzinare i dati in un DB. Creare un Bean Datasource significa poter passare all’engine di JasperReport (e quindi anche tramite iReport) un singolo bean Java o una collezione di bean che potranno essere utilizzati per valorizzare alcuni campi del nostro report. Prima di tutto dobbiamo avere la classica classe Java Bean, come la seguente
package test;
public class Persona {
private String nome;
private String cognome;
private String codicefiscale;
private String indirizzo;
public Persona(String nome, String cognome, String codicefiscale, String indirizzo) {
this.nome=nome;
this.cognome=cognome;
this.codicefiscale=codicefiscale;
this.indirizzo=indirizzo;
}
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
public String getCognome() {
return cognome;
}
public void setCognome(String cognome) {
this.cognome = cognome;
}
public String getCodicefiscale() {
return codicefiscale;
}
public void setCodicefiscale(String codicefiscale) {
this.codicefiscale = codicefiscale;
}
public String getIndirizzo() {
return indirizzo;
}
public void setIndirizzo(String indirizzo) {
this.indirizzo = indirizzo;
}
}
Per utilizzare questo bean all’interno di iReport e creare quindi un JRXML che potremo utilizzare successivamente per creare i nostri report, dobbiamo creare un datasource di tipo “Sorgente dati di JavaBean” e poi impostare nel wizard una classe ed un metodo statico di questa che potranno essere utilizzati per utilizzare questo datasource di test. Praticamente nel caso del database, il datasource andava a prendere i dati direttamente tramite JDBC, in questo caso dobbiamo dirgli che tipo di dati prendere (definire il bean) e in che il modo il datasource può generarli (una classe e un metodo statico). Per il nostro esempio possiamo utilizzare la seguente classe che simula la creazione dei bean Persona
public class TestBeanDatasource {
public static java.util.Collection generateCollection() {
java.util.Vector collection=new java.util.Vector();
collection.add(new test.Persona("Federico","Paparoni","APOSPANFLSNAF","VIA ROMA 123"));
collection.add(new test.Persona("Gianluca","Paparoni","SISISIS","VIA ROMA 123"));
collection.add(new test.Persona("Chiara","Paparoni","AOFDNFLKD","VIA ROMA 123"));
collection.add(new test.Persona("Giulia","Paparoni","FDLFKDNFD","VIA ROMA 123"));
return collection;
}
}
In questo caso nel wizard dovremo segnalare la classe TestBeanDatasource come factory e generateCollection() come metodo statico. A questo punto potremo creare un report nello stesso modo in cui abbiamo fatto precedentemente per il datasource JDBC, gestendo tutti gli attributi del singolo bean come variabili per il nostro report. Il bean e la classe che li genera deve essere presente nel classpath di iReport, quindi potete settarla attraverso le opzioni del programma o includerla nella cartella lib del programma.
Generazione del report
Tramite iReport abbiamo creato il JRXML che descrive il nostro report e ora dobbiamo generarlo tramite una classe Java. Qui di seguito trovate un programma d’esempio che crea due diversi report, uno che si basa sull’esempio descritto nel filmato ovvero tramite Datasource JDBC e l’altro sul Bean Datasource
import java.sql.Connection;
import java.sql.DriverManager;
import java.util.Collection;
import java.util.HashMap;
import net.sf.jasperreports.engine.JRException;
import net.sf.jasperreports.engine.JasperCompileManager;
import net.sf.jasperreports.engine.JasperFillManager;
import net.sf.jasperreports.engine.JasperPrint;
import net.sf.jasperreports.engine.JasperReport;
import net.sf.jasperreports.engine.data.JRBeanCollectionDataSource;
import net.sf.jasperreports.engine.JasperExportManager;
public class MainTest {
public static void main(String a[]) throws JRException {
printPerson(TestFactory.generateCollection());
printItems();
}
public static void printPerson(Collection personList) throws JRException {
JRBeanCollectionDataSource datasource = new JRBeanCollectionDataSource(personList);
JasperReport jasperReport = JasperCompileManager.compileReport("c:/classic.jrxml");
JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, new HashMap(), datasource);
JasperExportManager.exportReportToPdfFile(jasperPrint, "c:/person.pdf");
}
public static void printItems() {
Connection connection;
JasperReport jasperReport;
JasperPrint jasperPrint;
try{
Class.forName("com.mysql.jdbc.Driver");
connection =
DriverManager.getConnection("jdbc:mysql://localhost:3306/test","root","mysql");
jasperReport = JasperCompileManager.compileReport("c:/mysql.jrxml");
jasperPrint = JasperFillManager.fillReport(jasperReport, new HashMap(), connection);
JasperExportManager.exportReportToPdfFile(jasperPrint, "c:/reportItems.pdf");
JasperExportManager.exportReportToHtmlFile(jasperPrint, "c:/reportItems.html");
}catch(Exception ex){
ex.printStackTrace();
}
}
}
Il metodo printPerson() genera un report in PDF del file JRXML che si basa sui Java Bean mentre l’altro metodo crea il report illustrato nel filmato, richiamando sempre il corrispettivo file JRXML e salvandone l’output in due diversi formati (PDF e HTML). In questo caso abbiamo salvato il tutto sul filesystem ma avremmo potuto tranquillamente gestire le generazione tramite Servlet e restituire il report attraverso il browser.
Risorse
JasperReports Homepage
iReport Homepage
Altro interessante tutorial su iReport
Commenti recenti