El proceso de generación de informes suele consistir en completar las plantillas de documentos predefinidas que contienen los marcadores de posición para los campos deseados. Los motores de generación de informes toman el documento de plantilla como entrada, rellenan los marcadores de posición con los datos de forma dinámica y generan los informes resultantes. Este artículo también mostrará un caso de uso similar en el que puede generar documentos de Word completando las plantillas de Word de forma dinámica y programática con Java.
Para generar documentos de Word a partir de plantillas DOCX, utilizaremos el LINQ Reporting Engine ofrecido por Aspose.Words for Java API. LINQ Reporting Engine admite una variedad de etiquetas para texto, imágenes, listas, tablas, hipervínculos y marcadores para plantillas de Word. El motor completa los documentos de plantilla que contienen estas etiquetas con datos provenientes de objetos Java, así como fuentes de datos XML, JSON o CSV. Entonces, comencemos a generar los documentos de Word a partir de las plantillas usando Java.
Este artículo cubrirá cómo generar un documento de Word a partir de una plantilla usando:
- valores de los objetos Java,
- fuente de datos XML,
- fuente de datos JSON,
- y fuente de datos CSV.
Instalación de Aspose.Words for Java: API de generación de informes y automatización de Word
Puede descargar Aspose.Words for Java JAR o agregarlo a su aplicación basada en Maven usando las siguientes configuraciones.
Repositorio:
<repository>
<id>AsposeJavaAPI</id>
<name>Aspose Java API</name>
<url>https://repository.aspose.com/repo/</url>
</repository>
Dependencia:
<dependency>
<groupId>com.aspose</groupId>
<artifactId>aspose-words</artifactId>
<version>20.1</version>
<type>pom</type>
</dependency>
Genere documentos de Word a partir de una plantilla usando objetos Java
Para comenzar la generación del informe, primero creemos un documento de Word completando la plantilla con valores de los objetos de Java. Para definir una plantilla de documento, cree un nuevo documento de Word, inserte las siguientes etiquetas y guárdelo como un documento DOCX.
<<[s.getName()]>> says: "<<[s.getMessage()]>>."
En la plantilla anterior, “s” se tratará como un objeto de la clase Java que se usará para completar las etiquetas. Así que vamos a crear una clase llamada Sender con dos miembros de datos.
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;
}
Ahora es el momento de pasar la plantilla de Word al motor de informes de LINQ y generar el documento de Word basado en los valores del objeto del remitente. Los siguientes son los pasos para generar el documento de Word:
- Cree el objeto Document e inicialícelo con la ruta de la plantilla.
- Crea e inicializa un objeto de la clase Sender.
- Cree un objeto de la clase ReportingEngine.
- Cree el informe utilizando el método ReportingEngine.buildReport() que acepta la plantilla del documento, la fuente de datos y el nombre de la fuente de datos.
- Guarde el documento de Word generado utilizando el método Document.save().
El siguiente ejemplo de código muestra cómo generar un documento de Word a partir de una plantilla de Word utilizando los valores del objeto Java.
// Cree el objeto Documento e inicialícelo con la plantilla DOCX.
Document doc = new Document("template.docx");
// Crear objeto Remitente.
Sender sender = new Sender("LINQ Reporting Engine", "Hello World");
// Crear objeto ReportingEngine.
ReportingEngine engine = new ReportingEngine();
// Informe de compilación.
engine.buildReport(doc, sender, "s");
// Guardar como documento de Word.
doc.save("word.docx");
Producción
Cree documentos de Word a partir de una plantilla utilizando datos XML
Ahora demos un paso más y veamos cómo llenar las plantillas de Word usando una fuente de datos XML en un escenario un poco complejo. La siguiente es la fuente de datos XML que usaremos para completar la plantilla de 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>
En este escenario, usaremos las siguientes etiquetas en el documento de plantilla para varios registros en la fuente de datos XML.
<<foreach [in persons]>>Name: <<[Name]>>, Age: <<[Age]>>, Date of Birth: <<[Birth]:"dd.MM.yyyy">>
<</foreach>>
Average age: <<[persons.average(p => p.Age)]>>
El código Java para generar un documento de Word, en este caso, sería el mismo y excepto por pasar el objeto Java como fuente de datos, pasaremos el objeto XmlDataSource en el método ReportingEngine.buildReport(). El siguiente ejemplo de código muestra cómo crear un documento de Word llenando la plantilla del documento usando una fuente de datos XML en Java.
// Cree el objeto Documento e inicialícelo con la plantilla DOCX.
Document doc = new Document("template.docx");
// Cargar XML
XmlDataSource dataSource = new XmlDataSource("./datasource.xml");
// Crear objeto ReportingEngine.
ReportingEngine engine = new ReportingEngine();
// Informe de compilación.
engine.buildReport(doc, dataSource, "persons");
// Guardar como documento de Word.
doc.save("word.docx");
Producción
Genere documentos de Word a partir de una plantilla utilizando datos JSON
Veamos ahora cómo generar un documento de Word a partir de la plantilla DOCX utilizando una fuente de datos JSON. Los siguientes son los datos JSON que usaremos en este ejemplo.
[
{
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
}
]
},
]
En este ejemplo, generaremos el documento de Word que contiene una lista de los clientes agrupados por sus gerentes. De acuerdo con este escenario, la plantilla DOCX tendrá el siguiente aspecto:
<<foreach [in managers]>>Manager: <<[Name]>>
Contracts:
<<foreach [in Contract]>>- <<[Client.Name]>> ($<<[Price]>>)
<</foreach>>
<</foreach>>
Para cargar la fuente de datos JSON, Aspose.Words proporciona la clase JsonDataSource. El siguiente ejemplo de código muestra cómo crear un documento de Word a partir de la plantilla utilizando una fuente de datos JSON en Java.
// Cree el objeto Documento e inicialícelo con la plantilla DOCX.
Document doc = new Document("template.docx");
// Cargar JSON
JsonDataSource dataSource = new JsonDataSource("datasource.json");
// Crear objeto ReportingEngine.
ReportingEngine engine = new ReportingEngine();
// Informe de compilación.
engine.buildReport(doc, dataSource, "managers");
// Guardar como documento de Word.
doc.save("word.docx");
Producción
Genere documentos de Word a partir de una plantilla usando datos CSV
Por último, pero no menos importante, veamos cómo generar el documento de Word completando la plantilla de Word con la siguiente fuente de datos 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
En este ejemplo se utilizará la siguiente plantilla de Word:
<<foreach [in persons]>>Name: <<[Column1]>>, Age: <<[Column2]>>, Date of Birth: <<[Column3]:"dd.MM.yyyy">>
<</foreach>>
Average age: <<[persons.average(p => p.Column2)]>>
Para manejar fuentes de datos CSV, Aspose.Words ofrece la clase CsvDataSource. El siguiente ejemplo de código muestra cómo generar un documento de Word utilizando una fuente de datos CSV en Java.
// Cree el objeto Documento e inicialícelo con la plantilla DOCX.
Document doc = new Document("template.docx");
// Cargar CSV
CsvDataSource dataSource = new CsvDataSource("datasource.csv");
// Crear objeto ReportingEngine.
ReportingEngine engine = new ReportingEngine();
// Informe de compilación.
engine.buildReport(doc, dataSource, "persons");
// Guardar como documento de Word.
doc.save("word.docx");
Producción
Más información sobre el motor de informes de LINQ
LINQ Reporting Engine admite una amplia gama de etiquetas para generar documentos de Word con todas las funciones de forma dinámica en Java. Puede explorar más sobre estas etiquetas junto con su sintaxis en este artículo.
En caso de que tenga alguna pregunta o consulta, puede publicar en Aspose.Words Forum.