JasperReports avec Spring

1. Vue d'ensemble

JasperReports est une bibliothèque de rapports open source qui permet aux utilisateurs de créer des rapports au pixel près qui peuvent être imprimés ou exportés dans de nombreux formats, notamment PDF, HTML et XLS.

Dans cet article, nous explorerons ses principales fonctionnalités et classes, et implémenterons des exemples pour présenter ses capacités.

2. Dépendance de Maven

Tout d'abord, nous devons ajouter la dépendance jasperreports à notre pom.xml :

 net.sf.jasperreports jasperreports 6.4.0 

La dernière version de cet artefact peut être trouvée ici.

3. Modèles de rapport

Les conceptions de rapport sont définies dans des fichiers JRXML. Ce sont des fichiers XML ordinaires avec une structure particulière que le moteur JasperReports peut interpréter.

Examinons maintenant uniquement la structure pertinente des fichiers JRXML - pour mieux comprendre la partie Java du processus de génération de rapport, qui est notre objectif principal.

Créons un rapport simple pour afficher les informations sur les employés:

3.1. Compilation de rapports

Les fichiers JRXML doivent être compilés pour que le moteur de rapport puisse les remplir de données.

Effectuons cette opération à l'aide de la classe JasperCompilerManager :

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

Pour éviter de le compiler à chaque fois, nous pouvons le sauvegarder dans un fichier:

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

4. Remplissage des rapports

Le moyen le plus courant de remplir des rapports compilés consiste à utiliser des enregistrements d'une base de données. Cela nécessite que le rapport contienne une requête SQL que le moteur exécutera pour obtenir les données.

Tout d'abord, modifions notre rapport pour ajouter une requête SQL:

    ... 

Maintenant, créons une source de données simple:

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

Maintenant, nous pouvons remplir le rapport:

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

Notez que nous transmettons null au deuxième argument car notre rapport ne reçoit pas encore de paramètres.

4.1. Paramètres

Les paramètres sont utiles pour transmettre au moteur de rapports des données qu'il ne trouve pas dans sa source de données ou lorsque les données changent en fonction de différentes conditions d'exécution.

Nous pouvons également modifier des parties ou même l'ensemble de la requête SQL avec les paramètres reçus lors de l'opération de remplissage du rapport.

Tout d'abord, modifions le rapport pour recevoir trois paramètres:

       // ... 

Maintenant, ajoutons une section de titre pour afficher le paramètre de titre :

 // ...           ... 

Ensuite, modifions la requête pour utiliser les paramètres minSalary et condition :

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

Notez la syntaxe différente lors de l'utilisation du paramètre de condition . Cela indique au moteur que le paramètre ne doit pas être utilisé en tant que paramètre PreparedStatement standard , mais comme si la valeur de ce paramètre aurait été écrite à l'origine dans la requête SQL.

Enfin, préparons les paramètres et remplissons le rapport:

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, ...);

Notez que les clés des paramètres correspondent aux noms de paramètres dans le rapport. Si le moteur détecte qu'un paramètre est manquant, il obtiendra la valeur de defaultValueExpression du paramètre le cas échéant.

5. Exportation

Pour exporter un rapport, tout d'abord, nous instancions un objet d'une classe d'exportateur qui correspond au format de fichier dont nous avons besoin.

Ensuite, nous définissons notre précédent rapport rempli comme entrée et définissons où sortir le fichier résultant.

En option, nous pouvons définir le rapport correspondant et les objets de configuration d'exportation pour personnaliser le processus d'exportation.

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("baeldung"); 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. Sous-rapports

Les sous-rapports ne sont rien de plus qu'un rapport standard intégré dans un autre rapport.

Commençons par créer un rapport pour afficher les e-mails d'un employé:

Maintenant, modifions notre rapport d'employé pour inclure le précédent:

Notez que nous référençons le sous-rapport par le nom du fichier compilé et lui passons l' idEmployee et la connexion de rapport actuelle en tant que paramètres.

Ensuite, compilons les deux rapports:

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");

Notre code de remplissage et d'exportation du rapport ne nécessite aucune modification.

7. Conclusion

Dans cet article, nous avons examiné brièvement les principales fonctionnalités de la bibliothèque JasperReports.

Nous avons pu compiler et remplir des rapports avec des enregistrements d'une base de données; nous avons transmis des paramètres pour modifier les données affichées dans le rapport en fonction de différentes conditions d'exécution, incorporé des sous-rapports et les avons exportés vers les formats les plus courants.

Le code source complet de cet article est disponible à l'adresse over sur GitHub.