Guia de Consulta Rápida
Java e XML Processamento de documentos XML com Java 2a edição
Renê Rodrigues Veloso
Novatec
Copyright 2007 da Novatec Editora Ltda.
Todos os direitos reservados e protegidos pela Lei 9.610 de 19/02/1998. É proibida a reprodução desta obra, mesmo parcial, por qualquer processo, sem prévia autorização, por escrito, do autor e da Editora. Editor: Rubens Prates
ISBN: 978-85-7522-111-2 Primeira impressão: Abril/2003 (ISBN: 85-7522-036-5) Segunda edição: Julho/2007 (ISBN: 978-85-7522-111-2)
Novatec Editora Ltda.
Rua Luís Antônio dos Santos 110 02460-000 São Paulo SP – Brasil Tel.: +55 11 6959-6529 Fax: +55 11 6950-8869 E-mail: novatec@novatec.com.br Site: www.novatec.com.br
Sumário
Introdução..............................................................................5 Por que utilizar Java?.........................................................5 O que é XML?...................................................................5 Analisando documentos XML.................................................7 Parsers XML.....................................................................8 Processadores XML...........................................................9 Diferenças entre parser e processador XML....................... 10 Diferenças entre SAX e DOM........................................... 10 Trabalhando com JAXP..........................................................11 As APIs JAXP.................................................................. 12 Parser DOM.................................................................... 13 Parser SAX...................................................................... 16 Validando com Schema em JAXP..................................... 22 Trabalhando com Xerces........................................................ 25 Instalação....................................................................... 25 Parser DOM.................................................................... 25 Parser SAX......................................................................26 Manipulando Namespaces...............................................26 Validação DTD...............................................................26 Validação Schema............................................................26 Tratando erros......................................................................26 A Interface ErrorHandler................................................. 27 Utilizando o tratador de erros criado...............................28 Removendo espaços em branco..............................................28 Removendo espaços em branco com JAXP.......................29 Removendo espaços em branco com Xerces......................29 API DOM.............................................................................30 Módulos de DOM...........................................................30 Hierarquia de Classes/Interfaces...................................... 32 Interface Node................................................................ 33 Interface NodeList...........................................................38 Interface Element............................................................ 39 Interface NamedNodeMap.............................................. 41 Interface Attr...................................................................42 Interface Document.........................................................42 Interface CharacterData...................................................44 Interface Text . ................................................................ 45 Interface DocumentType . ...............................................46 Interface Entity............................................................... 47 Interface Notation........................................................... 47 Interface ProcessingInstruction ....................................... 47 Interface DOMImplementation........................................48 Classe DOMException....................................................48 Módulo DOM Traversal........................................................50 Interface NodeIterator......................................................51 Interface fábrica DocumentTraversal................................ 52 Interface NodeFilter.........................................................54 Interface TreeWalker........................................................56 Gerando documentos XML...................................................58 Criando uma árvore DOM..............................................58 Criando um objeto Document.........................................58 Criando e adicionando nós-filho......................................58
Sumário
Serialização...........................................................................60 Serializando com JAXP....................................................60 Serializando com Xerces..................................................64 Classe OutputFormat......................................................64 XPath e XSLT........................................................................68 XPath.............................................................................68 Funções de processamento XPath..................................... 73 XPath em Java.................................................................77 XSLT............................................................................... 81 Exemplos práticos.................................................................84 Trabalhando com DOM4J.....................................................90 Instalação.......................................................................90 Parsing XML...................................................................90 Criando um Novo Documento XML................................ 91 Percorrendo o documento XML....................................... 93 Navegação com Xpath..................................................... 93 Convertendo de String para Árvore DOM4J.....................94 Principais Interfaces do Pacote org.dom4j.........................95 Serialização de Objetos em XML......................................... 100 Serializando com XStream............................................. 100 Serializando com XMLEncoder/XMLDecoder................ 102 Informações adicionais (links)............................................. 104 Sobre o autor................................................................ 105 Índice remissivo.................................................................. 106
Introdução
Introdução Por que utilizar Java? A frase “escreva um e rode em qualquer lugar” é um bom motivo para começar a pensar em Java como sendo a plataforma de desenvolvimento de aplicações poderosas, seguras e que funcionam em qualquer ambiente computacional. Java é uma linguagem popular e de recursos fantásticos; com ela é possível fazer quase tudo o que se queira, é ideal para a implementação de aplicativos baseados em Intranet e Internet e em qualquer outro software para dispositivos que se comunicam em uma rede (como telefones celulares, pagers e PDAs – Personal Digital Assistants), e possui recursos importantes como manipulação de strings, imagens gráficas, componentes de interface gráfica com o usuário, tratamento de exceções, multitarefa, multimídia (áudio, imagens, animação e vídeo), processamento de arquivos, processamento de banco de dados, computação distribuída e estruturas de dados pré-empacotadas. Os recursos de Java são exatamente o que as empresas e organizações estão procurando para atender aos requisitos de processamento de informações atuais. A linguagem Java foi desenvolvida pela Sun Microsystems e está disponível gratuitamente na Internet no site da Sun:. http://java.sun.com.
O que é XML? A XML (Extensible Markup Language, ou Linguagem de Marcação Extensível, com extensível significando expansível), é uma metalinguagem de marcação definida pelo W3C (World Wide Web Consortium) em www.w3.org, que lhe permite criar a sua própria linguagem (baseada em marcações – tags) e seguindo as regras que você definir em um determinado contexto. O W3C não é um órgão de padronização como a ISO, mas de recomendações. Isso significa que ele indica o que é melhor, e não o que deverá, necessariamente, ser utilizado. Por exemplo, a recomendação XML 1.1.
Interoperabilidade É muito comum encontrarmos, principalmente em ambientes empresariais,grandes redes de comunicação de dados interligando aplicativos distribuídos entre máquinas com arquiteturas e sistemas operacionais diferentes. E para que isso aconteça, é necessário que as aplicações sejam capazes de conversar entre si, ou melhor, é fundamental que haja interoperabilidade entre elas. Para que ocorra interoperabilidade, também é preciso que as aplicações aceitem uma especificação comum de protocolos e formato de dados e que sejam, o máximo possível, baseadas
Introdução
em padrões abertos. A Internet é um bom exemplo de ambiente facilitador de interoperabilidade, e padronização é uma palavra importante na grande rede, pois nela devemos garantir que a informação transmitida será entendida pelo receptor, como os diversos browsers e aplicações clientes existentes. Uma das principais vantagens da XML é justamente promover a interoperabilidade ou a troca dos dados de maneira simples, barata e rápida entre os diversos tipos de computadores e sistemas. E isso se dá porque um arquivo XML é baseado em formato texto, contribuindo até mesmo para a leitura e maior entendimento.
Organização e personalização XML representa os dados de maneira hierárquica e organizada. Essa representação é feita por meio de uma árvore que trata cada elemento como sendo um nó, facilitando o entendimento e a busca de informações. Uma outra função de XML é a capacidade de separar o conteúdo da apresentação; preocupa-se com “o que mostrar”, enquanto HTML se preocupa em “como mostrar” a informação. Veja a tag <p>, por exemplo; em HTML, essa tag significa o início de um parágrafo, já em XML, essa mesma tag poderia representar um preço, um parâmetro, uma pessoa etc., dependendo do contexto em que se encontra. Existem várias linguagens de marcação que foram criadas a partir de XML e que se tornaram recomendações do W3C, como a MathML (Mathematical Markup Language) em. www.w3.org/Math, que fornece uma maneira padrão de descrever equações, símbolos e expressões matemáticas, e a CML (Chemical Markup Language) em www.xml-cml.org, que descreve informações moleculares, gerencia problemas de equações químicas e ajuda os químicos a manipular átomos e moléculas como tags.
Autodescrição dos dados Os dados em um documento XML são autodescritíveis, já que as tags informam o tipo de informação que está por vir. Por exemplo, em um documento XML, como o mostrado a seguir:
livro.xml <?xml version=”1.0” encoding=”UTF-8”?> <LIVRO> <TITULO> Java e XML </TITULO> <ASSUNTO> Processamento de documentos XML com Java </ASSUNTO> </LIVRO>
Introdução
Tomando como base somente os nomes das tags ou elementos XML, podemos descobrir de que se trata o documento apresentado. Neste caso, o documento livro.xml descreve informações sobre um livro cujo título é “Java e XML” e o assunto é “Processamento de documentos XML com Java”.
Documentos bem formados Um bom documento XML precisa ser bem formado, ou seja, deve seguir as regras de sintaxe estabelecidas para a XML pelo W3C na especificação XML 1.1. O documento XML precisa conter um ou mais elementos (tags); deve haver somente um elemento raiz, que deve conter todos os demais elementos. Cada elemento deve estar aninhado corretamente dentro de outro elemento. Cada elemento deve ter a sua tag de fechamento correspondente. Diferentemente do HTML que pode ter tags abertas, embaralhadas e sem raiz, o documento XML deve ser sintaticamente correto.
Documentos válidos Um documento XML é dito válido se houver uma definição de tipo de documento (DTD) ou Schema associado a ele. DTD/Schema dita as regras que o documento deve seguir, quais são seus elementos, os seus nomes e que tipo de dados suporta. Veja um exemplo de DTD para o documento livro.xml mostrado anteriormente: <!ELEMENT LIVRO (TITULO, ASSUNTO)> <!ELEMENT TITULO (#PCDATA)> <!ELEMENT ASSUNTO (#PCDATA)>
O arquivo com esse texto pode ser chamado de livro.dtd.
Observação Um documento bem formado nem sempre é válido, mas um documento válido é sempre bem formado.
Analisando documentos XML Para trabalhar com documentos no formato XML, de maneira que se tenha acesso a todos os elementos que constituem o documento, precisamos ter em mãos algumas ferramentas que nos permitirão realizar a parsing ou análise dos dados. Essas ferramentas são as chamadas APIs (Application Programming Interface), disponíveis para Java, com as quais construíremos os parsers e processadores XML.
Analisando documentos XML
Parsing É o processo de leitura e divisão do documento em elementos, atributos, entidades, comentários e outros tipos de dados, por meio do qual poderão ser analisados e validados.
Parsers XML O parser é uma biblioteca de software (uma classe em Java) que lê o documento XML e verifica se ele é bem formado e válido.
Validante e não-validante Os parsers XML são categorizados como validantes e nãovalidantes: • Validante: Um parser validante deve checar as restrições de validação e boa formação do documento de acordo com o DTD/Schema associado. • Não-validante: Quando lemos um documento XML, um parser não-validante checa a sua boa formação de acordo com a especificação XML1.1 e informa quaisquer violações ou erros quanto à estrutura do documento. Java 1.4 foi a primeira versão de Java a incluir um parser XML. Em outras versões, é necessário fazer o download do parser na web e instalá-lo normalmente como qualquer outra biblioteca Java, bastando adicioná-lo ao seu CLASSPATH. Mesmo em Java 1.4 é possível substituir o parser-padrão por um diferente que contenha uma característica adicional, mais simples ou mais rápida em seus documentos.
Parsers disponíveis Existem vários tipos de analisadores ou parsers XML, todos com características e implementações distintas, podendo ser encontrados disponíveis para download na internet ou comercializados. A seguir serão citados os mais comuns.
Ælfred O Ælfred (http://www.microstar.com/aelfred.html) é um pequeno e rápido parser especialmente desenvolvido para o uso em applets Java. Foi projetado para programadores Java que querem processar XML em seus applets e outras aplicações sem aumentar excessivamente o tamanho do projeto. Alfred consiste em somente duas classes, com um total de 26K de tamanho, e necessita de pouca memória para executar. Suporta a API SAX.
Analisando documentos XML
Crimson Antes conhecido como “Projeto Java X” (http://xml.apache. org/crimson/), é o parser que a Sun empacota com o JDK 1.4. Crimson suporta mais ou menos as mesmas APIs e especificações que a Xerces – SAX2, DOM2, JAXP, XML 1.0, Namespaces em XML e schema.
Oracle XML Parser Encontrado em http://technet.oracle.com/tech/xml/. É um parser que permite a análise de documentos XML por meio das APIs SAX ou DOM, usando os modos validante ou não-validante.
Piccolo Piccolo de Yuval Oren é um parser pequeno, rápido e nãovalidante. No entanto, faz a leitura de DTDs externas e as aplica ao documento ajustanto valores de atributos e resolvendo referências a entidades externas. Suporta exclusivamente a API SAX. Não possui implementação DOM. Mais informações podem ser obtidas em http://piccolo.sourceforge.net/.
Xerces Um dos melhores e mais completos parsers disponíveis atualmente é Xerces-J do Projeto XML Apache, disponível em http://xerces.apache.org/. Atualmente, na versão 2.x, possui a melhor adaptação à especificação XML 1.1. Fornece suporte completo às APIs SAX2 e DOM Level 3, e até JAXP. Xerces-J é altamente configurável e adaptável para quase tudo de que um parser necessita. Xerces-J também suporta W3C XML Schema Language e Namespaces.
XP Encontrado em http://www.jclark.com/xml/xp/index.html. XP é um parser que suporta a especificação 1.0 da XML. É capaz de detectar documentos bem formados, no entanto, atualmente, é um parser não-validante. Suporta a API SAX.
Processadores XML Basicamente um processador XML é um módulo de software que faz a leitura de documentos XML e fornece os aplicativos necessários para acessar o conteúdo e a estrutura desses documentos. A especificação XML 1.0 do W3C (http://www. w3.org) define precisamente as funções de um processador XML. Um processador XML (Figura 1) funciona como uma ponte entre um documento XML e uma aplicação, podendo, além de analisar, também gerar documentos XML. A aplicação utiliza uma API para acessar objetos que representam parte do documento XML.
10
Analisando documentos XML Documento XML
Processador XML
Árvore DOM
Eventos SAX
Aplicação Análise Geração Acesso com DOM e SAX
Figura 1 – Processador XML.
Diferenças entre parser e processador XML Um parser XML tem a função de fazer a análise do conteúdo de um documento XML e verificar se esse documento é bem formado e válido. Já um processador XML, além de fazer a parsing ou a análise dos dados, pode navegar por entre os nós da árvore XML, acessar todos os elementos e campos, como também gerar documentos em formato XML e quaisquer outros formatos.
Diferenças entre SAX e DOM O objetivo das APIs SAX e DOM é tornar a interpretação XML fácil e satisfatória para programas de computador. Para fazer essa interpretação, existem duas técnicas conhecidas como Simple API for XML (SAX) e Document Object Model (DOM), baseadas em abstrações dos conjuntos de informação de um documento XML (Figura 2). Essas técnicas projetam esses conjuntos e informações em um modelo de objetos que permite aos programadores manipulá-los.
SAX SAX (Simple API for XML) é um conjunto de interfaces que decompõe um documento XML em uma sucessão linear de chamadas de métodos.
DOM DOM (Document Object Model) é um conjunto de interfaces que decompõe um documento XML em uma árvore transversal hierárquica de nós/objetos.
11
Analisando documentos XML <?xml version="1.0" encoding="UTF-8"?> <livro> <nome>Java e XML</nome> <editora>Novatec</editora> </livro> PARSING
livro nome
editora
Java e XML Novatec
startElement: livro startElement: nome characters: Java e XML endElement: nome startElement: editora characters: Novatec endElement: editora endElement: livro
Figura 2 – Diferenças entre DOM e SAX, respectivamente.
Comparando DOM e SAX • DOM é uma solução natural para lidar com dados que são mais bem descritos como uma árvore. • Para trabalhar principalmente com dados estruturados ou gerados pelo computador, SAX pode ser mais conveniente. • SAX possui métodos e estruturas de dados mais simples do que os de DOM, podendo muitas vezes alcançar alta performance. • DOM agiliza a pesquisa por elementos, bastando apenas indicar o caminho de nós na árvore (por exemplo, com expressões XPath). • SAX utiliza menos memória que DOM, pois não precisa manipular uma estrutura de dados complexa, como uma árvore em memória.
Trabalhando com JAXP Nas versões mais recentes de J2SE e J2EE, é incluído um conjunto-padrão de APIs para XML, conhecido como JAXP (Java APIs for XML Processing). Essas APIs também estão disponíveis separadamente, em um pacote de bibliotecas Java chamado JAX Pack (Java XML Pack), no site da Sun (http://java.sun.com), contendo várias outras APIs relacionadas a XML e Web Services. JAXP suporta os analisadores-padrão SAX (Simple API for XML Parsing) e DOM (Document Object Model), assim como o padrão XSLT (XML Stylesheet Language Transformation), dando maior controle sobre a apresentação dos dados e capacitando a conversão dos dados para outro documento XML ou para outros formatos, como HTML. JAXP também trabalha com DTD/Schema e suporta namespaces.
12
Trabalhando com JAXP
As APIs JAXP As principais APIs JAXP são definidas no pacote javax.xml.parsers. Esse pacote contém duas fábricas de classes: SAXParserFactory e DocumentBuilderFactory, que fornecem instâncias para um objeto SAXParser e um objeto DocumentBuilder, respectivamente. A vantagem é que essas fábricas de classes, SAXParserFactory e DocumentBuilderFactory, permitem utilizar uma implementação XML oferecida por outros fornecedores sem a necessidade de mudar o código.
Uma visão geral dos pacotes As APIs SAX e DOM são definidas pelo grupo XML-DEV e pelo W3C, respectivamente. As bibliotecas que definem essas APIs são:
Pacotes DOM Pacote
Descrição
org.w3c.dom
Define a interface de programação DOM para documentos XML (especificação W3C). Define a classe-fábrica DocumentBuilderFactory e a classe DocumentBuilder, que constroem um objeto implementando a interface Document do W3C. A fábrica utilizada para criar o construtor é determinada pelas propriedades do pacote javax.xml.parsers, que podem ser ajustadas por um comando de linha ou ativadas quando se invocar o método new Instance. Esse pacote também define a classe ParserConfigurationException para informar erros.
javax.xml.parsers
Pacotes SAX Pacote org.xml.sax
Descrição
Define as interfaces SAX. O nome org.xml é o prefixo do pacote que foi estabelecido pelo grupo que definiu a API SAX. org.xml.sax.ext Define as extensões SAX que são utilizadas em um processamento SAX mais sofisticado, por exemplo, para processar um DTD ou para ver a sintaxe detalhada de um arquivo. org.xml.sax.helpers Contém classes auxiliares que facilitam a utilização de SAX. Javax.xml.parsers Define a classe SAXParserFactory que retorna o SAXParser.Também define classes de exceções para informar erros.
13
Trabalhando com JAXP
Pacotes XSLT Pacote
Descrição
javax.xml.transform
Define as classes TransformerFactory e Transformer , que são utilizadas para obter um objeto capaz de fazer transformações em um documento XML seguindo as regras contidas em uma folha de estilo. Depois de criar um objeto transformer, é invocado o método transform(), fornecendo uma entrada (source) e uma saída (output). javax.xml.transform.dom Classes para criar objetos de entrada (input) e saída (result) de um DOM. javax.xml.transform.sax Classes para criar a entrada (input) de um parser SAX e objetos de saída (output) de um manipulador de eventos SAX. javax.xml.transform.stream Classes para criar objetos de entrada (input) e saída (output) de uma stream de I/O.
Parser DOM O Document Object Model (DOM) é uma interface de programação especificada pelo W3C para o tratamento e manipulação de dados em documentos XML. DOM sugere um meio de abordar documentos XML como sendo uma árvore de nós, e essa é a maneira mais correta, visto que o documento XML organiza-se também em forma de árvore. A Figura 3 apresenta o processo de construção e funcionamento de um parser DOM JAXP. Para mais informações sobre DOM, visite o site www.w3.org. DocumentBuilder Factory
DocumentBuilder
Dados XML
Objeto Document Árvore DOM
Figura 3 – Construção e funcionamento de um parser DOM JAXP.
14
Trabalhando com JAXP
DocumentBuilder e DocumentBuilderFactory Para construir um parser DOM em JAXP, é necessário utilizar as classes javax.xml.parsers.DocumentBuilderFactory e javax.xml.parsers. DocumentBuilder e configurá-las corretamente. import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.parsers.DocumentBuilder; import org.w3c.dom.Document; String nome_arquivo; ... DocumentBuilderFactory factory = DocumentBuilderFactory. newInstance(); DocumentBuilder builder = factory.newDocumentBuilder(); Document doc = builder.parse(nome_arquivo);
É necessário seguir alguns passos para obter um parser DOM JAXP: 1. Utilize o método-fábrica estático DocumentBuilderFactory. n e w I n s t a n c e ( ) p a r a r e to r n a r u m o b j e to DocumentBuilderFactory. 2. Utilize o método newDocumentBuilder() do objeto DocumentBuilderFactory para retornar uma instância da classe DocumentBuilder. 3. Utilize um dos cinco métodos parse() de DocumentBuilder para ler o documento XML e retornar um objeto org. w3c.dom.Document. 4. Lembre-se de colocar tudo em um bloco try-catch para tratar possíveis exceções.
Exemplo completo import javax.xml.parsers.*; import org.w3c.dom.Document; import java.io.*; public class ParserExemplo { public static void main(String args[]) { String nomeArquivo = “”;
if(args.length > 0) nomeArquivo = args[0]; else { System.out.println(“Use: ParserExemplo seu_arquivo_XML”); System.exit(0); } try{ DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newDocumentBuilder(); Document doc = builder.parse(nomeArquivo); } catch(Exception e){e.printStackTrace();} } }
15
Trabalhando com JAXP Métodos parse()
public Document parse(InputSource fonte) throws SAXException, IOException public Document parse(String uri) throws SAXException, IOException public Document parse(File arquivo) throws SAXException, IOException public Document parse(InputStream entrada) throws SAXException, IOException public Document parse(InputStream entrada,String systemID) throws SAXException,IOException
Configurando DocumentBuilderFactory A classe DocumentBuilderFactory possui métodos de ajuste set...(), que permitem determinar exatamente como o parser criado deve se comportar.
Ignorando comentários public boolean isIgnoringComments(); public void setIgnoringComments(boolean ignora);
Esses métodos determinam se o parser produzido por esse factory irá gerar nós de comentários que serão vistos na entrada do documento. O valor default, false, significa que os nóscomentário serão produzidos.
Ignorando espaços em branco public boolean isIgnoringElementContentWhitespace(); public void setIgnoringElementContentWhitespace(boolean ignorarWS);
Esses métodos determinam se o parser irá gerar nós-texto para os chamados “espaços em branco ignoráveis”, isto é, espaço em branco que ocorre entre os elementos onde o DTD especifica que os caracteres de dados analisados não podem aparecer. O valor default (padrão) é false, isto é, inclui nós-texto para espaços em branco ignoráveis. Para que essa propriedade seja aplicada, ou seja, para que se possa atribuir true ao argumento ignoraWS, o documento deve ter um DTD associado a ele e deve ser válido. De outra forma, o parser não pode saber qual espaço em branco é ignorável e qual não é.
Reconhecendo Namespaces public boolean isNamespaceAware(); public void setNamespaceAware(boolean namespaceAware);
Esses métodos determinam se o parser produzido é namespace aware, ou seja, se reconhece namespaces. Essa característica irá ajustar as propriedades de prefixo e URI namespace dos nós-elemento e atributos. O valor default (padrão) é sempre para true. Por exemplo:
false,
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); factory.setNamespaceAware(true);
mas deve ser ajustado