Introdução

Neste tutorial, você verá como integrar XSLT com ferramentas modernas como Saxon e Oxygen XML para automatizar fluxos de trabalho com dados XML. XSLT é uma linguagem poderosa para transformar documentos XML em diferentes formatos, enquanto Saxon é uma implementação de XSLT e XPath que fornece um processamento eficiente. Oxygen XML é uma robusta plataforma para edição de XML que também suporta XSLT. Juntos, esses componentes podem criar soluções eficientes para transformar e manipular dados XML, facilitando a automação de processos em projetos de software. Abordaremos um exemplo prático que envolve a criação de um microserviço em Java usando Spring Boot para realizar transformações de dados XML, configurando o ambiente de desenvolvimento, implementando as transformações com Saxon e testando a aplicação com ferramentas modernas. Este guia é ideal para desenvolvedores que desejam potencializar sua produtividade ao lidar com XML.

Etapas

  1. Configuração do Ambiente de Desenvolvimento

    Certifique-se de ter o JDK (Java Development Kit) instalado e o Maven configurado em sua máquina. Você pode baixar o JDK em www.oracle.com/java/technologies/javase-jdk11-downloads.html e o Maven em maven.apache.org/download.cgi. Após a instalação, verifique se estão corretamente configurados usando os comandos ‘java -version’ e ‘mvn -version’ no terminal.

    commands
    # Verifique as versões instaladas
    java -version
    mvn -version

  2. Criação do Projeto Spring Boot

    Utilize o Spring Initializr (start.spring.io) para gerar um novo projeto Spring Boot. Configure o projeto com as opções: **Project**: Maven, **Language**: Java, **Spring Boot**: última versão estável, **Packaging**: Jar, **Java**: 11 ou superior. Adicione as dependências ‘Spring Web’, ‘Spring Boot DevTools’, e ‘JUnit’. Baixe e descompacte o projeto.

    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>Exemplo de integração de XSLT com Spring Boot</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-devtools</artifactId>
      <scope>runtime</scope>
      <optional>true</optional>
    </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>10.6</version>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

  3. Criação do Serviço de Transformação XML

    Crie uma nova classe chamada XmlTransformationService que será responsável por realizar a transformação dos dados usando XSLT. Nela, utilizaremos a biblioteca Saxon para processar o XSLT e fazer a transformação do arquivo XML que você fornecer.

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

import net.sf.saxon.s9api.*;
import org.springframework.stereotype.Service;

import java.io.StringReader;
import java.io.StringWriter;

@Service
public class XmlTransformationService {
    private final Processor processor;

    public XmlTransformationService() throws SaxonApiException {
        this.processor = new Processor(false);
    }

    public String transformXml(String xmlInput, String xsltInput) throws SaxonApiException {
        XsltCompiler compiler = processor.newXsltCompiler();
        XsltExecutable executable = compiler.compile(new StringSource(xsltInput));

        Serializer out = processor.newSerializer();
        StringWriter outputWriter = new StringWriter();
        out.setOutputWriter(outputWriter);

        XsltTransformer transformer = executable.load();
        transformer.setSource(new StringSource(xmlInput));
        transformer.setDestination(out);
        transformer.transform();

        return outputWriter.toString();
    }
}

  4. Criação do Controlador de API

    Implemente um controlador REST chamado XmlTransformationController que irá expor um endpoint para receber arquivos XML e XSLT, processá-los e retornar os resultados da transformação.

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

import com.example.xsltintegration.service.XmlTransformationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/transform")
public class XmlTransformationController {
    @Autowired
    private XmlTransformationService transformationService;

    @PostMapping
    public ResponseEntity<String> transform(@RequestParam String xml, @RequestParam String xslt) {
        try {
            String result = transformationService.transformXml(xml, xslt);
            return ResponseEntity.ok(result);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(e.getMessage());
        }
    }
}

  5. Implementação de Testes Unitários

    Crie a classe de testes XmlTransformationServiceTest para validar a transformação de XML usando XSLT. Utilize JUnit e Mockito para criar os testes unitários e garantir que as transformações estão ocorrendo como esperado.

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

import net.sf.saxon.s9api.*;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.mockito.MockitoAnnotations;

import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;

public class XmlTransformationServiceTest {
    private XmlTransformationService transformationService;

    @BeforeEach
    public void setUp() throws SaxonApiException {
        MockitoAnnotations.openMocks(this);
        transformationService = new XmlTransformationService();
    }

    @Test
    public void testTransformXml() throws SaxonApiException {
        String xmlInput = "<note><to>Tove</to><from>Jani</from><heading>Reminder</heading><body>Don't forget me this weekend!</body></note>";
        String xsltInput = "<xsl:stylesheet version='1.0' /*XSLT content here*/></xsl:stylesheet>";

        String result = transformationService.transformXml(xmlInput, xsltInput);
        assertNotNull(result);
        // Adicione mais assertivas para validar o resultado esperado
    }
}

  6. Executando a Aplicação e Testes

    Utilize o Maven para compilar e executar a aplicação. Em seguida, utilize ferramentas como Postman ou cURL para testar o endpoint criado, enviando os dados XML e XSLT adequados.

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

    curl_examples
    # Testando a transformação XML com cURL
    curl -X POST -H "Content-Type: application/json" -d '{"xml":"<detalhes>","xslt":"<xsl:stylesheet>...</xsl:stylesheet>"}' http://localhost:8080/api/transform

Conclusão

Neste tutorial, você aprendeu a integrar o XSLT com o serviço Saxon em um projeto Spring Boot. A partir da configuração do ambiente, passando pela criação de um endpoint que recebe documentos XML e XSLT, até a implementação de testes unitários, você viu como automatizar eficientemente transformações de dados. Essa abordagem não apenas facilita o manuseio de dados XML de maneira programática, mas também melhora a produtividade e a escalabilidade de suas aplicações. Agora você pode aplicar essas habilidades em projetos reais e explorar ainda mais as funcionalidades que o XSLT e o Saxon oferecem.

Hashtags

#XML #XSLT #Saxon #SpringBoot #Automation #SoftwareDevelopment