Introdução

Neste tutorial, vamos explorar como utilizar XSLT (Extensible Stylesheet Language Transformations) para transformar dados XML de forma eficiente utilizando os frameworks Saxon e Xalan. A transformação de dados é uma habilidade crítica em muitos projetos de integração, e o XSLT é uma das ferramentas mais potentes para este tipo de tarefa. Neste guia, focaremos em um projeto que implementa essas transformações de maneira prática, utilizando Java e Spring Boot. Vamos abordar desde a configuração do ambiente até a execução de testes unitários, proporcionando uma compreensão completa do ciclo de desenvolvimento.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Certifique-se de ter o JDK (Java Development Kit) e o Maven instalados em sua máquina. Utilizaremos o Maven para gerenciamento de dependências em nosso projeto. Caso não tenha as ferramentas instaladas, você pode seguir as instruções nos sites oficiais.

    commands
    # Verificar versões instaladas
    java -version
    mvn -version

  2. Criação do Projeto Spring Boot

    Utilize o Spring Initializr para gerar um novo projeto Spring Boot com as dependências necessárias. Configure o projeto com as opções: Project: Maven, Language: Java, Spring Boot: última versão estável, Packaging: Jar, e Java: 11 ou superior. Adicione as dependências ‘Spring Web’ e ‘Spring Boot Starter Test’. Baixe e descompacte o projeto em seu ambiente.

    pom.xml
    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.example</groupId>
  <artifactId>xslt-integration</artifactId>
  <version>0.0.1-SNAPSHOT</version>
  <name>xslt-integration</name>
  <description>Projeto de Integração com XSLT</description>
  <properties>
    <java.version>11</java.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>net.sf.saxon</groupId>
      <artifactId>Saxon-HE</artifactId>
      <version>12.0</version>
    </dependency>
    <dependency>
      <groupId>xalan</groupId>
      <artifactId>xalan</artifactId>
      <version>2.7.2</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

  3. Adicionando Arquivo XML e XSLT

    Crie um diretório `src/main/resources` e adicione dois arquivos: `data.xml` contendo os dados que você deseja transformar e `transform.xsl` que contém a lógica XSLT para transformação dos dados XML.

    data.xml
    <?xml version="1.0" encoding="UTF-8"?>
<produtos>
    <produto>
        <id>1</id>
        <nome>Produto A</nome>
        <preco>10.0</preco>
    </produto>
    <produto>
        <id>2</id>
        <nome>Produto B</nome>
        <preco>20.0</preco>
    </produto>
</produtos>

    transform.xsl
    <?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:template match="/">
        <html>
            <body>
                <h2>Lista de Produtos</h2>
                <table border="1">
                    <tr>
                        <th>ID</th>
                        <th>Nome</th>
                        <th>Preço</th>
                    </tr>
                    <xsl:for-each select="produtos/produto">
                        <tr>
                            <td><xsl:value-of select="id" /></td>
                            <td><xsl:value-of select="nome" /></td>
                            <td><xsl:value-of select="preco" /></td>
                        </tr>
                    </xsl:for-each>
                </table>
            </body>
        </html>
    </xsl:template>
</xsl:stylesheet>

  4. Implementação do Serviço de Transformação

    Crie uma classe de serviço `XSLTService` que será responsável por realizar a transformação utilizando os frameworks Saxon e Xalan de acordo com a lógica definida no arquivo XSLT.

    XSLTService.java
    package com.example.xsltintegration.service;

import org.springframework.stereotype.Service;
import javax.xml.transform.*;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
import java.io.StringWriter;

@Service
public class XSLTService {
    public String transformXML(String xmlInput, String xsltFilePath) throws TransformerException {
        Source xmlSource = new StreamSource(new java.io.StringReader(xmlInput));
        Source xsltSource = new StreamSource(xsltFilePath);
        StringWriter stringWriter = new StringWriter();
        Result result = new StreamResult(stringWriter);

        TransformerFactory factory = TransformerFactory.newInstance();
        Transformer transformer = factory.newTransformer(xsltSource);
        transformer.transform(xmlSource, result);

        return stringWriter.toString();
    }
}

  5. Criação do Controlador para Expor a API

    Implemente um controlador `XSLTController` que expõe um endpoint para realizar a transformação de XML passando um arquivo XML de entrada e o estilo XSLT.

    XSLTController.java
    package com.example.xsltintegration.controller;

import com.example.xsltintegration.service.XSLTService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/transform")
public class XSLTController {
    @Autowired
    private XSLTService xsltService;

    @PostMapping
    public String transformXML(@RequestBody String xmlInput) {
        try {
            String xsltPath = "classpath:transform.xsl";
            return xsltService.transformXML(xmlInput, xsltPath);
        } catch (Exception e) {
            return "Erro na transformação: " + e.getMessage();
        }
    }
}

  6. Implementação de Testes Unitários

    Vamos criar testes unitários para o serviço de transformação para garantir que a lógica de transformação funcione corretamente.

    XSLTServiceTest.java
    package com.example.xsltintegration.service;

import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.MockitoAnnotations;
import javax.xml.transform.TransformerException;
import static org.junit.jupiter.api.Assertions.assertNotNull;
import static org.junit.jupiter.api.Assertions.fail;

public class XSLTServiceTest {
    @InjectMocks
    private XSLTService xsltService;

    public XSLTServiceTest() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    public void testTransformXML() {
        String xmlInput = "<produtos><produto><id>1</id><nome>Produto A</nome><preco>10.0</preco></produto></produtos>";
        try {
            String result = xsltService.transformXML(xmlInput, "src/main/resources/transform.xsl");
            assertNotNull(result);
        } catch (TransformerException e) {
            fail("Exceção na transformação: " + e.getMessage());
        }
    }
}

  7. Executando a Aplicação e Testes

    Use o Maven para compilar e executar a aplicação. Em seguida, utilize ferramentas como Postman ou cURL para testar o endpoint de transformação XML que você implementou.

    commands
    # Compilar e executar a aplicação
    mvn spring-boot:run
    # Executar os testes unitários
    mvn test

    curl_examples
    # Testar a transformação XML
    curl -X POST -H 'Content-Type: application/xml' -d '<produtos><produto><id>1</id><nome>Produto A</nome><preco>10.0</preco></produto></produtos>' http://localhost:8080/api/transform

Conclusão

Neste tutorial, abordamos como utilizar XSLT em conjunto com os frameworks Saxon e Xalan para realizar transformações de dados em projetos de integração utilizando Java e Spring Boot. Vimos desde a configuração do ambiente, a criação de arquivos XML e XSLT, até a implementação do serviço e a criação de testes unitários. Com este conhecimento, você está agora apto a aplicar transformações XML em seus próprios projetos, facilitando a integração e manipulação de dados.

Hashtags

#Java #SpringBoot #XSLT #Saxon #Xalan #IntegraçãoDeDados