JasperReport, iReport e java

Dobbiamo produrre dei report in pdf da java?
Le soluzioni sono tante. Noi oggi ne tratteremo una in particolare: jasperReport!
Non è semplicissimo, ma cercheremo di seguire tutti i passi necessari per renderlo facile…
Ecco cosa faremo:
1. produzione file jrxml e compilazione del file jrxml in jasper
2. uso del file jasper in java per produrre un file PDF

1. PRODUZIONE FILE JRXML E COMPILAZIONE IN FILE JASPER
Per eseguire i suoi compiti jasperReport usa file con estensione jrxml, ossia file xml nei quali scrive tutto quello che serve per produrre il report. Compilando il file jrxml si ottiene poi un file con estensione jasper.
Da ciò deriva che la prima cosa da fare è produrre un file jrxml.
Per farlo, scarichiamo un IDE creato appositamente: iReport.
Ora dobbiamo usare iReport per disegnare il nostro report.
iReport si presenta più o meno come mostrato nella figura qui in basso e ci indica sin da subito la strada da seguire per creare un report:
– creare una fonte dati
– disegnare il report
– visualizzare/salvare il report

E’ bene chiarire che non siamo di certo costretti a seguire l’iter appena indicato. Possiamo tranquillamente selezionare “File/Nuovo…”, scegliere il nostro layout preferito e premere “Open this template”. In questo caso però è bene aprire il file appena creato in visualizzazione XML ed eliminare l’attributo “language” del tag  <jasperReport>.
Si, ma allora perché fare tutto quel giro? Perché in quel modo iReport ci consente di vedere in diretta quello che creiamo. Vediamo allora di seguire l’iter indicato.
Clicchiamo sul “passo 1”.
Ci troveremo di fronte all’elenco di tutte le fonti dati da cui jasperReport può prelevare i dati da stampare (praticamente tutte). Noi qui prenderemo in esame quelle che più da vicino interessano un javista: Database JDBC connection, XML file datasource e JavaBeans.

Database JDBC connection
Questa è l’opzione da scegliere se vogliamo che il nostro report prelevi i dati da stampare da un DB. Selezioniamo quindi questa voce e premiamo “Avanti >”. Qui di seguito possiamo osservare la schermata che ci viene proposta da iReport dopo la pressione del pulsante “Avanti>”.

Dobbiamo ovviamente avere le informazioni che servono per collegarci al DB (nella figura stiamo utilizzando una connessione JDBC a Oracle).
ATTENZIONE: Se vogliamo usare Oracle dobbiamo scaricare la libreria ojdbc14.jar e posizionarla nella sottocartella “ide10\modules\ext” della cartella in cui abbiamo installato iReport e poi strumenti/opzioni/Classpath/Add Jar e aggiungiamo il jar.
Una volta inseriti tutti i dati, scegliamo “Prova” per vedere se abbiamo fatto tutto bene e quando tutto è OK premiamo “Salva”.
Ora, in alto al centro della schermata principale di iReport possiamo notare la nostra fonte dati (nell’immagine qui sotto indicata con “Fasi”).

E adesso? Ora che abbiamo la fonte dati possiamo usarla per compilare il nostro report. Clicchiamo con il destro sul nome del report e scegliamo la voce “Edit Query” (come mostrato nella figura che segue).

Si aprirà l’interfaccia mostrata qui di seguito, nella quale non dobbiamo fare altro che inserire la nostra query SQL e premere il pulsante “Read fields”.
Come per miracolo in basso vedremo l’elenco dei campi del DB. Scegliamo “OK” e torniamo sul nostro report. Nella sezione “Report inspector” (sulla sinistra) avremo la voce “Campi” riempita con i nomi delle colonne del DB. Non ci resta che selezionare una colonna e trascinarla sul nostro report, nella sezione in cui vogliamo che compaia.

XML file datasource
Se la nostre fonte dati è un file XML, ci basta scegliere XML file datasource al “Passo 1” e premere “Avanti >”. Diamo poi un nome e scegliamo il file XML di riferimento.
C’è però un caso in cui ci si può trovare in difficoltà nell’uso di un file XML come sorgente dati. E’ il caso in cui si cerca di inserire in una jr:table i dati contenuti nel file xml. In tal caso dopo aver creato il dataset dal quale la tabella andrà a prendere i dati, è opportuno entrare nella visualizzazione XML e modificare la seguente stringa:

<dataSourceExpression><![CDATA[new net.sf.jasperreports.engine.JREmptyDataSource(1)]]></dataSourceExpression>

in quest’altra:

<dataSourceExpression><![CDATA[$P{REPORT_DATA_SOURCE}]]></dataSourceExpression>

Ok, facciamo un piccolo esempio 🙂
Ammettiamo che questo sia il nostro file XML:

<documento>
    <voce>
        <testo>Testo 1</testo>
        <valore>Valore 1</valore>
    </voce>
    <voce>
        <testo>Testo 2</testo>
        <valore>Valore 2</valore>
    </voce>
</documento>
</code>
Ammettiamo inoltre di dover inserire i dati contenuti nel tag "testo" nella prima colonna della jr:table e i dati del tag "valore" nella seconda colonna.
Trasciniamo quindi l'oggetto "Table" nella zona "Detail" del nostro report. Si presenterà la seguente schermata:
<a rel="lytebox" href="http://www.alessandrostella.it/blog/wp-content/uploads/2010/07/iReportNewTable.jpg"><img class="aligncenter size-medium wp-image-1225" title="creazione nuova Table" src="http://www.alessandrostella.it/blog/wp-content/uploads/2010/07/iReportNewTable-450x325.jpg" alt="creazione nuova Table" width="450" height="325" /></a>
dalla quale dobbiamo associare la nostra tabella al dataset. Premiamo quindi "New dataset". Nella schermata successiva diamo un nome al dataset (ad esempio SorgenteDatiXML) e scegliamo "Create new dataset...". Premiamo "Avanti&gt;". Nella schermata successiva andiamo a cercare la sorgente dati che fa riferimento al file XML. Ora sempre "Avanti&gt;" fino alla fine, quindi "Termina".
Ora nel "Report inspector", sulla sinistra, sarà comparsa la voce "SorgenteDatiXML".
Clicchiamoci sopra con il tasto destro e scegliamo "Edit query". Dalla schermata che si apre, nella combo "Query language" scegliamo "XPath" come nella figura qui sotto.
<a rel="lytebox" href="http://www.alessandrostella.it/blog/wp-content/uploads/2010/07/iReportQueryLanguage.jpg"><img class="aligncenter size-medium wp-image-1227" title="iReport - Query Language" src="http://www.alessandrostella.it/blog/wp-content/uploads/2010/07/iReportQueryLanguage-450x355.jpg" alt="iReport - Query Language" width="450" height="355" /></a>
A questo punto tramite XPath andiamo a cercare i dati che ci interessano (documento/voce). Sulla destra apriamo il tag "voce" e trasciniamo i tag "testo" e "valore" nella parte bassa della figura. Premiamo "OK".
Ora, sotto "SorgenteDatiXML" troveremo i campi "testo" e "valore".
Portiamoci nell'edit della tabella e trasciniamo i campi nelle rispettive colonne, come nella sottostante figura.
<a rel="lytebox" href="http://www.alessandrostella.it/blog/wp-content/uploads/2010/07/iReportEditTable.jpg"><img class="aligncenter size-medium wp-image-1229" title="iReport - Edit table" src="http://www.alessandrostella.it/blog/wp-content/uploads/2010/07/iReportEditTable-450x316.jpg" alt="iReport - Edit table" width="450" height="316" /></a>
Ora effettuiamo la sostituzione di cui si è parlato all'inizio di questo paragrafo ("dataSourceExpression").

<span style="text-decoration: underline;">JavaBeans set datasource</span>
Questa è la scelta più complicata, ma forse più utile per un javista. In questo modo possiamo dire a jasperReport di prelevare le informazioni da stampare da un elenco (collezione o array) di beans! Procediamo.
Dobbiamo innanzitutto sapere che
<blockquote>"this datasource need a spacial factory class that provides a static method to generate a collection or an array of JavaBeans"</blockquote>
ossia <strong>dobbiamo creare una classe che abbia un metodo statico e tale metodo DEVE restituire una collection o un array riempiti con i nostri beans</strong>.
Qui di seguito vi porto un esempio di tale metodo (si presuppone l'esistenza di una classe di nome Bean che rappresenta il nostro bean):

public static java.util.Collection dammiLista() {
    java.util.Collection persone = new ArrayList();
    for (int i=0; i<5; i++) {
        Bean persona = new Bean();
        persona.setCodiceFiscale("CODFISC"+i);
        persona.setCognome("Cognome"+i);
        persona.setNome("Nome"+i);
        persone.add(persona);
    }
    return persone;
}

Fatto questo, creiamo un .jar dal nostro progetto. Poi da iReport "Strumenti/Opzioni/Classpath". Scegliamo "Add JAR" e aggiungiamo il nostro jar. Ora, aggiungendo un datasource di tipo "JavaBeans set datasource", nel campo "Factory class" possiamo aggiungere la classe (completa di percorso del package in cui si trova). Nell'altro campo (il metodo statico) aggiungiamo il nome del metodo statico (nell'esempio "dammiLista) che ci restituisce la collection o l'array di beans, come mostrato nella figura qui sotto.

Premiamo il pulsate "Prova". Deve venire fuori un "successo", altrimenti abbiam sbagliato qualcosa... Se tutto è ok, clicchiamo sul destro sul nome del nostro progetto e scegliemo "Edit query". Comparirà la schermata qui sotto

Dobbiamo quindi premere su "JavaBean Datasource" e inserire il nome della classe che rappresenta il singolo bean (nel nostro caso proprio Bean). Poi premiamo "Read attributes". Al centro, come mostrato, comparirà l'elenco degli attributi del singolo Bean 🙂 Selezioniamo quelli che ci interessano e premiamo "Aggiungi il campo(i) selezionati. Poi diamo "ok".
Adesso nei campi del nostro report sono comparsi quelli selezionati e, trascinandoli sul report possiamo stamparne i valori 🙂
Ue', sia chiaro! Tutto questo discorso sui javabeans serve esclusivamente per vedere da iReport l'anteprima del nostro report. Nella nostra applicazione poi le cose son diverse! Non è che dobbiamo creare un metodo statico nel codice!!!
Procediamo nella lettura per capire...

Bene.
Qualunque sia stata la nostra scelta, ora prcediamo e creiamo il nostro report.
Ritorniamo nella schermata principale e clicchiamo sul "Passo 2".
Ci verrà proposto un insieme di layout. Senza complicarci la vita dietro a layout più o meno belli e complicati, scegliamo il primo se vogliamo un report con stampa verticale o il secondo se preferiamo una stampa orizzontale. Clicchiamo quindi sul layout scelto e premiamo "Open this template". Ora siamo pronti a disegnare il nostro report.
Le guide sull'argomento non mancano, quindi vi rimando ad una qualunque di esse per prendere dimestichezza con iReport.
Una volta terminato il nostro lavoro sul report è opportuno compilarlo per ottenere il file jasper. Per farlo basta premere il bottone evidenziato nelle figura qui sotto.

2.USO DI JASPERREPORT IN JAVA
Usare jasperReport in java significa semplicemente aggiungere la sua jar (attualmente jasperreports-3.7.3.jar) nelle librerie del progetto. Fatto questo possiamo accedere alle sue classi.
Se, ad esempio, il nostro file jasper compilato si chiama "ricevutaTrasfProgrTriennale.jasper" e deve recuperare i dati da un file XML, inviato tramite post in una web application, con il codice qui di seguito recuperiamo l'inputstream, modifichiamo il file XML (tramite jaxp) e richiamiamo jasperReport per la realizzazione del file PDF:

private void sendReportElencoReportXmlPdf(HttpServletRequest request,
HttpServletResponse response) throws IOException {

    ByteArrayOutputStream out = new ByteArrayOutputStream();
    try {
    String pathFile = request.getSession().getServletContext().getRealPath("") + "WEB-INF/reports/ricevutaTrasfProgrTriennale.jasper";
    String pathFileImg = request.getSession().getServletContext().getRealPath("") + "WEB-INF/reports/LogoLomb.gif";
    //String pathFile = request.getRealPath("") + "WEB-INF/reports/ricevutaTrasfProgrTriennale.jasper";
    log.debug("PATHFILE PDF: " + pathFile);
    Map lParameters = new HashMap();
    lParameters.put("DATA_TIME", "15/15/2015");
    String fileXML = request.getParameter("file");
    log.debug(fileXML);
    InputStream in = new ByteArrayInputStream(fileXML.getBytes());

    DocumentBuilderFactory f = DocumentBuilderFactory.newInstance();
    DocumentBuilder db;
    db = f.newDocumentBuilder();
    Document doc = db.parse(in);
    Element root = doc.getDocumentElement();
    root.setAttribute("img", pathFileImg);

    JRXmlDataSource xmlDS = new JRXmlDataSource(doc,"/trasferimenti/trasferimento");
    //JRXmlDataSource xmlDS = new JRXmlDataSource(in,"/trasferimenti/trasferimento");
    in.close();

    JRPdfExporter exporter = new JRPdfExporter();
    JasperPrint jasperPrint = JasperFillManager.fillReport(pathFile,lParameters, xmlDS);
    exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
    exporter.setParameter(JRExporterParameter.OUTPUT_STREAM, out);
    exporter.exportReport();
    } catch (JRException e) {
        log.error(e, e);
    } catch (ParserConfigurationException PCexc) {
        log.error(PCexc, PCexc);
    } catch (IOException IOexc) {
        log.error(IOexc, IOexc);
    } catch (SAXException SAXexc) {
        log.error(SAXexc, SAXexc);
    }

    response.setContentType("application/vnd.pdf");
    response.setHeader("Content-Disposition", "attachment; filename=stampaReport.pdf");
    //response.setContentLength(out.size());
    ServletOutputStream output = response.getOutputStream();
    out.writeTo(output);
    output.flush();
}

Se invece i dati sono contenuti in una collezione di beans, possiamo procedere come segue:

private void creaReportDaCollezioneDiBean(HttpServletRequest request,
     HttpServletResponse response) throws IOException {

    ByteArrayOutputStream out = new ByteArrayOutputStream();
    // QUI SETTIAMO EVENTUALI PARAMETRI E VARIABILI CHE SI ASPETTA IL NOSTRO JASPER
   // I QUESTO CASO STIAMO SETTANDO IL PATH IN CUI SI TROVA IL FILE JASPER E
   // IL PATH IN CUI SI TROVA UN'IMMAGINE CHE VERRA' POI STAMPATA NEL NOSTRO REPORT
    String pathFile = request.getSession().getServletContext().getRealPath("") + "/WEB-INF/reports/stampaReport.jasper";
    String pathFileImg = request.getSession().getServletContext().getRealPath("") + "/WEB-INF/reports/logo.png";
    Map<String, String> lParameters = new HashMap<String, String>();
    lParameters.put("pathImg", pathFileImg);
    log.debug("PATH JAPSER: " + pathFile);
    // FINE DEI SETTAGGI DEI PARAMETRI
  
    try {
     JRDataSource dataSource = null;

     java.util.Collection<EventoSospensioneStampaBean> beanCollection = 
       new ArrayList<EventoSospensioneStampaBean>();
     /*
      *  QUI SCRIVIAMO IL CODICE PER RIEMPIRE LA NOSTRA COLLEZIONE DI BEAN
      *  UNA VOLTA SETTATI GLI ATTRIBUTI DEL BEAN, LO AGGIUNGIAMO ALLA COLLEZIONE
     */  
      if (NostroBean!=null) {
       beanCollection.add(NostroBean);
     }
     dataSource = new JRBeanCollectionDataSource(beanCollection);

      // QUESTO E' IL CODICE PER COMPILARE IL NOSTRO REPORT JASPER
     if (dataSource!=null) {     
        JRPdfExporter exporter = new JRPdfExporter();
       log.debug("STO RIMPIENDO IL JASPER");
       JasperPrint jasperPrint = JasperFillManager.fillReport(pathFile, lParameters, dataSource);
        log.debug("HO RIEMPITO IL JASPER");
       exporter.setParameter(JRExporterParameter.JASPER_PRINT, jasperPrint);
       exporter.setParameter(JRExporterParameter.OUTPUT_STREAM, out);
        exporter.exportReport();
      }
   } catch (JRException e) {
     log.error(e, e);
    } catch (Exception exc) {
     log.error(exc, exc);
    }

     response.setContentType("application/vnd.pdf");
   response.setHeader("Content-Disposition", "attachment; filename=reportSospensione.pdf");
    //response.setContentLength(out.size());
    ServletOutputStream output = response.getOutputStream();
    out.writeTo(output);
    output.flush();
}    

CLASSICI PROBLEMI INCONTRATI DURANTE L'USO DI JASPERREPORT
Dopo aver creato il file jasper e aver provato a interagire con esso tramite codice java, può capitare di imbattersi nel seguente messaggio di errore:

java.lang.NoClassDefFoundError: org/codehaus/groovy/control/CompilationFailedException

In questo caso bisogna aprire il jrxml ed eliminare l'attributo language="groovy" nel nodo jasperReport.

[... to be continued ...]