Transformações Eficientes de XML: Explorando o Uso Prático do XSLT com o Framework Saxon e Integrações em Aplicações Web Modernas

Introdução

XML (Extensible Markup Language) é um formato amplamente utilizado para a troca de dados entre sistemas, mas muitas vezes os dados precisam ser transformados para atender a diferentes necessidades. O XSLT (Extensible Stylesheet Language Transformations) aparece como uma solução eficiente para transformar XML em outros formatos, como HTML, texto ou mesmo outro XML. Neste tutorial, vamos explorar como usar o XSLT junto com o framework Saxon para realizar transformações de XML em uma aplicação Java utilizando o Spring Boot. Iremos abordar o ambiente de desenvolvimento, configuração, implementações necessárias e a criação de testes automatizados para validar as transformações, garantindo que você tenha uma aplicação sólida e confiável.

Etapas

Configuração do Ambiente de Desenvolvimento
Certifique-se de ter o JDK (Java Development Kit) e o Maven instalados em sua máquina. Verifique as versões instaladas usando os comandos `java -version` e `mvn -version`. Além disso, crie um novo projeto Spring Boot usando o Spring Initializr com as dependências necessárias.
commands
```
# Verifique as versões do Java e Maven instaladas
java -version
mvn -version
# Criar um novo projeto com dependências necessárias
```

Criação do Projeto Spring Boot

Utilize o Spring Initializr para gerar um novo projeto Spring Boot. As opções devem ser: **Project**: Maven, **Language**: Java, **Spring Boot**: última versão, **Packaging**: Jar, **Java**: 11 ou superior. Adicione as dependências ‘Spring Web’ e ‘Xalan (para processamento XSLT)’.

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.xmltransform</groupId>
  <artifactId>xml-transform</artifactId>
  <version>1.0-SNAPSHOT</version>
  <name>xml-transform</name>
  <description>Transformações de XML com XSLT e Saxon</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.apache.xmlgraphics</groupId>
      <artifactId>batik-dom</artifactId>
      <version>1.16</version>
    </dependency>
    <dependency>
      <groupId>org.apache.xalan</groupId>
      <artifactId>xalan</artifactId>
      <version>2.7.2</version>
    </dependency>
    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-test</artifactId>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>
  </build>
</project>

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

Implemente uma classe de serviço chamada `XmlTransformationService` que usará o Saxon e XSLT para transformar XML através de um arquivo de estilo XSL.

XmlTransformationService.java

package com.example.xmltransform.service;

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

import java.io.StringReader;

@Service
public class XmlTransformationService {
    public String transformXml(String xmlInput, String xsltFile) throws SaxonApiException {
        Processor processor = new Processor(false);
        XsltCompiler compiler = processor.newXsltCompiler();
        XsltExecutable executable = compiler.compile(new InputSource(xsltFile));

        Serializer serializer = processor.newSerializer();
        StringOutputStream outputStream = new StringOutputStream();
        serializer.setOutputStream(outputStream);

        XsltTransformer transformer = executable.load();
        transformer.setSource(new StreamSource(new StringReader(xmlInput)));
        transformer.setDestination(serializer);
        transformer.transform();

        return outputStream.toString();
    }
}

Criação do Controlador de API

Crie um controlador REST chamado `XmlController` para expor um endpoint que aceita XML e um arquivo XSL, realizando a transformação e retornando o resultado.

XmlController.java

package com.example.xmltransform.controller;

import com.example.xmltransform.service.XmlTransformationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

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

    @PostMapping("/transform")
    public ResponseEntity<String> transformXml(@RequestParam("xml") MultipartFile xmlFile,
                                               @RequestParam("xslt") MultipartFile xsltFile) {
        try {
            String xmlInput = new String(xmlFile.getBytes());
            String xsltPath = new String(xsltFile.getBytes());
            String transformedXml = transformationService.transformXml(xmlInput, xsltPath);
            return ResponseEntity.ok(transformedXml);
        } catch (Exception e) {
            return ResponseEntity.badRequest().body(e.getMessage());
        }
    }
}

Criação do Teste do Serviço de Transformação

Implemente um teste unitário para o `XmlTransformationService` utilizando JUnit e Mockito, garantindo que a transformação funcione corretamente.

XmlTransformationServiceTest.java

package com.example.xmltransform.service;

import org.junit.jupiter.api.Test;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

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

public class XmlTransformationServiceTest {
    @InjectMocks
    private XmlTransformationService xmlTransformationService;

    @Mock
    private String xsltFile = "path/to/stylesheet.xsl";

    @BeforeEach
    public void init() {
        MockitoAnnotations.openMocks(this);
    }

    @Test
    public void testTransformXml() throws Exception {
        String xmlInput = "<root><test>Hello</test></root>";
        String result = xmlTransformationService.transformXml(xmlInput, xsltFile);
        assertNotNull(result);
        assertTrue(result.contains("ExpectedOutput"));
    }
}

Executando a Aplicação e Testes

Utilize o Maven para compilar e executar a aplicação. Em seguida, utilize o Postman ou cURL para testar o endpoint de transformação de XML.

commands

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

curl_examples

# Testar o endpoint de transformação de XML
curl -X POST -F 'xml=@test.xml' -F 'xslt=@stylesheet.xsl' http://localhost:8080/api/xml/transform

Conclusão

Neste tutorial, você aprendeu como utilizar o XSLT juntamente com o Saxon em uma aplicação Spring Boot para realizar transformações de XML de forma eficiente. Desde a configuração do ambiente até a implementação de serviços, controladores e testes unitários, cobrimos cada passo do processo. Agora você tem as habilidades necessárias para integrar a transformação de XML em suas aplicações web modernas, permitindo que seus sistemas suportem melhor a troca e a manipulação de dados.

Hashtags

#Java #SpringBoot #XSLT #Saxon #XML #DesenvolvimentoWeb

copycoda.com.br