Transformando Dados: Um Tutorial Prático com XSLT e o Framework Saxon para Simplificar a Manipulação de XML em Projetos Reais

Introdução

Neste tutorial, exploraremos como utilizar XSLT (Extensible Stylesheet Language Transformations) em conjunto com o framework Saxon para simplificar a manipulação de dados XML em projetos Java reais. Vamos abordar desde a configuração do ambiente até a criação de transformações XSLT eficazes, com exemplos claros e códigos prontos para uso. O XSLT é uma linguagem poderosa que permite transformar documentos XML em outros formatos, como HTML ou XML modificado, o que a torna essencial para desenvolvedores que precisam trabalhar com esse tipo de dado. Além disso, o Saxon é um processador XSLT robusto que oferece funcionalidades avançadas para facilitar essa tarefa. Este guia é ideal para aqueles que desejam entender melhor como transformar e manipular dados XML de forma eficiente e prática.

Etapas

Configuração do Ambiente de Desenvolvimento
Certifique-se de ter o JDK (Java Development Kit) instalado em sua máquina, pois o Saxon é uma biblioteca Java. Você pode verificar a instalação do JDK utilizando o comando `java -version`. Se não estiver instalado, faça o download do site oficial da Oracle ou utilize distribuições como OpenJDK.
commands
```
# Verificar versão do JDK
java -version
```
Criação de um Projeto Maven
Utilize o Maven para criar um novo projeto. Crie um diretório para o seu projeto e dentro dele execute o comando abaixo para criar o esqueleto do projeto.
commands
```
# Criar o projeto Maven
mvn archetype:generate -DgroupId=com.example -DartifactId=xslt-transform -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false
```

Adicionando a Dependência do Saxon

Adicione a dependência do Saxon no arquivo `pom.xml` do seu projeto. Essa biblioteca será utilizada para realizar as transformações 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</groupId>
  <artifactId>xslt-transform</artifactId>
  <version>1.0-SNAPSHOT</version>
  <properties>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
  </properties>
  <dependencies>
    <dependency>
      <groupId>net.sf.saxon</groupId>
      <artifactId>Saxon-HE</artifactId>
      <version>10.6</version>
    </dependency>
  </dependencies>
</project>

Criando um Arquivo XML de Exemplo

Crie um arquivo XML simples que será transformado usando XSLT. Salve-o na raiz do seu projeto com o nome `input.xml`.

input.xml

<?xml version="1.0" encoding="UTF-8"?>
<livros>
    <livro>
        <titulo>O Senhor dos Anéis</titulo>
        <autor>J.R.R. Tolkien</autor>
        <ano>1954</ano>
    </livro>
    <livro>
        <titulo>A Revolução dos Bichos</titulo>
        <autor>George Orwell</autor>
        <ano>1945</ano>
    </livro>
</livros>

Criando um Arquivo XSLT para Transformação

Crie um arquivo XSLT que definirá como o XML será transformado. Salve-o com o nome `transform.xsl` na raiz do projeto.

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 Livros</h2>
                <table border="1">
                    <tr bgcolor="#9acd32">
                        <th>Título</th>
                        <th>Autor</th>
                        <th>Ano</th>
                    </tr>
                    <xsl:for-each select="livros/livro">
                        <tr>
                            <td><xsl:value-of select="titulo"/></td>
                            <td><xsl:value-of select="autor"/></td>
                            <td><xsl:value-of select="ano"/></td>
                        </tr>
                    </xsl:for-each>
                </table>
            </body>
        </html>
    </xsl:template>
</xsl:stylesheet>

Implementando a Classe Java para a Transformação

Crie uma classe Java que utilizará o Saxon para aplicar a transformação XSLT ao arquivo XML. Salve essa classe como `Transformador.java` dentro do diretório `src/main/java/com/example/`.

Transformador.java

package com.example;

import net.sf.saxon.s9api.*;
import java.io.File;

public class Transformador {
    public static void main(String[] args) {
        try {
            Processor processor = new Processor(true);
            XsltCompiler compiler = processor.newXsltCompiler();
            XsltExecutable executable = compiler.compile(new StreamSource(new File("transform.xsl")));
            XsltTransformer transformer = executable.load();

            transformer.setSource(new StreamSource(new File("input.xml"));
            serializer.setOutputStream(System.out);
            transformer.transform();
        } catch (SaxonApiException e) {
            e.printStackTrace();
        }
    }
}

Compilando e Executando a Transformação
Compile e execute a aplicação para ver a transformação em ação. Utilize o comando abaixo para compilar o projeto e executar a classe transformadora.
commands
```
# Compilar o projeto
mvn clean install
# Executar a classe Transformador
java -cp target/xslt-transform-1.0-SNAPSHOT.jar com.example.Transformador
```

Verificando a Saída

Após executar a transformação, verifique a saída no console. Você deve ver uma tabela HTML que lista os livros contidos no arquivo XML, com título, autor e ano.

output_example

<html>
<body>
<h2>Lista de Livros</h2>
<table border="1">
<tr bgcolor="#9acd32">
<th>Título</th>
<th>Autor</th>
<th>Ano</th>
</tr>
<tr>
<td>O Senhor dos Anéis</td>
<td>J.R.R. Tolkien</td>
<td>1954</td>
</tr>
<tr>
<td>A Revolução dos Bichos</td>
<td>George Orwell</td>
<td>1945</td>
</tr>
</table>
</body>
</html>

Criando Testes Unitários

Implemente testes unitários para garantir que as transformações estejam funcionando conforme o esperado. Use o framework JUnit para criar uma classe de teste chamada `TransformadorTest.java`.

TransformadorTest.java

package com.example;

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

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

public class TransformadorTest {
    @Test
    public void testTransformacao() {
        // Simular chamada ao processamento e verificar a saída
        // Implementação do teste irá depender das necessidades específicas
    }
}

Conclusão

Ao final deste tutorial, você aprendeu como manipular dados XML utilizando XSLT e o framework Saxon em um projeto Java. Nós cobrimos desde a configuração do ambiente até a implementação de transformações e testes unitários, proporcionando uma compreensão prática de como transformar dados XML de forma eficiente. Este conhecimento é valioso em diversos cenários de desenvolvimento, e agora você pode aplicar essas técnicas em seus próprios projetos, facilitando a integração e manipulação de dados.

Hashtags

#XSLT #Saxon #Java #TransformacaoDeDados #XML #DesenvolvimentoDeSoftware

copycoda.com.br