Le processus de génération de rapport consiste le plus souvent à remplir les modèles de document prédéfinis contenant les espaces réservés pour les champs souhaités. Les moteurs de génération de rapports prennent le modèle de document en entrée, remplissent dynamiquement les espaces réservés avec les données et génèrent les rapports résultants. Cet article va également présenter un cas d’utilisation similaire dans lequel vous pouvez générer les documents Word en remplissant les modèles Word de manière dynamique et par programmation à l’aide de Java.
Pour générer des documents Word à partir de modèles DOCX, nous utiliserons le LINQ Reporting Engine proposé par l’API Aspose.Words for Java. LINQ Reporting Engine prend en charge une variété de balises pour le texte, les images, les listes, les tableaux, les liens hypertexte et les signets pour les modèles Word. Les modèles de documents contenant ces balises sont remplis par le moteur avec des données provenant d’objets Java ainsi que des sources de données XML, JSON ou CSV. Commençons donc à générer les documents Word à partir des modèles en utilisant Java.
Cet article explique comment générer un document Word à partir d’un modèle en utilisant :
- les valeurs des objets Java,
- Source de données XML,
- source de données JSON,
- et source de données CSV.
Installation d’Aspose.Words for Java - API d’automatisation de mots et de génération de rapports
Vous pouvez télécharger Aspose.Words for Java JAR ou l’ajouter à votre application basée sur Maven en utilisant les configurations suivantes.
Repository:
<repository>
<id>AsposeJavaAPI</id>
<name>Aspose Java API</name>
<url>https://repository.aspose.com/repo/</url>
</repository>
Dependency:
<dependency>
<groupId>com.aspose</groupId>
<artifactId>aspose-words</artifactId>
<version>20.1</version>
<type>pom</type>
</dependency>
Générer des documents Word à partir d’un modèle à l’aide d’objets Java
Pour commencer la génération du rapport, créons d’abord un document Word en remplissant le modèle avec les valeurs des objets Java. Pour définir un modèle de document, créez un nouveau document Word, insérez les balises suivantes et enregistrez-le en tant que document DOCX.
<<[s.getName()]>> says: "<<[s.getMessage()]>>."
Dans le modèle ci-dessus, “s” sera traité comme un objet de classe Java qui sera utilisé pour remplir les balises. Créons donc une classe nommée Sender avec deux membres de données.
public class Sender {
public Sender(String name, String message) {
_name = name;
_message = message;
}
public String getName() {
return _name;
}
public String getMessage() {
return _message;
}
private String _name;
private String _message;
}
Il est maintenant temps de transmettre le modèle Word au moteur de génération de rapports LINQ et de générer le document Word en fonction des valeurs de l’objet de l’expéditeur. Voici les étapes pour générer le document Word :
- Créez l’objet Document et initialisez-le avec le chemin du modèle.
- Créez et initialisez un objet de la classe Sender.
- Créez un objet de la classe ReportingEngine.
- Créez le rapport à l’aide de la méthode ReportingEngine.buildReport() qui accepte le modèle de document, la source de données et le nom de la source de données.
- Enregistrez le document Word généré à l’aide de la méthode Document.save().
L’exemple de code suivant montre comment générer un document Word à partir d’un modèle Word à l’aide des valeurs de l’objet Java.
// Créez un objet Document et initialisez avec le modèle DOCX.
Document doc = new Document("template.docx");
// Créer un objet expéditeur.
Sender sender = new Sender("LINQ Reporting Engine", "Hello World");
// Créez un objet ReportingEngine.
ReportingEngine engine = new ReportingEngine();
// Créer un rapport.
engine.buildReport(doc, sender, "s");
// Enregistrer en tant que document Word.
doc.save("word.docx");
Production
Créer des documents Word à partir d’un modèle à l’aide de données XML
Allons maintenant plus loin et voyons comment remplir les modèles Word à l’aide d’une source de données XML dans un scénario un peu complexe. Voici la source de données XML que nous utiliserons pour remplir le modèle Word.
<Persons>
<Person>
<Name>John Doe</Name>
<Age>30</Age>
<Birth>1989-04-01 4:00:00 pm</Birth>
</Person>
<Person>
<Name>Jane Doe</Name>
<Age>27</Age>
<Birth>1992-01-31 07:00:00 am</Birth>
</Person>
<Person>
<Name>John Smith</Name>
<Age>51</Age>
<Birth>1968-03-08 1:00:00 pm</Birth>
</Person>
</Persons>
Dans ce scénario, nous utiliserons les balises suivantes dans le modèle de document pour plusieurs enregistrements dans la source de données XML.
<<foreach [in persons]>>Name: <<[Name]>>, Age: <<[Age]>>, Date of Birth: <<[Birth]:"dd.MM.yyyy">>
<</foreach>>
Average age: <<[persons.average(p => p.Age)]>>
Le code Java pour générer un document Word, dans ce cas, serait le même et à l’exception du passage de l’objet Java comme source de données, nous passerons l’objet XmlDataSource dans la méthode ReportingEngine.buildReport(). L’exemple de code suivant montre comment créer un document Word en remplissant le modèle de document à l’aide de la source de données XML en Java.
// Créez un objet Document et initialisez avec le modèle DOCX.
Document doc = new Document("template.docx");
// Charger XML
XmlDataSource dataSource = new XmlDataSource("./datasource.xml");
// Créez un objet ReportingEngine.
ReportingEngine engine = new ReportingEngine();
// Créer un rapport.
engine.buildReport(doc, dataSource, "persons");
// Enregistrer en tant que document Word.
doc.save("word.docx");
Production
Générer des documents Word à partir d’un modèle à l’aide de données JSON
Voyons maintenant comment générer un document Word à partir du modèle DOCX à l’aide d’une source de données JSON. Voici les données JSON que nous utiliserons dans cet exemple.
[
{
Name: "John Smith",
Contract:
[
{
Client:
{
Name: "A Company"
},
Price: 1200000
},
{
Client:
{
Name: "B Ltd."
},
Price: 750000
},
{
Client:
{
Name: "C & D"
},
Price: 350000
}
]
},
{
Name: "Tony Anderson",
Contract:
[
{
Client:
{
Name: "E Corp."
},
Price: 650000
},
{
Client:
{
Name: "F & Partners"
},
Price: 550000
}
]
},
]
Dans cet exemple, nous allons générer le document Word contenant la liste des clients regroupés par leurs responsables. Conformément à ce scénario, le modèle DOCX ressemblera à ceci :
<<foreach [in managers]>>Manager: <<[Name]>>
Contracts:
<<foreach [in Contract]>>- <<[Client.Name]>> ($<<[Price]>>)
<</foreach>>
<</foreach>>
Pour charger la source de données JSON, Aspose.Words fournit la classe JsonDataSource. L’exemple de code suivant montre comment créer un document Word à partir du modèle à l’aide d’une source de données JSON en Java.
// Créez un objet Document et initialisez avec le modèle DOCX.
Document doc = new Document("template.docx");
// Charger JSON
JsonDataSource dataSource = new JsonDataSource("datasource.json");
// Créez un objet ReportingEngine.
ReportingEngine engine = new ReportingEngine();
// Créer un rapport.
engine.buildReport(doc, dataSource, "managers");
// Enregistrer en tant que document Word.
doc.save("word.docx");
Production
Générer des documents Word à partir d’un modèle à l’aide de données CSV
Enfin et surtout, voyons comment générer le document Word en remplissant le modèle Word à l’aide de la source de données CSV suivante.
John Doe,30,1989-04-01 4:00:00 pm
Jane Doe,27,1992-01-31 07:00:00 am
John Smith,51,1968-03-08 1:00:00 pm
Le modèle Word suivant sera utilisé dans cet exemple :
<<foreach [in persons]>>Name: <<[Column1]>>, Age: <<[Column2]>>, Date of Birth: <<[Column3]:"dd.MM.yyyy">>
<</foreach>>
Average age: <<[persons.average(p => p.Column2)]>>
Pour traiter les sources de données CSV, Aspose.Words propose la classe CsvDataSource. L’exemple de code suivant montre comment générer un document Word à l’aide d’une source de données CSV en Java.
// Créez un objet Document et initialisez avec le modèle DOCX.
Document doc = new Document("template.docx");
// Charger le CSV
CsvDataSource dataSource = new CsvDataSource("datasource.csv");
// Créez un objet ReportingEngine.
ReportingEngine engine = new ReportingEngine();
// Créer un rapport.
engine.buildReport(doc, dataSource, "persons");
// Enregistrer en tant que document Word.
doc.save("word.docx");
Production
En savoir plus sur le moteur de création de rapports LINQ
LINQ Reporting Engine prend en charge une large gamme de balises pour générer dynamiquement des documents Word complets en Java. Vous pouvez en savoir plus sur ces balises ainsi que sur leur syntaxe dans cet article.
Au cas où vous auriez des questions ou des requêtes, vous pouvez poster sur Forum Aspose.Words.