Usando JAXB para ler e escrever documentos XML

JAXB é a sigla para Java Architecture for XML Binding, e permite os desenvolvedores mapearem um documento XML para classes Java, e vice-versa. Desde o Java 1.6 (Java SE 6.0) essa biblioteca já faz parte da especificação e implementação de referência. Neste artigo vamos gerar um XML a partir de um código Java, que lê um XSD (XML Schema Definition). Em seguida vamos utilizar outro código para ler um arquivo XML em um objeto Java. 

Escrevendo um arquivo XML

Utilizando o Eclipse, criamos um projeto Java simples. Coloque nele um arquivo .xsd simples, que descreverá um formato de XML desejado. O arquivo .xsd é o seguinte:

<?xml version="1.0" encoding="UTF-8" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:element name="venda">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="vendedor" type="xs:string"/>
      <xs:element name="comprador">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="nome" type="xs:string"/>
            <xs:element name="logradouro" type="xs:string"/>
            <xs:element name="cidade" type="xs:string"/>
            <xs:element name="pais" type="xs:string"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>
      <xs:element name="item">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="titulo" type="xs:string"/>
            <xs:element name="nota" type="xs:string" minOccurs="0"/>
            <xs:element name="quantidade" type="xs:positiveInteger"/>
            <xs:element name="preco" type="xs:decimal"/>
          </xs:sequence>
        </xs:complexType>
      </xs:element>
    </xs:sequence>
    <xs:attribute name="numOrdem" type="xs:string" use="required"/>
  </xs:complexType>
</xs:element>

</xs:schema>

Este XSD descreve os atributos de um arquivo XML relacionado com um objeto venda, que possui um comprador, um vendedor, um item e um número de ordem. O projeto no Eclipse vai ficar assim:



O Eclipse possui uma funcionalidade de gerar as classes JAXB automaticamente. Para isso clique com o botão direito no arquivo ordem.xsd -> Generate -> JAXB Classes... Em outras versões do Eclipse esta função está na opção "Source". Escolha um pacote destino, e serão criados dois arquivos:

- ObjectFactory.java
- Venda.java

Examine esses arquivos: o ObjectFactory é uma fábrica que possui os métodos para criar um objeto do tipo Venda, que é a representação do XML com todos os seus elementos. 

Vamos criar uma classe de teste chamada EscreveXML.java. O seu código será o seguinte: 

public static void main(String args[]) throws JAXBException {
ObjectFactory factory = new ObjectFactory();

Item item = factory.createVendaItem();
item.setTitulo("Pressurizador PSE01");
item.setPreco(new BigDecimal(105.50));
item.setQuantidade(BigInteger.ONE);
Comprador comprador = factory.createVendaComprador();
comprador.setCidade("Rio de Janeiro");
comprador.setLogradouro("Avenida Atlântica 10");
comprador.setNome("Maria Alves da Costa");
comprador.setPais("Brasil");
Venda venda = factory.createVenda();
venda.setComprador(comprador);
venda.setItem(item);
venda.setVendedor("Ramirez");
venda.setNumOrdem("00123456");
JAXBContext context = JAXBContext.newInstance(Venda.class);
Marshaller marshaller = context.createMarshaller();
marshaller.setProperty("jaxb.formatted.output",Boolean.TRUE);
marshaller.marshal(venda,System.out);
}

E o projeto ficará assim:




Ao executar este exemplo, ele irá criar um objeto Venda a partir da ObjectFactory, e em seguida chamaremos o JAXB para executar a operação de marshall, isto é, transformar um objeto Java em um XML. O resultado é jogado na console (System.out):

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<venda numOrdem="00123456">
    <vendedor>Ramirez</vendedor>
    <comprador>
        <nome>Maria Alves da Costa</nome>
        <logradouro>Avenida Atlântica 10</logradouro>
        <cidade>Rio de Janeiro</cidade>
        <pais>Brasil</pais>
    </comprador>
    <item>
        <titulo>Pressurizador PSE01</titulo>
        <quantidade>1</quantidade>
        <preco>105.5</preco>
    </item>
</venda>

Lendo um arquivo XML

Agora que temos um arquivo de XML gerado, vamos tentar executar a operação inversa, ou seja, ler este arquivo em um objeto Java.

O código a seguir instancia um Unmarshaller do JAXB a partir da ObjectFactory do exemplo anterior. A operação de unsmarshall é a que lê um arquivo XML em um objeto Java. O objeto já existe, é o Venda criado também no exemplo anterior. Colocamos o arquivo ordem.xml em um diretório qualquer, e lemos esse arquivo no exemplo.

public static void main(String args[]) throws JAXBException, FileNotFoundException {
JAXBContext jaxbContext = JAXBContext.newInstance(ObjectFactory.class);
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
InputStream stream = new FileInputStream(new File("C:\\temp\\ordem.xml"));
Venda venda = (Venda) unmarshaller.unmarshal(stream);
Item item = venda.getItem();
Comprador comprador = venda.getComprador();
System.out.println("Ordem: " + venda.numOrdem);
System.out.println("Vendedor: " + venda.vendedor);
System.out.println("Item: " + item.titulo);
System.out.println("Comprador: " + comprador.nome);
}

A saída será impressa na console, com os campos a seguir:

Ordem: 00123456
Vendedor: Ramirez
Item: Pressurizador PSE01
Comprador: Maria Alves da Costa

O projeto ficará da seguinte forma:

 

Conclusão

Neste artigo vimos como escrever arquivos XML a partir de um objeto Java, e também como ler um arquivo XML em um objeto Java. Para isso utilizamos a API do JAXB, que faz parte da especificação da JRE e deve ser a escolha natural do desenvolvedor.

Referências


Comments