Archivi tag: jasperreports

JASPERREPORTS TUTORIAL – 8 – PAGINARE IL REPORT

19/06/2014 admin

Nell’articolo di oggi vedremo come paginare un report. JasperReports consente di paginare agevolmente un report tramite l’uso delle variabili:

PAGE_NUMBER
PAGE_COUNT

La variabile PAGE_NUMBER indica il numero della pagina corrente, mentre la variabile PAGE_COUNT indica il numero totale di pagine presenti. Possiamo così ottenere l’effetto paginazione inserendo la seguente espressione da inserire nella banda Piè di Pagina

“Pagina “+$V{PAGE_NUMBER}+” di ” + $V{PAGE_NUMBER}

Questa soluzione fallisce nel momento in cui il report è ottenuto come aggregazione di report ottenuti tramite programmazione. Usando una lista di oggetti JasperPrint vedremo la numerazione ripartire più volte e non essere continua.

Per aggirare il problema possiamo sfruttare il passaggio di parametri e fornire ad ogni report un parametro contenente il totale delle pagine fino al quel momento.

Siccome una porzione di codice vale più di mille parole ecco un estratto che chiarisce

try {
List<JasperPrint> jasperPrintList = new ArrayList<JasperPrint>();
int totalePagine = 0;
for (int j = 0; j < 5; j++) {
Map<String, Object> lParametersTmp = new HashMap<String, Object>();
lParametersTmp.put("TOTALE_PAGINA_CORRENTE", totalePagine);
JasperPrint jasperPrintMulti = JasperFillManager.fillReport(j+"", lParametersTmp, new JREmptyDataSource());
totalePagine = totalePagine + jasperPrint.getPages().size();
jasperPrintList.add(jasperPrint);
}
} catch (JRException e) {
e.printStackTrace();
}

try {

List<JasperPrint> jasperPrintList = new ArrayList<JasperPrint>();

int totalePagine = 0;

for (int j = 0; j < 5; j++) {

Map<String, Object> lParametersTmp = new HashMap<String, Object>();

lParametersTmp.put("TOTALE_PAGINA_CORRENTE", totalePagine);

JasperPrint jasperPrintMulti = JasperFillManager.fillReport(j+"", lParametersTmp, new JREmptyDataSource());

totalePagine = totalePagine + jasperPrint.getPages().size();

jasperPrintList.add(jasperPrint);

}

} catch (JRException e) {

e.printStackTrace();

}

Nel nostro report modifichiamo l’espressione della banda Piè di Pagina in questo modo

“Pag. ” + ($P{TOTALE_PAGINA_CORRENTE} + $V{PAGE_NUMBER})

Questa modifica ci consente di numerare le pagina in modo crescente ma non ci permette di ottenere l’effetto X di Y.

Se volessimo ottenere l’effetto X di Y dobbiamo effettuare un doppio ciclo:

il primo ci permette di ottenere il totale delle pagine
il secondo ciclo ci permette di passare il totale delle pagine e la paginazione corrente come parametri,

Buona sperimentazione.

Se hai trovato l’articolo utile un +1 non dispiace.

JASPERREPORTS

JASPERREPORTS TUTORIAL – 7 – INTEGRARE IL REPORT IN UNA SERVLET

19/06/2014 admin

Nell’articolo di oggi vedremo come rendere disponibile il report all’interno di una web application. Il report sarà aperto invocando una url particolare e reso disponibile direttamente nel browser.

Primo passo: creare la web application.

Per fare questo ci avvaliamo di maven e uno dei suoi archetipi.

mvn archetype:create 
-DgroupId=it.finazzo.web 
-DartifactId=ReportJasperWeb 
-DarchetypeArtifactId=maven-archetype-webapp

mvn archetype:create

-DgroupId=it.finazzo.web

-DartifactId=ReportJasperWeb

-DarchetypeArtifactId=maven-archetype-webapp

Creato il progetto possiamo importarlo in eclipse tramite la direttiva mvn eclipse:eclipse.

Secondo Passo: definire la servlet per l’export

A questo punto dichiaramo la servlet che si preoccuperà di esportare il report in formato pdf. Definiamo nel file web.xml la servlet e l’url pattern che la attiva

<servlet>
  <servlet-name>Manager</servlet-name>
  <servlet-class>it.finazzo.servlet.Manager</servlet-class>
  </servlet>  
  <servlet-mapping>
  	<servlet-name>Manager</servlet-name>
  	<url-pattern>/manager</url-pattern>
  </servlet-mapping>
</web-app>

<servlet-name>Manager</servlet-name>

<servlet-class>it.finazzo.servlet.Manager</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>Manager</servlet-name>

<url-pattern>/manager</url-pattern>

</servlet-mapping>

</web-app>

Terzo Passo: implementare la funzione di export.

JRDataSource ds = new it.finazzo.ds.DataSource();
String reportFileName = 
getServletContext().getRealPath("WEB-INF/classes/reportFromXml.jrxml");
JasperReport jasperReport = null;
jasperReport = JasperCompileManager.compileReport(reportFileName);
JasperPrint jasperPrint = null;
jasperPrint = JasperFillManager.fillReport(jasperReport, new HashMap(), ds );
JasperExportManager.exportReportToPdfStream(jasperPrint, resp.getOutputStream());

JRDataSource ds = new it.finazzo.ds.DataSource();

String reportFileName =

getServletContext().getRealPath("WEB-INF/classes/reportFromXml.jrxml");

JasperReport jasperReport = null;

jasperReport = JasperCompileManager.compileReport(reportFileName);

JasperPrint jasperPrint = null;

jasperPrint = JasperFillManager.fillReport(jasperReport, new HashMap(), ds );

JasperExportManager.exportReportToPdfStream(jasperPrint, resp.getOutputStream());

Recuperiamo il file jrxml dal classpath e usiamo il metodo per esportare il report direttamente nell’output stream della response, con l’effetto di aprire il file direttamente nel browser quando invochiamo l’url http://localhost:9000/Report/manager

Qui sono disponibili i sorgenti per provare in locale.

JASPERREPORTS

JASPERREPORTS TUTORIAL – 6 – CREIAMO IL NOSTRO REPORT IN JAVA

19/06/2014 admin

Nell’articolo di oggi vedremo come generare il nostro report in pdf partendo dal modello generato con Ireport.

Il primo passo è quello di generare il nostro report a partire dal formato jrxml. Per fare questo JasperReports ci mette a disposizione la classe JasperCompileManager

JasperReport jasperReport = JasperCompileManager.compileReport(“reportFromXml.jrxml”);

Tale classe permette di compilare il report e ottenere un file .jasper, lo stesso file che otteniamo quando generiamo l’anteprima con Ireport.

A questo punto resta da riempire il report compilato con i dati che provengono da un datasource. Questo meccanismo viene realizzato dalla classe JasperFillManager

JasperPrint jasperPrint = JasperFillManager.fillReport(jasperReport, new HashMap(), ds );

La classe JasperFillManager mette a disposizione il metodo fillReport che permette di riempire il nostro report tramite una serie di parametri che vengono forniti tramite un oggetto di tipo Map e un datasource di tipo JRDataSource.

L’interfaccia JRDataSource è un’interfaccia che prevede la definizione di 2 metodi: il metodo next che permette di scorrere il datasource e il metodo getField che permette di recuperare la proprietà del bean del datasource.

Nel nostro esempio ho definito una semplice implementazione dell’interfaccia che permette di scorrere un elenco di libri e accedere ad alcune sue proprietà.

JRDataSource ds = new JRDataSource() {
	Collection<Libro> beanCollection = 
(Collection<Libro>) LibroFactory.getBeanCollection();
	private Iterator<Libro> iterator = beanCollection.iterator();
	private Libro libro = null; 
        int counter = 0;

	@Override
	public boolean next() throws JRException {
		if (counter>=beanCollection.size())
			return false;
		libro = iterator.next();
		counter++;
		return true;
	}
	@Override
	public Object getFieldValue(JRField arg0) throws JRException {
		if (arg0.getName().equals("autore"))
			return libro.getAutore();
		if (arg0.getName().equals("id"))
			return libro.getId();
		if (arg0.getName().equals("titolo"))
			return libro.getTitolo();
		if (arg0.getName().equals("genere"))
			return libro.getGenere();
		return null;
		}
	};

JRDataSource ds = new JRDataSource() {

Collection<Libro> beanCollection =

(Collection<Libro>) LibroFactory.getBeanCollection();

private Iterator<Libro> iterator = beanCollection.iterator();

private Libro libro = null;

int counter = 0;

@Override

public boolean next() throws JRException {

if (counter>=beanCollection.size())

return false;

libro = iterator.next();

counter++;

return true;

}

@Override

public Object getFieldValue(JRField arg0) throws JRException {

if (arg0.getName().equals("autore"))

return libro.getAutore();

if (arg0.getName().equals("id"))

return libro.getId();

if (arg0.getName().equals("titolo"))

return libro.getTitolo();

if (arg0.getName().equals("genere"))

return libro.getGenere();

return null;

}

};

Il metodo next permette di scorrere il nostro datasource. Ritorna true se è presente un altro elemento all’interno del datasource, mentre il metodo getFieldValue permette di accedere alla singola proprietà del record.

A questo punto tramite la classe JasperExportManager possiamo estrarre il nostro report nel formato desiderato.

JasperExportManager.exportReportToPdfFile(jasperPrint, “c://Simple_Report.pdf”);

Qui trovate le classi per compilare il progetto

JASPERREPORTS

JASPERREPORTS TUTORIAL – 5 – DATASOURCE XML

19/06/2014 admin

L’articolo illustra come usare un datasource di tipo xml. Per prima cosa occorre disporre la sorgente dati: in questo usiamo un file xml così definito

<?xml version="1.0" encoding="windows-1250"?>
<libri>
  <libro id="1" titolo="titolo1" autore="autore1" genere="giallo" >
  </libro>
  <libro id="2" titolo="titolo2" autore="autore2" genere="giallo" >
  </libro>
</libri>

<?xml version="1.0" encoding="windows-1250"?>

<libri>

</libro>

</libro>

</libri>

A questo punto sfruttiamo il report definito per l’articolo precedente ma creiamo il nuovo datasource di tipo Xml File Datasource e tra le opzioni indichiamo il path del file xml creato e l’utilizzo di XPath per estrarre i dati.

Resta a questo punto da definire i campi e come essi vanno estratti dal file. Per far questo usiamo Xpath, per chi non lo conoscesse esso permette di individuare i nodi all’interno di un documento XML. Le espressioni XPath, a differenza delle espressioni XML, non servono a identificare la struttura di un documento, bensì a localizzarne con precisione i nodi. Ireport offre uno strumento che permette di individuare i nodi senza conoscere la sintassi Xpath. A questo punto non resta che lanciare l’anteprima e ottenere il nostro report.

Scaricate il file jrxml per replicare quanto descritto nell’articolo.

JASPERREPORTS

JASPERREPORTS TUTORIAL – 4 – DATASOURCE JDBC

19/06/2014 admin

Nell’articolo di oggi vedremo come integrare una sorgente datasource di tipo JDBC nel nostro report. Per prima cosa occorre disporre di una sorgente dati: è possibile utilizzare il database di esempio fornito con Ireport HSQLDB o procurarsi un altra DBMS, Nell’esempio ho usato Mysql fornito con Xampp.

In questo database ho definito lo schema REPORT e in esso ho definito la tabella LIBRI. Ecco lo script per generarlo agevolmente:

DROP TABLE IF EXISTS `libri`;

CREATE TABLE IF NOT EXISTS `libri` 
(  `id` int(11) NOT NULL,   `titolo` text NOT NULL,  
`autore` text NOT NULL,  `genere` text NOT NULL,  
PRIMARY KEY (`id`) ) ENGINE=MyISAM DEFAULT CHARSET=latin1;

INSERT INTO `libri` 
(`id`, `titolo`, `autore`, `genere`) 
VALUES (1, 'libro1', 'autore1', 'giallo'), 
(2, 'titolo2', 'autore2', 'giallo');

DROP TABLE IF EXISTS `libri`;

CREATE TABLE IF NOT EXISTS `libri`

( `id` int(11) NOT NULL, `titolo` text NOT NULL,

`autore` text NOT NULL, `genere` text NOT NULL,

PRIMARY KEY (`id`) ) ENGINE=MyISAM DEFAULT CHARSET=latin1;

INSERT INTO `libri`

(`id`, `titolo`, `autore`, `genere`)

VALUES (1, 'libro1', 'autore1', 'giallo'),

(2, 'titolo2', 'autore2', 'giallo');

Una volta che abbiamo la nostra sorgente dati passiamo alla definizione del nostro Report. Usiamo IReport per generare un report vuoto e come prima operazione definiamo la connection verso il database appena configurato. Come parametri di configurazione usiamo i seguenti dati:

JDBC Driver: MySQL (com.mysql.jdbc.Driver)
JDBC URL: jdbc:mysql://localhost/report

Tramite la funzione Report Query individuiamo i campi della tabella LIBRI che vogliono mettere nel nostro report. Scegliamo come language l’SQL e definiamo la nostra query:

SELECT      libri.`id` AS libri_id,      
libri.`titolo` AS libri_titolo,      
libri.`autore` AS libri_autore,      
libri.`genere` AS libri_genere 
FROM      `libri` libri

SELECT libri.`id` AS libri_id,

libri.`titolo` AS libri_titolo,

libri.`autore` AS libri_autore,

libri.`genere` AS libri_genere

FROM `libri` libri

con cui recuperiamo i campi da visualizzare nel nostro report.

Aggiungiamo un testo statico nella banda Titolo, l’intestazione di colonne nella banda Testata di Colonna e nella banda Detail mettiamo i campi restituiti dalla nostra query.

A questo punto non resta che lanciare l’anteprima e avremo il risultato desiderato.

Per comodità trovate il file jrxml con cui fare subito qualche prova.

JASPERREPORTS

JASPERREPORTS TUTORIAL – 3 – STRUTTURA DEL REPORT JRXML

19/06/2014 admin

I report JasperReports sono dei file in formato xml, con estensione .jrxml. Nell’articolo precedente abbiamo usato il wizard per generare rapidamente il nostro report, adesso incominceremo ad analizzare la struttura del report.

Analizziamo la struttura base del report, che otteniamo con ireport quando scegliamo di generare un report vuoto.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE jasperReport PUBLIC "-//JasperReports//DTD JasperReport//EN" 
"http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">
<jasperReport name="report name" pageWidth="595" pageHeight="842" 
columnWidth="535" leftMargin="20" rightMargin="20" 
topMargin="20" bottomMargin="20">
<background> <band/> </background>
<title> <band height="79"/> </title> 
<pageHeader> <band height="35"/> </pageHeader> 
<columnHeader> <band height="61"/> </columnHeader> 
<detail> <band height="125"/> </detail> 
<columnFooter> <band height="45"/> </columnFooter> 
<pageFooter> <band height="54"/> </pageFooter> 
<summary> <band height="42"/> </summary>
</jasperReport>

<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE jasperReport PUBLIC "-//JasperReports//DTD JasperReport//EN"

"http://jasperreports.sourceforge.net/dtds/jasperreport.dtd">

<jasperReport name="report name" pageWidth="595" pageHeight="842"

columnWidth="535" leftMargin="20" rightMargin="20"

topMargin="20" bottomMargin="20">

</jasperReport>

Analizziamo in dettaglio gli elementi che compongono la struttura del report:

l’elemento jasperReport è la root del file xml
l’elemento background contiene i dati dello sfondo
l’elemento title viene stampato una sola volta all’inizio del report
l’elemento pageHeader viene stampato all’inizio di ogni pagina. Consiste nella testata di pagina.
l’elemento columnHeader viene stampato all’inizio di ogni pagina che contiene una banda di tipo detail. L’elemento viene stampato in testa ad ogni colonna
l’elemento detail viene stampato per ogni record del datasource
l’elemento columnFooter viene stampato alla fine di ogni pagina che contiene una banda di tipo detail. L’elemento viene stampato in coda ad ogni colonna.
l’elemento pageFooter viene stampato alla fine di ogni pagina. Consiste nel piè di pagina.
l’elemento summary viene stampato alla fine del report

L’utente può aggiungere elementi ad ogni sezione per costruire l’aspetto grafico del report.

Inoltre è possibile aggiungere i seguenti elementi per gestire il report:

stili (tag style) –> Gli stili intervengono sull’aspetto grafico del report
parametri (tag parameter) –> i parametri sono valori che vengono passati al report direttamente dall’utente
variabili (tag variable) –> le variabile vengono usate per elaborazioni interne al report
campi (tag field) –> i campi vengono estratti dal datasource associato al report

JASPERREPORTS

JASPERREPORTS TUTORIAL – 2 – USARE IREPORT

19/06/2014 admin

Nell’articolo di oggi creeremo il nostro primo report usando ireport, l’ottimo tool che permette di fare il design del nostro report senza scrivere una riga di codice.

Scaricate il tool dal sito http://jasperforge.org/projects/ireport. Ad oggi l’ultima versione è la 3.7.2.

Una volta installato procediamo alla creazione del nostro primo report, utilizzando il comodo wizard.

Scegliamo il template a noi più congeniale da utilizzare dall’elenco proposto.
Stabiliamo il nome del report e la posizione di salvataggio del file
Scegliamo la sorgente dati da utilizzare. ireport mette a disposizione un database di test da poter sfruttare e per comodità usiamo questa connessione identificando una query sql che recupera i dati dalla tabella ADDRESS dello schema PUBLIC.
Definiamo i campi da far visualizzare nel nostro report e per comodità li scegliamo tutti
Saltiamo la scheda per raggruppare i dati
Clicchiamo su Termina

A questo punto il sistema carica il template definito.

Nella nuova finestra sono visibili le seguenti sezioni:

a sinistra è visibile la sezione report inspector che permette di navigare tra le sezioni del report e i suoi componenti
al centro è presente la finestra di lavoro dove è possibile vedere il report in formato xml e la sua anteprima
a destra è presente la sezione per aggiungere i componenti al report e modificare le loro proprietà
in basso è presente la sezione con i messaggi di errore

Cliccando sul pulsante Anteprima il sistema genera l’anteprima del report all’interno di ireport. In ogni momento è possibile modificare il formato di output desiderato dal menù anteprima (ad esempio il formato pdf).

JASPERREPORTS

JASPERREPORTS TUTORIAL – 1 – INTRODUZIONE

19/06/2014 admin

JasperReports è un tool per la generazione e gestione dei report in ambiente JAVA. E ‘interamente scritto in Java ed è in grado di utilizzare dati provenienti da qualsiasi tipo di fonte di dati e di produrre documenti che possono essere visualizzati, stampati o esportati in una varietà di formati di documenti, tra cui HTML, PDF, Excel, Word e OpenOffice.

E’ possibile configurare JasperReports in modo da interrogare direttamente la fonte dati JDBC oppure, qualora non si voglia o non si possa interagire direttamente con il database, è possibile definire un Jasper Report DataSource.

Tra le fonti dati supportate le più comuni sono:

JDBC Connection
File XML
Java Bean Collection

Qualora non si volesse configurare un datasource è possibile inviare dei parametri direttamente in formato chiave, valore e generare il report in funzione di essi.

Nei prossimi articoli vedremo come integrare le fonti dati e generare il nostro report nel formato desiderato.

Faremo anche la conoscenza di un ottimo tool ireport, che ci consentirà di concentrarci sul design del report e tralasciare alcuni dettagli implementativi.

MAVEN

MAVEN TUTORIAL – 11 – INTEGRARE JASPERREPORTS

17/06/2014 admin

In questo articolo vedremo come integrare un interessante plugin maven per la compilazione automatica dei report realizzati con jasperReports.

Incominciamo con il creare il nostro progetto maven con la direttiva

mvn archetype:generate -DgroupId=com.mycompany.app -DartifactId=my-app -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

La direttiva crea una cartella contenente contenente il file pom.xml e la cartella src contenente i sorgenti e i file junit per l’esecuzione dei test.

Lanciamo la direttiva mvn eclipse:eclipse per creare i file necessari ad un progetto eclipse ed importiamo il progetto nel nostro workspace.

A questo punto agganciamo il plugin responsabile della compilazione dei sorgenti jrxml, tipici di JasperReports. Tale plugin prevede la presenza di una cartella jasperreports sotto src/main. Creiamo la cartella e modifichiamo il pom inserendo la dichiarazione del plugin.

<build>
  <plugins>
    <plugin>
      <groupId>org.codehaus.mojo</groupId>
      <artifactId>jasperreports-maven-plugin</artifactId>
      <executions>
        <execution>
          <goals>
            <goal>compile-reports</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

<build>

<groupId>org.codehaus.mojo</groupId>

<artifactId>jasperreports-maven-plugin</artifactId>

<goals>

<goal>compile-reports</goal>

</goals>

</execution>

</executions>

</plugin>

</plugins>

</build>

A questo punto lanciamo la direttiva mvn compile per verificare la correttezza delle nostre operazioni. Se avete sbagliato a posizionare la cartella il plugin vi ricorderà il percorso esatto.

Restano da definire le dipendenze dalla versione di jasperReports da usare. Per farlo è sufficiente specificare la dipendenza a livello di progetto e a livello di plugin, nel nostro caso ho scelto la versione 4.0.2

 <dependencies>
    <dependency>
      <groupId>net.sf.jasperreports</groupId>
      <artifactId>jasperreports</artifactId>
      <version>4.0.2</version>
    </dependency>
  </dependencies>

<groupId>net.sf.jasperreports</groupId>

<artifactId>jasperreports</artifactId>

</dependency>

</dependencies>

Creiamo il nostro file jrxml nella cartella jasperreports e lanciamo la direttiva mcn compile. A questo sotto la cartella target avremo il nostro file compilato e pronto all’uso.

Il vantaggio di questa soluzione è di aver all’atto della compilazione tutti i report in linea con i file jrxml presenti nel progetto.

Qui trovate i sorgenti dell’articolo.

www.valeriofinazzo.it

Archivi tag: jasperreports

JASPERREPORTS TUTORIAL – 8 – PAGINARE IL REPORT

JASPERREPORTS TUTORIAL – 7 – INTEGRARE IL REPORT IN UNA SERVLET

JASPERREPORTS TUTORIAL – 6 – CREIAMO IL NOSTRO REPORT IN JAVA

JASPERREPORTS TUTORIAL – 5 – DATASOURCE XML

JASPERREPORTS TUTORIAL – 4 – DATASOURCE JDBC

JASPERREPORTS TUTORIAL – 3 – STRUTTURA DEL REPORT JRXML

JASPERREPORTS TUTORIAL – 2 – USARE IREPORT

JASPERREPORTS TUTORIAL – 1 – INTRODUZIONE

MAVEN TUTORIAL – 11 – INTEGRARE JASPERREPORTS

Il sito dell'ingegnere Valerio Finazzo