1.
DOM é o padrão oficial W3C para representar documentos XML de maneira independente de plataforma e linguagem. Dom é uma coleção de nós ou fragmentos de informação organizados em uma hierarquia. Essa hierarquia permite que os desenvolvedores procurem informações específicas na árvore. Analisar essa estrutura geralmente requer carregar o documento inteiro e a construção da hierarquia antes que qualquer trabalho possa ser realizado. Como é baseado no nível de informação, o DOM é considerado baseado em árvores ou baseado em objetos. DOM e processamento generalizado baseado em árvores têm várias vantagens. Primeiro, como a árvore é persistente na memória, ela pode ser modificada para que o aplicativo possa fazer alterações nos dados e na estrutura. Ele também permite que você navegue para cima e para baixo na árvore a qualquer momento, em vez de ser um trabalho único como o Sax. DOM é muito mais simples de usar.
2. Sax
As vantagens do processamento sax são muito semelhantes às vantagens do streaming. A análise pode começar imediatamente, em vez de esperar que todos os dados sejam processados. E, como o aplicativo verifica apenas os dados ao lê -los, ele não precisa armazenar os dados na memória. Esta é uma grande vantagem para documentos grandes. De fato, o aplicativo nem precisa analisar todo o documento; Pode parar de analisar quando uma certa condição é atendida. De um modo geral, o Sax é muito mais rápido que o seu DOM de substituição.
Escolha DOM ou Sax? Para os desenvolvedores que precisam escrever seu próprio código para processar documentos XML, escolher um modelo DOM ou Sax Parsing é uma decisão de design muito importante. O DOM usa o método de estabelecer uma estrutura de árvore para acessar documentos XML, enquanto o Sax usa o modelo de evento.
O DOM Parser converte um documento XML em uma árvore contendo seu conteúdo e pode atravessar a árvore. A vantagem de analisar um modelo com DOM é que é fácil de programar. Os desenvolvedores precisam apenas chamar instruções de fabricação de árvores e usar APIs de navegação para acessar os nós de árvore necessários para concluir a tarefa. É fácil adicionar e modificar elementos na árvore. No entanto, como todo o documento XML precisa ser processado ao usar o analisador DOM, os requisitos de desempenho e memória são relativamente altos, especialmente ao encontrar grandes arquivos XML. Devido aos seus recursos de travessia, os analisadores DOM são frequentemente usados em serviços em que os documentos XML exigem alterações frequentes.
O analisador sax adota um modelo baseado em eventos. Ele pode desencadear uma série de eventos ao analisar um documento XML. Quando uma determinada tag é encontrada, ela pode ativar um método de retorno de chamada para informar o método que a tag foi encontrada. O Sax geralmente requer baixa memória porque permite que os desenvolvedores decidam as tags que desejam processar. Especialmente quando os desenvolvedores precisam apenas processar parte dos dados contidos no documento, a capacidade de expansão do Sax é melhor refletida. No entanto, a codificação é difícil ao usar o analisador sax e é difícil acessar vários dados diferentes no mesmo documento ao mesmo tempo.
3. JDOM http://www.jdom.org
O objetivo da Jdomia é ser um modelo de documento específico para Java, que simplifica a interação com XML e é mais rápido que o uso do DOM. Como é o primeiro modelo específico de Java, a juíza foi promovida e promovida vigorosamente. Considerando acabar usando-o como uma "Extensão padrão Java" via "Java Specification Request JSR-102". O desenvolvimento da jdomia foi iniciado desde o início de 2000.
A JDOM e o DOM são principalmente diferentes em dois aspectos. Primeiro, a JDOM usa apenas classes de concreto e não interfaces. Isso simplifica a API de certa forma, mas também limita a flexibilidade. Segundo, a API usa um grande número de classes de coleções, simplificando o uso de desenvolvedores de Java que já estão familiarizados com essas classes.
A documentação da JDOM declara que seu objetivo é "usar 20% (ou menos) de esforço para resolver 80% (ou mais) problemas Java/XML" (assumidos como 20% com base na curva de aprendizado). É claro que a JDOM é útil para a maioria dos aplicativos Java/XML, e a maioria dos desenvolvedores acha APIs muito mais fáceis de entender do que o DOM. A JDOM também inclui verificações bastante extensas sobre o comportamento do programa para impedir que os usuários façam qualquer coisa sem sentido no XML. No entanto, ainda exige que você entenda completamente o XML para fazer algo além do básico (ou mesmo entender erros em alguns casos). Este pode ser um trabalho mais significativo do que aprender uma interface DOM ou JDOM.
A própria jdomia não contém um analisador. Geralmente, ele usa um analisador SAX2 para analisar e validar documentos XML de entrada (embora também possa tomar representações DOM anteriormente construídas como entrada). Ele contém alguns conversores para representações de jddom em saída em fluxos de eventos Sax2, modelos DOM ou documentos de texto XML. A JDOM é de código aberto liberado sob a variante da licença Apache.
4. DOM4J http://dom4j.sourceforge.net
Embora o DOM4J represente um resultado de desenvolvimento completamente independente, inicialmente era um ramo inteligente da JDOM. Ele incorpora muitos recursos além das representações básicas de documentos XML, incluindo suporte ao XPath integrado, suporte ao esquema XML e processamento baseado em eventos para documentos grandes ou transmitidos. Ele também fornece a opção de criar uma representação de documentos, que possui acesso paralelo através da API DOM4J e da interface DOM padrão. Está em desenvolvimento desde a segunda metade de 2000.
Para suportar todos esses recursos, o DOM4J usa interfaces e métodos abstratos de classe base. O DOM4J usa a classe de coleções na API extensivamente, mas em muitos casos também fornece algumas alternativas para permitir um melhor desempenho ou um método de codificação mais direto. O benefício direto é que, embora o DOM4J pague o preço de uma API mais complexa, ela fornece uma flexibilidade muito maior que a JDOM.
Ao adicionar flexibilidade, a integração do XPath e os objetivos do processamento de documentos grandes, o DOM4J é o mesmo que a JDOM: facilidade de uso e operação intuitiva para desenvolvedores de Java. Também está empenhado em se tornar uma solução mais completa do que a JDOM, alcançando o objetivo de lidar com todos os problemas Java/XML na natureza. Ao concluir esse objetivo, enfatiza menos ênfase na prevenção do comportamento incorreto do aplicativo que o JDOM.
O DOM4J é uma API Java XML muito, muito excelente, com excelente desempenho, funções poderosas e extremamente fácil de usar. É também um software de código aberto. Atualmente, você pode ver que mais e mais software Java está usando o DOM4J para ler e escrever XML. Vale a pena mencionar particularmente que até o Jaxm da Sun está usando o DOM4J.
Comparação dos quatro métodos
O DOM4J tem o melhor desempenho, e até o Jaxm do Sun usa o DOM4J. Atualmente, muitos projetos de código aberto usam DOM4J em grandes quantidades, como o famoso Hibernate também usa o DOM4J para ler os arquivos de configuração XML. Se a portabilidade não for considerada, o DOM4J será usado.
A JDOM e o DOM têm um desempenho ruim durante o teste de desempenho, a memória transbordando ao testar documentos de 10 milhões. Também vale a pena considerar o DOM e a JDOM no caso de pequena documentação. Embora os desenvolvedores da JDOM tenham declarado que esperam se concentrar em questões de desempenho antes do lançamento oficial, do ponto de vista do desempenho, ele realmente não recomenda. Além disso, Dom ainda é uma escolha muito boa. A implementação do DOM é amplamente utilizada em uma variedade de linguagens de programação. É também a base de muitos outros padrões relacionados ao XML, pois são oficialmente as recomendações do W3C (em oposição aos modelos Java não padrão), portanto, também pode ser necessário em alguns tipos de projetos (como o uso de DOM em JavaScript).
O SAX tem um desempenho melhor, o que depende do seu método de análise específico - orientado a eventos. Um sax detecta um próximo fluxo XML, mas não é carregado na memória (é claro, quando o fluxo XML for lido, alguns documentos serão temporariamente ocultos na memória).
Uso básico de quatro métodos de operação XML
Arquivo XML:
＜? Xml versão = "1.0" Encoding = "GB2312"?> ＜ Resultado> ＜ Valor> ＜ no> a1234 ＜/no> ＜ Addr> No. xx Seção xx Rota, XX Town, XX Condado, Adicionar Província de Sichuan </Addr> ＜/Valor> ＜ Talue> ＜ Não> ＜ ＜ ＜ ＜x City, addr </addr> ＜/value> ＜ x «x xx, xx, addr. </Addr> ＜/value> ＜/resultado ＞
1) Método de implementação do DOM
importar java.io.*; importar java.util.*; importar org.w3c.dom.*; import javax.xml.parsers. tente {arquivo f = novo arquivo ("data_10k.xml"); DocumentBuilderFactory Factory = DocumentBuilderFactory.NewInstance (); DocumentBuilder Builder = Factory.NewDocumentBuilder (); Documento doc = builder.parse (f); Nodelist nl = doc.getElementsByTagName ("value"); para (int i = 0; i ＜ nl.getLength (); i ++) {System.out.print ("Número da placa de contrato:"+doc.getElementsByTagName ("não"). Item (i) .getfirstChild (). getNodEvalue ()); System.out.println ("Endereço do proprietário:" + doc.getElementsByTagName ("addr"). Item (i) .getfirstChild (). GetNodEvalue ()); }} catch (Exceção e) {e.printStackTrace ();} 2) Método de implementação de Sax
importar org.xml.sax.*; importar org.xml.sax.helpers.*; importar javax.xml.parsers. public myxmlReader () {super ();} public static void main (string args []) {durading = System.currenttimemillis (); tente {saxParserFactory sf = saxParSerFactory.NewInstance (); Saxparser sp = sf.newsaxparser (); Leitor myxmlReader = new myxmlReader (); sp.parse (new inputSource ("data_10k.xml"), leitor); } catch (Exceção e) {e.printStackTrace (); } System.out.println ("Tempo de execução:" + (System.currenttimemillis () - durading) + "milissegundos");} Public void caracteres (char ch [], int start, int length) lança saxException {string tag = (string) tags.peek (); if (tag.equals("NO")) { System.out.print("licence plate number: " + new String(ch, start, length));}if (tag.equals("ADDR")) { System.out.println("Address:" + new String(ch, start, length));}} public void startElement(String uri,String localName,String qName,Attributes attrs) { tags.push (qname);}} 3) Método de implementação de jddom
importar java.io.*; importar java.util.*; importar org.jdom.*; importar org.jdom.input.* tente {saxbuilder Builder = new saxbuilder (); Documento doc = builder.build (novo arquivo ("data_10k.xml")); Elemento foo = doc.getrootelement (); Listar allChildren = foo.getChildren (); para (int i = 0; i ＜ allChildren.size (); i ++) {System.out.print ("Número da placa de contrato:"+(((elem elem) allChildren.get (i)). getChild ("não"). getText ()); System.out.println ("Endereço do proprietário:" + ((elemento) allChildren.get (i)). GetChild ("addr"). GetText ()); }} catch (Exceção e) {e.printStackTrace ();}} 4) Método de implementação DOM4J
importar java.io.*; importar java.Util. tente {arquivo f = novo arquivo ("data_10k.xml"); SAXReader Reader = new SaxReader (); Documento doc = leitor.read (f); Elemento root = doc.getrootelement (); Elemento foo; para (iterador i = root.ElementIterator ("value"); i.hasnext () {foo = (element) i.next (); system.out.print ("número da placa:" + foo.ElementText ("não"); system.out.println (endereço do proprietário: " + foo.ElementText); E.PrintStackTrace ();})