Il processo di generazione dei report più spesso consiste nel popolare i modelli di documento predefiniti contenenti i segnaposto per i campi desiderati. I motori di reporting prendono il documento modello come input, popolano i segnaposto con i dati in modo dinamico e generano i report risultanti. Questo articolo mostrerà anche un caso d’uso simile in cui è possibile generare i documenti di Word popolando i modelli di Word in modo dinamico e programmatico utilizzando Java.
Per generare documenti Word da modelli DOCX, utilizzeremo il LINQ Reporting Engine offerto dall’API Aspose.Words for Java. LINQ Reporting Engine supporta una varietà di tag per testo, immagini, elenchi, tabelle, collegamenti ipertestuali e segnalibri per i modelli di Word. I documenti modello contenenti questi tag vengono popolati dal motore con dati provenienti da oggetti Java e origini dati XML, JSON o CSV. Quindi iniziamo a generare i documenti Word dai modelli usando Java.
Questo articolo tratterà come generare un documento Word da un modello utilizzando:
- valori dagli oggetti Java,
- origine dati XML,
- origine dati JSON,
- e origine dati CSV.
Installazione di Aspose.Words per Java - API di Word Automation e generazione di report
Puoi scaricare Aspose.Words per Java JAR o aggiungerlo alla tua applicazione basata su Maven utilizzando le seguenti configurazioni.
Archivio:
<repository>
<id>AsposeJavaAPI</id>
<name>Aspose Java API</name>
<url>https://repository.aspose.com/repo/</url>
</repository>
Dipendenza:
<dependency>
<groupId>com.aspose</groupId>
<artifactId>aspose-words</artifactId>
<version>20.1</version>
<type>pom</type>
</dependency>
Genera documenti Word dal modello utilizzando oggetti Java
Per iniziare la generazione del report, creiamo prima un documento Word popolando il modello con i valori degli oggetti Java. Per definire un modello di documento, crea un nuovo documento Word, inserisci i seguenti tag e salvalo come documento DOCX.
<<[s.getName()]>> says: "<<[s.getMessage()]>>."
Nel modello sopra, “s” verrà trattato come un oggetto di classe Java che verrà utilizzato per popolare i tag. Creiamo quindi una classe denominata Sender con due membri dati.
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;
}
Ora è il momento di passare il modello di Word al LINQ Reporting Engine e generare il documento di Word in base ai valori dell’oggetto del mittente. Di seguito sono riportati i passaggi per la generazione del documento Word:
- Crea l’oggetto Documento e inizializzalo con il percorso del modello.
- Crea e inizializza un oggetto della classe Sender.
- Crea un oggetto della classe ReportingEngine.
- Crea il report utilizzando il metodo ReportingEngine.buildReport() che accetta il modello di documento, l’origine dati e il nome dell’origine dati.
- Salva il documento Word generato usando il metodo Document.save().
Nell’esempio di codice seguente viene illustrato come generare un documento di Word da un modello di Word utilizzando i valori dell’oggetto Java.
// Crea un oggetto Document e inizializza con il modello DOCX.
Document doc = new Document("template.docx");
// Crea oggetto Mittente.
Sender sender = new Sender("LINQ Reporting Engine", "Hello World");
// Crea oggetto ReportingEngine.
ReportingEngine engine = new ReportingEngine();
// Crea rapporto.
engine.buildReport(doc, sender, "s");
// Salva come documento Word.
doc.save("word.docx");
Produzione
Crea documenti Word dal modello utilizzando dati XML
Facciamo ora un ulteriore passo avanti e vediamo come popolare i modelli di Word utilizzando un’origine dati XML in uno scenario un po’ complesso. Quella che segue è l’origine dati XML che useremo per popolare il modello di 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>
In questo scenario, utilizzeremo i seguenti tag nel documento modello per più record nell’origine dati XML.
<<foreach [in persons]>>Name: <<[Name]>>, Age: <<[Age]>>, Date of Birth: <<[Birth]:"dd.MM.yyyy">>
<</foreach>>
Average age: <<[persons.average(p => p.Age)]>>
Il codice Java per la generazione del documento Word, in questo caso, sarebbe lo stesso e, fatta eccezione per il passaggio dell’oggetto Java come origine dati, passeremo l’oggetto XmlDataSource nel metodo ReportingEngine.buildReport(). L’esempio di codice seguente mostra come creare un documento di Word compilando il modello di documento utilizzando l’origine dati XML in Java.
// Crea un oggetto Document e inizializza con il modello DOCX.
Document doc = new Document("template.docx");
// Carica XML
XmlDataSource dataSource = new XmlDataSource("./datasource.xml");
// Crea oggetto ReportingEngine.
ReportingEngine engine = new ReportingEngine();
// Crea rapporto.
engine.buildReport(doc, dataSource, "persons");
// Salva come documento Word.
doc.save("word.docx");
Produzione
Genera documenti Word dal modello utilizzando i dati JSON
Diamo ora un’occhiata a come generare un documento Word dal modello DOCX utilizzando un’origine dati JSON. Di seguito sono riportati i dati JSON che utilizzeremo in questo esempio.
[
{
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
}
]
},
]
In questo esempio, genereremo il documento Word contenente un elenco dei clienti raggruppati dai loro gestori. In base a questo scenario, il modello DOCX sarà simile al seguente:
<<foreach [in managers]>>Manager: <<[Name]>>
Contracts:
<<foreach [in Contract]>>- <<[Client.Name]>> ($<<[Price]>>)
<</foreach>>
<</foreach>>
Per caricare l’origine dati JSON, Aspose.Words fornisce la classe JsonDataSource. L’esempio di codice seguente mostra come creare un documento Word dal modello usando un’origine dati JSON in Java.
// Crea un oggetto Document e inizializza con il modello DOCX.
Document doc = new Document("template.docx");
// Carica JSON
JsonDataSource dataSource = new JsonDataSource("datasource.json");
// Crea oggetto ReportingEngine.
ReportingEngine engine = new ReportingEngine();
// Crea rapporto.
engine.buildReport(doc, dataSource, "managers");
// Salva come documento Word.
doc.save("word.docx");
Produzione
Genera documenti Word dal modello utilizzando i dati CSV
Ultimo ma non meno importante, diamo un’occhiata a come generare il documento di Word compilando il modello di Word utilizzando la seguente origine dati CSV.
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
In questo esempio verrà utilizzato il seguente modello di Word:
<<foreach [in persons]>>Name: <<[Column1]>>, Age: <<[Column2]>>, Date of Birth: <<[Column3]:"dd.MM.yyyy">>
<</foreach>>
Average age: <<[persons.average(p => p.Column2)]>>
Per gestire le origini dati CSV, Aspose.Words offre la classe CsvDataSource. L’esempio di codice seguente mostra come generare un documento Word utilizzando un’origine dati CSV in Java.
// Crea un oggetto Document e inizializza con il modello DOCX.
Document doc = new Document("template.docx");
// Carica CSV
CsvDataSource dataSource = new CsvDataSource("datasource.csv");
// Crea oggetto ReportingEngine.
ReportingEngine engine = new ReportingEngine();
// Crea rapporto.
engine.buildReport(doc, dataSource, "persons");
// Salva come documento Word.
doc.save("word.docx");
Produzione
Ulteriori informazioni su LINQ Reporting Engine
LINQ Reporting Engine supporta un’ampia gamma di tag per la generazione dinamica di documenti Word con funzionalità complete in Java. Puoi esplorare di più su questi tag insieme alla loro sintassi in questo articolo.
In caso aveste domande o domande, potete postare su Aspose.Words Forum.