O processo de geração de relatórios geralmente consiste em preencher os modelos de documentos predefinidos que contêm os espaços reservados para os campos desejados. Os mecanismos de relatório usam o documento modelo como entrada, preenchem os espaços reservados com os dados dinamicamente e geram os relatórios resultantes. Este artigo também mostrará um caso de uso semelhante em que você pode gerar os documentos do Word preenchendo os modelos do Word de forma dinâmica e programática usando Java.
Para gerar documentos do Word a partir de modelos DOCX, usaremos o LINQ Reporting Engine oferecido pela API Aspose.Words for Java. O LINQ Reporting Engine oferece suporte a uma variedade de marcas para texto, imagens, listas, tabelas, hiperlinks e marcadores para modelos do Word. Os documentos de modelo que contêm essas tags são preenchidos pelo mecanismo com dados provenientes de objetos Java, bem como fontes de dados XML, JSON ou CSV. Então vamos começar a gerar os documentos do Word a partir dos templates usando Java.
Este artigo abordará como gerar um documento do Word a partir de um modelo usando:
- valores dos objetos Java,
- fonte de dados XML,
- fonte de dados JSON,
- e fonte de dados CSV.
Instalando o Aspose.Words para Java - API de Automação do Word e Geração de Relatórios
Você pode baixar Aspose.Words para Java JAR ou adicioná-lo ao seu aplicativo baseado em Maven usando as seguintes configurações.
Repositório:
<repository>
<id>AsposeJavaAPI</id>
<name>Aspose Java API</name>
<url>https://repository.aspose.com/repo/</url>
</repository>
Dependência:
<dependency>
<groupId>com.aspose</groupId>
<artifactId>aspose-words</artifactId>
<version>20.1</version>
<type>pom</type>
</dependency>
Gerar documentos do Word a partir do modelo usando objetos Java
Para iniciar a geração do relatório, vamos primeiro criar um documento do Word preenchendo o modelo com valores dos objetos Java. Para definir um modelo de documento, crie um novo documento Word, insira as seguintes tags e salve-o como um documento DOCX.
<<[s.getName()]>> says: "<<[s.getMessage()]>>."
No template acima, “s” será tratado como um objeto da classe Java que será utilizado para preencher as tags. Então vamos criar uma classe chamada Sender com dois membros de dados.
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;
}
Agora, é hora de passar o modelo do Word para o LINQ Reporting Engine e gerar o documento do Word com base nos valores do objeto do Remetente. A seguir estão as etapas para gerar o documento do Word:
- Crie o objeto Document e inicialize-o com o caminho do template.
- Crie e inicialize um objeto da classe Sender.
- Crie um objeto da classe ReportingEngine.
- Crie o relatório usando o método ReportingEngine.buildReport() que aceita o modelo de documento, a fonte de dados e o nome da fonte de dados.
- Salve o documento do Word gerado usando o método Document.save().
O exemplo de código a seguir mostra como gerar um documento do Word a partir de um modelo do Word usando os valores do objeto Java.
// Crie o objeto Document e inicialize com o modelo DOCX.
Document doc = new Document("template.docx");
// Criar objeto Sender.
Sender sender = new Sender("LINQ Reporting Engine", "Hello World");
// Crie o objeto ReportingEngine.
ReportingEngine engine = new ReportingEngine();
// Construir relatório.
engine.buildReport(doc, sender, "s");
// Salve como documento do Word.
doc.save("word.docx");
Resultado
Criar documentos do Word a partir do modelo usando dados XML
Vamos agora dar um passo adiante e ver como preencher os modelos do Word usando uma fonte de dados XML em um cenário um pouco complexo. Veja a seguir a fonte de dados XML que usaremos para preencher o modelo do 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>
Nesse cenário, usaremos as seguintes tags no documento de modelo para vários registros na fonte de dados XML.
<<foreach [in persons]>>Name: <<[Name]>>, Age: <<[Age]>>, Date of Birth: <<[Birth]:"dd.MM.yyyy">>
<</foreach>>
Average age: <<[persons.average(p => p.Age)]>>
O código Java para gerar o documento Word, neste caso, seria o mesmo e, exceto pela passagem do objeto Java como fonte de dados, passaremos o objeto XmlDataSource no método ReportingEngine.buildReport(). O exemplo de código a seguir mostra como criar um documento do Word preenchendo o modelo de documento usando a fonte de dados XML em Java.
// Crie o objeto Document e inicialize com o modelo DOCX.
Document doc = new Document("template.docx");
// Carregar XML
XmlDataSource dataSource = new XmlDataSource("./datasource.xml");
// Crie o objeto ReportingEngine.
ReportingEngine engine = new ReportingEngine();
// Construir relatório.
engine.buildReport(doc, dataSource, "persons");
// Salve como documento do Word.
doc.save("word.docx");
Resultado
Gerar documentos do Word a partir do modelo usando dados JSON
Vamos agora dar uma olhada em como gerar um documento do Word a partir do modelo DOCX usando uma fonte de dados JSON. A seguir estão os dados JSON que usaremos neste exemplo.
[
{
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
}
]
},
]
Neste exemplo, vamos gerar o documento Word contendo uma lista dos clientes agrupados por seus gerentes. De acordo com este cenário, o modelo DOCX terá a seguinte aparência:
<<foreach [in managers]>>Manager: <<[Name]>>
Contracts:
<<foreach [in Contract]>>- <<[Client.Name]>> ($<<[Price]>>)
<</foreach>>
<</foreach>>
Para carregar a fonte de dados JSON, o Aspose.Words fornece a classe JsonDataSource. O exemplo de código a seguir mostra como criar um documento do Word a partir do modelo usando uma fonte de dados JSON em Java.
// Crie o objeto Document e inicialize com o modelo DOCX.
Document doc = new Document("template.docx");
// Carregar JSON
JsonDataSource dataSource = new JsonDataSource("datasource.json");
// Crie o objeto ReportingEngine.
ReportingEngine engine = new ReportingEngine();
// Construir relatório.
engine.buildReport(doc, dataSource, "managers");
// Salve como documento do Word.
doc.save("word.docx");
Resultado
Gerar documentos do Word a partir do modelo usando dados CSV
Por último, mas não menos importante, vamos verificar como gerar o documento do Word preenchendo o modelo do Word usando a seguinte fonte de dados 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
O seguinte modelo do Word será usado neste exemplo:
<<foreach [in persons]>>Name: <<[Column1]>>, Age: <<[Column2]>>, Date of Birth: <<[Column3]:"dd.MM.yyyy">>
<</foreach>>
Average age: <<[persons.average(p => p.Column2)]>>
Para lidar com fontes de dados CSV, o Aspose.Words oferece a classe CsvDataSource. O exemplo de código a seguir mostra como gerar um documento do Word usando uma fonte de dados CSV em Java.
// Crie o objeto Document e inicialize com o modelo DOCX.
Document doc = new Document("template.docx");
// Carregar CSV
CsvDataSource dataSource = new CsvDataSource("datasource.csv");
// Crie o objeto ReportingEngine.
ReportingEngine engine = new ReportingEngine();
// Construir relatório.
engine.buildReport(doc, dataSource, "persons");
// Salve como documento do Word.
doc.save("word.docx");
Resultado
Saiba mais sobre o LINQ Reporting Engine
O LINQ Reporting Engine oferece suporte a uma ampla variedade de marcas para gerar documentos do Word com todos os recursos dinamicamente em Java. Você pode explorar mais sobre essas tags junto com sua sintaxe em este artigo.
Caso você tenha alguma dúvida ou pergunta, você pode postar no Aspose.Words Forum.