Bibliothèque modulaire jasper-modular pour JasperReports

Bibliothèque modulaire pour JasperReports : Simplifier les sous-rapports et les données

Travailler avec des rapports volumineux dans JasperReports conduit souvent à des fichiers JRXML monolithiques. La conception, la logique des données et les règles métier se mélangent, rendant la maintenance difficile. Les sous-rapports abordent la modularité, mais le passage des données introduit des complexités.

Approches typiques pour les données :

• JSON unique : JsonDataSource avec des chemins dans le XML. Les erreurs de chemin ne sont pas détectées à la compilation, et REPORT_DATA_SOURCE est passé implicitement.
• SQL dans les modèles : REPORT_CONNECTION pour les requêtes. La logique réside en dehors de Java, sans vérification de type.
• Passage de REPORT_DATA_SOURCE : Les sources de données consommables sont épuisées après le premier sous-rapport.
• Paramètres manuels : Des dizaines de <subreportParameter> et de params.put() en Java, nécessitant une synchronisation.

Le principe de jasper-modular

La bibliothèque passe deux paramètres dans chaque sous-rapport :

• <prefix>Report — le JasperReport compilé.
• <prefix>MapParameter — une Map<String, Object> contenant les données.

La map est décompressée via REPORT_PARAMETERS_MAP : les clés deviennent $P{key} sans <subreportParameter>. Un processeur d'annotations génère les paramètres et le JRXML pendant la compilation. Le moteur de rendu peuple récursivement les sous-rapports en utilisant la réflexion.

Ajouter les dépendances

Pour JasperReports 7.x :

<dependency>
    <groupId>io.github.hhdevr</groupId>
    <artifactId>jasper-modular-starter-jr7</artifactId>
    <version>1.0.0</version>
</dependency>

Pour 6.x :

<dependency>
    <groupId>io.github.hhdevr</groupId>
    <artifactId>jasper-modular-starter-jr6</artifactId>
    <version>1.0.0</version>
</dependency>

Processeur d'annotations dans maven-compiler-plugin :

<plugin>
    <groupId>org.apache.maven.plugins</groupId>
    <artifactId>maven-compiler-plugin</artifactId>
    <configuration>
        <annotationProcessorPaths>
            <path>
                <groupId>io.github.hhdevr</groupId>
                <artifactId>jasper-modular-processor-jr7</artifactId>
                <version>1.0.0</version>
            </path>
        </annotationProcessorPaths>
    </configuration>
</plugin>

Structure des classes de rapport

Rapport racine :

@Getter
@Setter
@JasperModularReport(templatePath = "/reports/company_report.jrxml")
public class CompanyReport extends ModularReport {
    private TitleSubModule titleSubModule;
    private FinancialSubModule financialSubModule;
}

Sous-rapport :

@Getter
@Setter
@JasperSubreport(templatePath = "/reports/sub_title_report.jrxml", prefix = "Title")
public class TitleSubModule extends SubreportModule {
    private CompanyDetails companyDetails;
    private String period;
    private String currency;

    @Override
    public boolean isEmpty() {
        return companyDetails == null;
    }
}

Imbrication : FinancialSubModule contient RevenueSubModule, ExpenseSubModule, ProfitSubModule. Chaque module vérifie isEmpty() pour un rendu conditionnel.

Collections :

@JasperCollection(columnWidth = 150)
private List<RevenueItem> items;

Exclusion de champs :

@JasperIgnore
private transient String internalCache;

Modes de génération JRXML

Le processeur d'annotations met à jour les modèles dans target/generated-sources/ :

• CREATE : Génère un JRXML complet avec paramètres, jeux de données, composants de collection et bandes de sous-rapports.
• INJECT (par défaut) : Ajoute les éléments manquants tout en préservant la conception existante.
• NONE : Aucune modification.

Après la génération, les modèles peuvent être affinés dans Jaspersoft Studio.

Exemple d'arborescence de projet :

• CompanyReport

- TitleSubModule (CompanyDetails, période, devise)

- FinancialSubModule

- RevenueSubModule (totalRevenus, pourcentageCroissance, List<RevenueItem>)

- ExpenseSubModule (totalDépenses, pourcentageCroissance, List<ExpenseItem>)

- ProfitSubModule (bénéficeBrut, bénéficeOpérationnel, bénéficeNet, marge, List<ProfitBreakdown>)

Points clés à retenir

• Modularité via des classes Java : sous-rapports en tant que champs, avec des données typées.
• Génération automatique des paramètres et du JRXML par le processeur d'annotations.
• Rendu récursif sans passage manuel des données.
• Prise en charge des collections avec @JasperCollection et une profondeur d'imbrication illimitée.
• Compatibilité avec JasperReports 6.x/7.x et Spring Boot 3.x/4.x.

— Editorial Team