Coltrane. JColtrane: Parser XML com SAX + Anotações. c o l u n a. Processe arquivos XML sem comprometer memória e a clareza do código

Transcrição

1 c o l u n a Made in Brazil Coltrane Better than SAX alone JColtrane: Parser XML com SAX + Anotações Processe arquivos XML sem comprometer memória e a clareza do código Renzo Nuccitelli (renzon@gmail.com): É graduado em Engenharia da Computação pelo ITA. Desenvolveu em seu TCC o tema Tratamento de Eventos em Java com Uso de Metadados, produzindo o framework JColtrane, premiado em 2º lugar no concurso search for a XML superstar promovido pela IBM e IDUG. Eduardo Guerra (guerraem@gmail.com) é desenvolvedor de frameworks, participando de projetos opensource como SwingBean, Esfinge Framework, ClassMock e JColtraine. Atualmente está cursando doutorado no ITA, onde também já concluiu graduação em Engenharia da Computação e mestrado. Possui as certificações SCJA, SCJP, SCWCD, SCBCD (1.3 e 5.0), SCJWSD, SCMAD e SCEA e experiência como arquiteto de software nas plataformas Java SE, Java EE e Java ME. Atua também como professor na graduação do ITA e nos cursos de pós-graduação ITA/Stefanini. A API SAX é muito utilizada para fazer processamento XML, porém sua utilização é muitas vezes difícil ou acarreta em códigos de difícil manutenção. Isto ocorre pois os métodos que tratam as tags no SAX são pouco granulares, criando a necessidade de criação de muitas expressões condicionais. Neste artigo será apresentado o framework Jcoltrane, que facilita o processamento de documentos XML com o uso de anotações, aumentando a granularidade das classes de processamento e evitando o grande aninhamento de blocos if/else. Também será visto como o framework fornece flexibilidade na definição do processamento, permitindo inclusive a criação de anotações personalizadas. Pesquisando por fóruns de Java pela internet, é comum observar que os programadores preferem utilizar o DOM (Domain Object abordagem se torna inviável, pois demanda um grande consumo de recursos, visto que todo o conteúdo do documento é armazenado em memória. Nesse momento, ao recorrer aos mesmos fóruns, é comum o programador receber precisa manter referência a todo o documento na memória. Ele percorre o documento em sua ordem natural, permitindo acesso a informações do elemento corrente, e apenas essas informações. Isso faz com que, muitas vezes, o usuário crie atributos em sua classe de processamento para guardar informações sobre elementos já percorridos e que em seus métodos necessite usar grandes aninhamentos de blocos if/else, comprometendo assim a legibilidade e manutenção do código produzido. Como uma alternativa a esse problema, este artigo apresentará o framework JColtrane, um framework nacional que foi um dos projetos premiados no não consumir muita memória, ao mesmo tempo em que mantém algumas formas de acessos às informações já processadas. Além disso, ele provê um conjunto de anotações padrão para definir condições de execução de métodos e a possibilidade de criação de anotações personalizadas, personalização no recebimento dos argumentos e wrapper automático para tipos primitivos. Os exemplos apresentados durante o artigo estarão disponíveis para donwload no site da revista. XML Programming Context Em outubro de 2008 o International DB2 Users Group, com o apoio da IBM, iniciou um concurso com cinco categorias, em 23 países, para promover o banco de dados DB2, especialmente o purexml nas comunidades de desenvolvedores e estudantes. O tema central, como indica o nome do concurso (Search for a XML Superstar), foi o XML. O framework JColtrane foi inscrito na categoria XML Programming Context por apresentar uma forma inovadora de realizar o parsing desse tipo de arquivo. A avaliação incluía tópicos como a utilidade, reusabilidade, documentação, segurança e inovação. Disputando com vários concorrentes, o JColtrane faturou o 1º lugar na sua categoria, afirmando-se como uma solução inovadora e reutilizável reconhecida internacionalmente. Parsing com SAX exemplos apresentados no artigo. Ele possui um elemento raiz chamado <listadeartigos> que pode possuir diversos tipos de elementos como <livro>, <revista> ou <paragrafo>. Cada elemento desse tipo pode possuir atributos representando a língua em que foram escritos e elementos que apresentem partes internas do mesmo. Note que a tag <paragrafo> pode ser encontrada em diversos locais, como, por exemplo, dentro de <livro> e diretamente dentro de <listadeartigos>. 26

2 Listagem 1. Exemplo.xml: arquivo base para os exemplos. <?xml version= 1.0 encoding= UTF-8?> <listadeartigos> <livro lingua= pt disponivelparavenda= true > <paragrafo lingua= ita >Corpo do parágrafo solto do livro</ paragrafo> <capitulo numero= 2 > <paragrafo lingua= pt linha= 5 >Corpo do parágrafo do capítulo </paragrafo> </capitulo> </livro> <revista lingua= eng > <secao numero= 5 > <paragrafo lingua= pt linha= 7 >Corpo do parágrafo da seção </paragrafo> </secao> <paragrafo lingua= pt linha= 6 >Corpo do parágrafo solto na resvista </paragrafo> </revista> <paragrafo lingua= es >Parágrafo Solto</paragrafo> </listadeartigos> Imagine, por exemplo, que esse arquivo tenha sido recebido de algum site, como resposta a uma busca por artigos científicos. Se fosse necessário processar esse documento, mostrando os nomes de todas as tags quando iniciam e quando terminam, bem como o corpo dos parágrafos, na Listagem 2. Listagem 2. SAXHandler: Classe que herda de DefautlHandler do SAX. package com.mundoj.exemplo1; public class SAXHandler extends DefaultHandler { private StringBuilder corpodoparagrafo=null; public void startdocument() { System.out.println( Reservando Recursos... ); corpodoparagrafo = new StringBuilder(); public void enddocument() { System.out.println( Liberando Recursos... ); corpodoparagrafo=null; public void startelement(string uri, String localname, String tag, Attributes atributos) throws SAXException { corpodoparagrafo.delete(0, corpodoparagrafo.length()); public void endelement(string uri, String localname, String tag) throws SAXException { if( paragrafo.equals(tag)){ corpodoparagrafo.delete(0, corpodoparagrafo.length()); public void characters(char[] ch, int start, int lenght) throws SAXException { corpodoparagrafo.append(ch, start, lenght); Esse exemplo básico mostra os cinco principais métodos da classe DefaultHandler que devem ser sobrescritos para realizar o processamento. Eles estão explicados brevemente na Tabela 1. A Listagem 3 apresenta um código que mostra como invocar o handler para fazer o processamento do documento. Listagem 3. SAXHandlerTest: Classe de teste para SAXHandler public class SAXHandlerTest { public static void main(string[] args) { SAXParser parser; try { parser= SAXParserFactory.newInstance().newSAXParser(); File file=new File( exemplo.xml ); InputSource input=new InputSource(file.getAbsolutePath()); parser.parse(input,new SAXHandler()); catch (ParserConfigurationException e) { e.printstacktrace(); catch (SAXException e) { e.printstacktrace(); catch (IOException e) { e.printstacktrace(); catch (Exception e){ e.printstacktrace(); Método startdocument() enddocument() public void startelement(string uri, String localname, String tag, Attributes atributos) public void endelement(string uri, String localname, String tag) Descrição Executado no início do processamento. Utilizado em geral para reservar recursos necessários ao processamento. Executado ao final do processamento. Utilizado em geral para liberar os recursos alocados para o processamento. Executado ao início de todo elemento. Recebe como parâmetros uri, localname, tag e atributos do elemento. Executado ao final de todo element. Recebe como parâmetros uri, local- Name e tag do elemento. Characters Executado diversas vezes para construir a cadeia de caracteres referentes ao corpo de um elemento. A cadeia construída deve ser utilizada somente ao fim dos elementos, momento no qual se garante a total construção da cadeia. Se fosse pedido, como condições, que a língua de um parágrafo fosse comparada à língua do objeto que contém aquele parágrafo (livro ou revista) e que também fossem impressos somente os corpos de parágrafos que estão dentro de livros ou imediatamente dentro de revista, a classe uma possível implementação. 27

3 Listagem 4. SAXHandlerModificada: Classe que herda de DefautlHandler do SAX. public class SAXHandlerModificada extends DefaultHandler { private StringBuilder corpodoparagrafo=new StringBuilder();; private String linguadolivro=null; private String linguadarevista=null; private String linguadoparagrafo=null; private int distanciadoelementoatualpararevista=-1; public void startelement(string uri, String localname, String tag, Attributes atributos) throws SAXException { if(distanciadoelementoatualpararevista!=-1){ distanciadoelementoatualpararevista++; if( livro.equals(tag)){ linguadolivro=new String(atributos.getValue( lingua )); else if( revista.equals(tag)){ linguadarevista=new String(atributos.getValue( lingua )); distanciadoelementoatualpararevista=0; else if( paragrafo.equals(tag)){ linguadoparagrafo=new String(atributos.getValue( lingua )); corpodoparagrafo.delete(0, corpodoparagrafo.length()); public void endelement(string uri, String localname, String tag) throws SAXException { if( livro.equals(tag)){ linguadolivro=null; else if( revista.equals(tag)){ linguadarevista=null; distanciadoelementoatualpararevista=-1; else if( paragrafo.equals(tag)){ if(isrevistaelementopai()){ System.out.println( Língua da revista e parágrafo são iguais: +(linguadarevista.equals(linguadoparagrafo))); else if(linguadolivro!=null){ System.out.println( Língua do livro e parágrafo são iguais: +(linguadolivro.equals(linguadoparagrafo))); if(distanciadoelementoatualpararevista!=-1){ distanciadoelementoatualpararevista--; corpodoparagrafo.delete(0, corpodoparagrafo.length()); public void characters(char[] ch, int start, int lenght) throws SAXException { corpodoparagrafo.append(ch, start, lenght); private boolean isrevistaelementopai(){ if(linguadarevista==null){ return false; else return distanciadoelementoatualpararevista==1; Apenas com a criação de algumas restrições relativamente simples, já se pode notar que foi necessário criar alguns atributos na classe de processamento para manter informações sobre elementos já iniciados, bem como a necessidade de criação de desvios condicionais. É possível perceber que quanto mais condições fossem impostas, mais atributos para manter estado seriam criados e mais blocos if/else seriam necessários para separar as informações. Essa estrutura aumenta a dificuldade para compreensão do código, tornando-o de difícil manutenção. Programadores experientes usariam Handlers, que implementariam uma interface comum, para evitar o uso de tantos desvios condicionais. Como, por exemplo, poderiam ser desenvolvidos handlers para cada tipo de tag e colocadas em um Mapa, de forma que o handler apropriado fosse utilizado dependendo do nome da tag. Contudo, o nome de um elemento não é o único fator que diferencia o processamento, e, nesse caso, o programador teria duas saídas: recorrer aos desvios lógicos ou criar outros handlers. Criando os desvios lógicos, acarretaria nos problemas de dificuldade de compreensão do código já mencionados. Criando mais handlers, a estrutura de tratamento ficaria muito granular, tornando difícil o entendimento da real da condição final para que um tratamento seja executado, já que seria necessária uma navegação entre as associações dos handlers. Listagem 5. ProcessadorComAnotacoesBasicas: Classe para exemplificação das principais Anotações do JColtrane. public class ProcessadorComAnotacoesBasicas private void startdocument() { System.out.println( Reservando Recursos... private void enddocument() { System.out.println( Liberando Recursos... ); Parsing com JColtrane Para utilizar o JColtrane e rodar os exemplos, basta adicionar o jar do projeto, que se encontra para donwload na página do framework (http// baixo dos panos, o jar é o único arquivo necessário. ma classe para executar o processamento. Ele faz uso de anotações para indicar os métodos a serem private void startelement(@tag String tag) { private void endelement(@body String corpodoparagrafo,@tag String tag) { 28

4 A Classe presente na Listagem 5 apresenta as anotações básicas do JColtrane. Elas são brevemente descritas na Tabela 2. Chama-se atenção pelo fato de que não foi necessário utilizar nenhum desvio condicional nem criar novos atributos. Além disso, os métodos não recebem argumentos que não são utilizados. Para testar o funcionamento da classe, poderia ser utilizada a classe constante na Listagem 3, com a alteração apenas do handler passado como ProcessadorComAnotaçõesBasicas()). Ou seja, em vez da implementação que em seu construtor leva como parâmetro a classe anotada para o sobrecarregado para que várias classes anotadas possam ser passadas implementar várias classes de processamento diferentes, o que permite inclusive que a leitura de um arquivo seja estendida sem alterar a classe de processamento original. Anotação Descrição Listagem 6. ProcessadorBasico: Classe para exemplificação de funcionalidades do JColtrane. public class ProcessadorBasico private void startdocument() { System.out.println( Reservando Recursos... private void enddocument() { System.out.println( Liberando Recursos... private void startelement(@tag String tag) { (tag= paragr.*,priority=1) private void endelement(@body String método anotado deve executar no início do processamento do private void imprimirtagencerramento(@tag método anotado deve executar no fim do processamento do método anotado deve executar iniciar método anotado deve executar terminar Tabela 2. Anotações Básicas do JColtrane. Como o leitor pode constatar comparando as tabelas 1 e 2, os nomes das anotações são os mesmos dos métodos principais da classe DefaultHan- Para elucidar algumas funcionalidades do JColtrane, na Listagem 6 consta o código para um processamento equivalente do executado pela classe da Listagem 2. É interessante notar que a primeira anotação possui dois parâmetros: tag e priority. Eles servem para indicar as condições nas quais ca que o método só deve ser executado se a tag possuir prefixo paragraf, outro, se possuir priority maior, ou após, se conter uma prioridade menor. O JColtrane trabalha sempre com expressões regulares para aumentar o "poder de fogo" do desenvolvedor na filtragem de elementos. Além das propriedades já descritas, as anotações fornecem outras opções que estão representadas na Tabela 3. Parâmetro Tipo do parâmetro Descrição Tag String (regex) Método deve ser executado se o elemento processado possui tag aceita pela expressão regular Uri String (regex) Método deve ser executado se o elemento processado possui uri aceita pela expressão regular localname String (regex) Método deve ser executado se o elemento processado possui local name aceito pela expressão regular Attributes Array que pode possui as propriedades name e value, ambos do tipo String(regex) Método deve executar se elemento possui atributo aceito pela regex name e valor aceito pela regex value (opcional) Priority Int Para métodos a serem executados no mesmo processamento de um elemento, aqueles com maior valor de priority executarão antes que os com menor valor Tabela 3. Opções básicas de filtragem. 29

5 Apesar das opções apresentadas já fornecerem uma boa maneira de exprimir condições de execução, o framework ainda fornece mais duas anotações que podem ser usadas. Para elucidar essas anotações, será es- Listagem 7. ProcessadorBasicoModificado: Classe exemplo para public class ProcessadorBasicoModificado private void startelement(@tag String tag) livro ) private void armazenarlinguadolivroi(@generalusemap Map<String,Object> lingua ) String lingua) { map.put( livro, revista ) private void armazenarlinguadarevista(@generalusemap Map<String,Object> lingua ) String lingua) { map.put( revista, livro ) (tag= paragr.*,priority=1) private void endelementdentrodelivro(@body String lingua ) String linguaparagrafo,@generalusemap Map<String,Object> map){ System.out.println( Língua do livro e parágrafo são iguais: +linguaparagrafo.equals(map.get( livro revista,elementdeep=1) (tag= paragr.*,priority=1) private void endelementdentroderevista(@body String corpodoparagrafo,@attribute( lingua ) String Map<String,Object> map){ System.out.println( Língua da revista e parágrafo são iguais: +linguaparagrafo.equals(map.get( revista ))); private void imprimirtagencerramento(@tag String tag){ (tag= livro ) private void anularlinguadolivro(@generalusemap Map<String,Object> map){ map.put( livro, null); (tag= revista ) private void anularlinguadarevista(@generalusemap Map<String,Object> map){ map.put( revista, null); Essa classe possui várias características interessantes a serem explicadas. Primeiramente se ressalta a Ela serve para indicar, como condição adicional, que o elemento em questão deve ser descendente, em qualquer profundidade, do elemento indicado na propriedade tag da anotação. Assim e, essa anotação aceita vários parâmetros de filtragem. Na sequência, pode se observar a Parecida essa anotação indica que o elemento em questão deve ser descendente de um elemento indicado nas propriedades e a profundidade de um para o outro é indicada através da propriedade elementdeep. Além dessas duas anotações, pode ser notado que os parâmetro dos métodos também possuem anotações. Isso acontece para que o framework possa prover para cada método apenas as informações necessárias para seu processamento. Chama-se atenção especial para a O parâmetro anotado com ela recebe o nome do atributo almejado indicado na sua anotação. são Strings, e caso ele tenha um valor inteiro ou booleano, é necessário fazer a conversão. Para evitar esse trabalho, o JColtrane já seta o parâmetro com o tipo correto, isso para os oito tipos primitivos e seus respectivos Wrappers, bem como para a classe String. Assim, para o caso poderia ser usado um parâmetro inteiro ou do tipo Integer anotado. O exemplo de assinatura de um método seria: private void acessarlinha(@ Attribute( linha ) int linha). As outras anotações para parâmetros podem ser observadas com sua descrição na Tabela 4. As opções de filtragem das e, mais o comportamento oferecem uma boa maneira de expressar condições de processamento. Contudo, é sabido que as possibilidades de condições são infinitas e apenas essas anotações não são suficientes em determinados casos. Com isso em mente, o JColtrane fornece uma estrutura que permite aos desenvolvedores criar anotações personalizadas para restringir a invocação de um determinado método. Será descrito no restante deste artigo como criar suas próprias anotações e como estender o JColtrane para implementar o comportamento desejado. Criando Anotações de Processamento Personalizadas Primeiramente, a anotação deve ser criada. Assim como programação de classes, é recomendável dar um nome sugestivo para as mesmas. Nesse exemplo, será criada uma anotação para filtrar elementos que possuam corpo respeitando uma expressão regular. Como o corpo só está disponível quando o elemento finaliza, essa anotação só deverá ser usada em conjunto com. O código da anotação consta na Listagem 8. Para criar um novo tipo de condição, deve-se criar uma classe que implementa a interface Condition. A interface Condition possui o método verify, que retorna um boleano, que deve retornar verdadeiro somente quando o método de processamento anotado deve ser executado. Uma anotação pode possuir várias Conditions ligadas a ela, de forma que todas devem ser satisfeitas para que o método seja executado. Esse método 30

6 Anotação Atribui para o parâmetro o valor do atributo dado pelo seu nome qualificador do elemento corrente. Faz casting automático para todos tipos primitivos ou seus respectivos wrappers. Retorna null para objetos, MIN_VALUE ou false para tipos primitivos, se o elemento não contiver o atributo Atribui para o parâmetro um mapa com todos os atributos daquele Atribui para o parâmetro o galho corrente do Atribui para o parâmetro a uri do elemento Atribui para o parâmetro a tag do elemento Atribui para o parâmetro o local name do elemento Atribui para o parâmetro um mapa de uso geral para armazenar informações importantes a serem compartilhadas entre os métodos. Seu uso evita a criação de inúmeros atributos e permite o compartilhamento de informações caso mais de uma classe seja utilizada para o Atribui para o parâmetro o corpo do elemento corrente e só pode ser utilizado em métodos anotados com. Possui as propriedades newline e tab, que podem assumir valores verdadeiro (true) ou falso (false), que configuram respectivamente se a String deve vir com ou sem marcadores de linha ou tabulação. Listagem 8. ContemCorpo: Anotação personalizada @Documented ContemCorpo { String value() default.* ; Listagem 9. CondicaoContemCorpo: implementação da interface Condition. public class CondicaoContemCorpo implements Condition { private Pattern pattern; public CondicaoContemCorpo(String regex) { super(); recebe um objeto da classe ContextVariables. Essa classe fornece várias informações sobre o contexto do processamento naquele momento. Ela não será aqui detalhada, porém, sua especificação pode ser encontrada no site do projeto. A classe recebe no construtor a expressão regular que deve buscar no corpo do elemento. No método verify(), busca-se o valor do corpo na variável contextvariables e verifica se ele se encaixa na expressão. public boolean verify(contextvariables contextvariables) { return pattern.matcher(contextvariables.getbody()).matches(); 31

7 A interface ConditionFactory é a responsável por ler a anotação e criar as instâncias de Condition apropriadas. Essa interface possui apenas um método que deve ser executado, o getconditions(). Ele retorna uma lista contendo todas as condições (instâncias de Condition) que devem ser obedecidas para que o método execute. Ele recebe como parâmetro uma anotação. Se ela for instância da anotação desejada, então as condições devem ser retornadas, levando em conta os parâmetros da anotação. Na Listagem 10 consta a implementação da interface ConditionFactory para o exemplo. O método getconditions() verifica se a anotação é do e em caso positivo retorna a lista de condições apenas com uma instância da condição CondicaoContemCorpo apresentada Listagem 10. FabricaDeCondicoesContemCorpo: implementação da interface ConditionFactory. public class FabricaDeCondicoesContemCorpo implements ConditionsFactory public List<Condition> getconditions(annotation annotation) { if(annotation instanceof ContemCorpo){ ContemCorpo anotacaocontemcorpo=(contemcorpo) annotation; List<Condition> list=new ArrayList<Condition>(); list.add(new CondicaoContemCorpo(anotacaoContemCorpo.value())); //Caso houvesse mais condições ligadas, elas seriam //adicionadas à lista aqui return list; return null; Para finalizar, basta acrescentar na anotação criada onde encontrar a fábrica apropriada para criar suas condições. Para isso, é necessário acrescentar a na própria anotação, com a classe ConditionFactory que lê aquela anotação. A anotação do exemplo, alterada, pode ser vista na Listagem 11. Listagem 11. ContemCorpo: Anotação personalizada com a configuração da fábrica de Executadas as etapas anteriores, é possível usar a anotação em conjunto com. A Listagem 12 apresenta uma classe que utiliza a anotação criada. Processando o arquivo exemplo.xml com a classe da Listagem 12, são impressos no console somente os corpos que possuem a palavra solto, conforme a saída abaixo. Corpo do parágrafo solto do livro Corpo do parágrafo solto na revista Listagem 12.ProcessadorContemCorpo: Classe que utiliza a anotação personalizada criada como exemplo. public class ProcessadorContemCorpo ) private void String corpo){ System.out.println(corpo); SAX versus JColtrane O JColtrane busca agregar algumas funcionalidades para facilitar o - Cabe ao usuário avaliar se as facilidades trazidas compensa a perda de gargalo da aplicação, na maioria dos casos usar um ou outro não afetará significativamente o tempo de processamento. Para comparar de forma mais criteriosa as duas abordagens, foi feito - processamento e foi criada uma versão utilizando o JColtrane. Os testes de unidade já existentes ajudaram a comprovar que a funcionalidade gerada era a mesma. Diversas métricas foram realizadas na utilização das duas abordagens. Em termos de qualidade de código, o JColtrane deixou coesos, menor acoplamento com outras classes e menor complexidade pouco de vantagem foi realmente o desempenho. Não está no escopo deste artigo se aprofundar na comparação @ConditionFactoryAnnotation(FabricaDeCondicoesContemCorpo.class) ContemCorpo { String value() default.* ; 32

8 mais detalhes sobre o experimento e das métricas realizadas podem ser encontrados no Trabalho de Conclusão de Curso que deu origem ao framework Tratamento de Eventos em Java com Uso de Metadados disponível através de uma busca em - Combinação Explosiva, falou sobre a criação de anotações. Na edição 34, o artigo Padrões de Projeto para Flexibilizar o Uso de Anotações apresentou dois padrões que foram utilizados durante a construção do JColtrane. Referências Saber mais Considerações finais Com este artigo é possível que o leitor tenha conhecimento sobre Buscou-se mostrar o quanto ele deixa as classes de processamento mais legíveis e mais fáceis de manter do que quando se usa somen- sados, buscando essa característica importante dos processadores baseados no DOM, mas como é baseado em eventos, não causa problemas com estouro de memória. Assim, nas aplicações em que o uso de outros parsers acarreta em problemas com memória, o JCol- na internet e não se conhece muito bem sua estrutura e só se deseja