TOC

Integração Spring Yarg

Integração Spring Yarg

1. Visão geral

O Yet Another Report Generator (YARG) é uma biblioteca de relatórios de código aberto para Java, desenvolvida pela Haulmont. Permite criar templates nos formatos mais comuns (.doc, .docs, .xls, .xlsx, .html, .ftl, .csv) ou formatos de texto customizados e preenchê-los com dados carregados por SQL, Groovy ou JSON.

Neste artigo, vamos demonstrar como usar um Spring@RestController que gera um documento.docx com dados carregados em JSON.

2. Configurando o exemplo

Para começar a usar YARG, precisamos adicionar as seguintes dependências ao nossopom: 


    
        
            false
        
        bintray-cuba-platform-main
        bintray
        http://dl.bintray.com/cuba-platform/main
    

...

    com.haulmont.yarg
    yarg
    2.0.4

Em seguida,we need a template for our data; vamos usar umLetter.docx simples: 

${Main.title}

Hello ${Main.name},

${Main.content}

Observe como o YARG usa uma linguagem de marcação / modelo - que permite a inserção de conteúdo nas diferentes seções. Essas seções são divididas em termos do grupo de dados ao qual eles pertencem.

Neste exemplo, temos um grupo “Principal” que contémtitle,name econtent da letra.

These groups are called ReportBand em YARG e são muito úteis para separar os diferentes tipos de dados que você pode ter.

3. Integrando a mola ao YARG

Uma das melhores maneiras de usar um gerador de relatórios é criar um serviço que possa nos devolver o documento.

E então, vamos usar Spring e implementar um@RestController simples que será responsável por ler o modelo, obter o JSON, carregá-lo no documento e retornar um.docx. formatado

Primeiro, vamos criar umDocumentController: 

@RestController
public class DocumentController {

    @GetMapping("/generate/doc")
    public void generateDocument(HttpServletResponse response)
      throws IOException {
    }
}

Isso irá expor a criação do documento como um serviço.

Agora vamos adicionar a lógica de carregamento para o modelo: 

ReportBuilder reportBuilder = new ReportBuilder();
ReportTemplateBuilder reportTemplateBuilder = new ReportTemplateBuilder()
  .documentPath("./src/main/resources/Letter.docx")
  .documentName("Letter.docx")
  .outputType(ReportOutputType.docx)
  .readFileFromPath();
reportBuilder.template(reportTemplateBuilder.build());

A classeReportBuilder será a responsável pela criação do relatório, agrupando o template e os dados. ReportTemplateBuilder carrega nosso modeloLetter.docx __ previamente definido especificando o caminho, o nome e o tipo de saída do documento.

Em seguida, iremosadd the loaded template para o criador de relatórios.

Agora precisamos definir os dados que vão ser inseridos no documento, este será um arquivoData.json com o seguinte: 

{
    "main": {
        "title" : "INTRODUCTION TO YARG",
        "name" : "example",
        "content" : "This is the content of the letter, can be anything we like."
    }
}

Essa é uma estrutura JSON simples com um objeto "principal" que contém o título, o nome e o conteúdo que nosso modelo precisa.

Agora, vamos continuar a carregar os dados em nossoReportBuilder: 

BandBuilder bandBuilder = new BandBuilder();
String json = FileUtils.readFileToString(
  new File("./src/main/resources/Data.json"));
ReportBand main = bandBuilder.name("Main")
  .query("Main", "parameter=param1 $.main", "json")
  .build();
reportBuilder.band(main);
Report report = reportBuilder.build();

Aqui definimos umBandBuilder para criar umReportBand, que é a abstração que YARG usa para os grupos de dados que definimos anteriormente no documento modelo.

Podemos ver que definimosthe name with the exact same section “Principal”, então usamos um método de consulta para encontrar a seção “Principal” e declarar um parâmetro que será usado para encontrar os dados necessários para preencher o modelo.

É importante observar que YARG usaJsonPath para percorrer o JSON, e é por isso que vemos esta sintaxe “$ .main”.

Em seguida, vamos especificar na consulta que o formato dos dados é “json” e, em seguida, adicionar a banda ao relatórioand finally, build it.

A última etapa é definir o objetoReporting, que é responsável por inserir os dados no template e gerar o documento final: 

Reporting reporting = new Reporting();
reporting.setFormatterFactory(new DefaultFormatterFactory());
reporting.setLoaderFactory(
  new DefaultLoaderFactory().setJsonDataLoader(new JsonDataLoader()));
response.setContentType(
 "application/vnd.openxmlformats-officedocument.wordprocessingml.document");
reporting.runReport(
  new RunParams(report).param("param1", json),
  response.getOutputStream());

Usamos umDefaultFormatterFactory que suporta os formatos comuns listados no início do artigo. Depois disso, definimos oJsonDataLoader que será responsável por analisar o JSON.

Na etapa final, definimos o tipo de conteúdo apropriado para o formato .docx e executamos o relatório. Isso conectará os dados JSON e os inserirá no modelo que gera o resultado no fluxo de saída da resposta.

Agora podemos acessar a URL/generate/doc para baixar o documento e veremos o seguinte resultado em nosso .docx gerado:

image

4. Conclusão

Neste artigo, mostramos como podemos integrar facilmente o YARG ao Spring e usar sua poderosa API para criar documentos de uma maneira simples.

Usamos JSON como entrada de dados, mas Groovy e SQL também são suportados.

Se você quiser aprender mais sobre isso, você pode encontrar a documentaçãohere.

E como sempre, você pode encontrar o exemplo completoover on GitHub.

Related