TOC

JasperReports avec Spring

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 allons explorer ses principales fonctionnalités et classes, et mettre en œuvre des exemples pour présenter ses fonctionnalités.

2. Dépendance Maven

Tout d'abord, nous devons ajouter la dépendancejasperreports à nospom.xml: 


    net.sf.jasperreports
    jasperreports
    6.4.0

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

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 à présent 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 avec des données.

Faisons cette opération à l’aide de la classeJasperCompilerManager: 

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. Peuplement 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.

Commençons par modifier 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 transmettonsnull 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 peut pas trouver 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 portions, voire la totalité de la requête SQL, avec les paramètres reçus lors de l'opération de remplissage du rapport.

Commençons par modifier le rapport pour recevoir trois paramètres: 


    
    
    
        
          
    
    // ...

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


    // ...
    
        <band height="20" splitType="Stretch">
            <textField>
                <reportElement x="238" y="0" width="100" height="20"/>
                <textElement/>
                <textFieldExpression class="java.lang.String">
                  <![CDATA[$P{title}]]></textFieldExpression>
            </textField>
        </band>
    
    ...

Ensuite, modifions la requête pour utiliser les paramètresminSalary etcondition: 

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

Notez la syntaxe différente lors de l'utilisation du paramètrecondition. Cela indique au moteur que le paramètre ne doit pas être utilisé comme paramètre standardPreparedStatement, 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 deparameters correspondent aux noms de paramètres dans le rapport. Si le moteur détecte qu'un paramètre est manquant, il obtiendra la valeur dedefaultValueExpression du paramètre le cas échéant.

5. Exportation

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

Ensuite, nous définissons notre rapport rempli précédent en tant qu'entrée et définissons où le fichier résultant doit être généré.

Vous pouvez éventuellement définir les objets de configuration de rapport et d'exportation correspondants 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("example");
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 sur les employés 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 lesidEmployee et la connexion actuelle du rapport comme 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 pour remplir et exporter le rapport ne nécessite aucune modification.

7. Conclusion

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

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

Le code source complet de cet article peut être trouvéover on GitHub.

Related