Como todos sabemos, existem mais e mais métodos para analisar o XML agora, mas existem apenas quatro métodos convencionais, a saber: DOM, Sax, Jdom e DOM4J
O seguinte é o primeiro a dar o endereço de download do pacote JAR para esses quatro métodos
Dom: Ele vem no atual Java JDK, no pacote XML-Apis.jar
Sax: http://sourceforge.net/projects/sax/
JDOM: http://jdom.org/downloads/index.html
DOM4J: http://sourceforge.net/projects/dom4j/
1. Introdução e análise de vantagens e desvantagens
1. DOM (modelo de objeto de documento)
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.
【vantagem】
① Permitir que os aplicativos façam alterações nos dados e na estrutura.
② O acesso é bidirecional e você pode navegar para cima e para baixo na árvore a qualquer momento, obter e operar qualquer parte dos dados.
【Deficiência】
① Normalmente, todo o documento XML precisa ser carregado para construir a hierarquia, que consome muitos recursos.
2. Sax (API simples para XML)
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 um 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.
【Vantagens】
① Não há necessidade de esperar que todos os dados sejam processados e a análise possa começar imediatamente.
② Verifique os dados somente ao ler os dados e não precisa ser salvo na memória.
③ Você pode parar de analisar quando uma certa condição é atendida, sem ter que analisar o documento inteiro.
④ Alta eficiência e desempenho, e pode analisar documentos maiores que a memória do sistema.
【Deficiência】
① O aplicativo precisa ser responsável pela lógica de processamento da tag (como manter o relacionamento pai/filho etc.), quanto mais complexo o documento, mais complicado o programa é.
② A navegação unidirecional não pode localizar a hierarquia de documentos e é difícil acessar diferentes partes dos dados do mesmo documento ao mesmo tempo e não suporta o XPath.
3. JDOM (modelo de objeto de documento baseado em Java)
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.
【vantagem】
①Use classes de concreto em vez de interfaces, simplificando a API DOM.
② Um grande número de aulas de coleta Java são usadas para facilitar os desenvolvedores de Java.
【Deficiência】
① Não boa flexibilidade.
② Má desempenho.
4. DOM4J (modelo de objeto de documento para Java)
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.
【vantagem】
①A classe de coleta Java é amplamente usada para facilitar os desenvolvedores de Java e fornecer alguns métodos alternativos para melhorar o desempenho.
②Support XPath.
③ tem um bom desempenho.
【Deficiência】
① A interface é usada extensivamente e a API é relativamente complexa.
2. Comparação
1. 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.
2. A JDOM e o DOM têm um desempenho ruim durante o teste de desempenho, a memória transborda ao testar documentos de 10 milhões, mas portátil. 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).
3. O Sax tem um desempenho melhor, o que depende de 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).
Minha opinião: se o documento XML for grande e não considerar problemas de portabilidade, é recomendável usar o DOM4J; Se o documento XML for pequeno, é recomendável usar a JDOM; Se precisar ser processado a tempo sem salvar dados, é recomendável considerar o sax. Mas não importa o quê, a mesma frase é: a melhor coisa é a coisa certa. Se o tempo permitir, é recomendável que você tente esses quatro métodos e escolha um que combine com você.
Iii. Exemplo
Para economizar espaço, esses quatro métodos e diferenças na criação de documentos XML não são fornecidos aqui por enquanto. Somente o código para analisar documentos XML é fornecido. Se for necessário um projeto completo (construindo documentos XML + comparação de testes XML +).
Aqui está o seguinte conteúdo XML como exemplo para analisar:
<?xml version="1.0" encoding="UTF-8"?><users> <user id="0"> <name>Alexia</name> <age>23</age> <sex>Female</sex> </user> <user id="1"> <name>Edward</name> <age>24</age> <sex>Male</sex> </user> <user id="2"> <name>wjm</name> <age> 23 </age> <ogem> feminino </sex> </suser> <user id = "3"> <name> wh </name> <eane> 24 </ge> <ogem> masculino </sex> </suser> </suserves>
Primeiro defina a interface para a análise de documentos XML:
/*** @Author Alexia** Defina a interface para o documento XML Parsing*/Public Interface Xmldocument {/*** Parse XML Document** @param FileName* Nome do caminho completo*/public void parserxml (string filename);} 1. Exemplo de DOM
pacote com.xml; importar java.io.fileNotFoundException; importar java.io.fileOutputStream; importar java.io.ioException; importar java.io.printwriter; import javax.xml.parsers.documentsbuilder; importância javax.xml.parsers.parserConfigurationException; importar javax.xml.transform.outputkeys; importar javax.xml.transform.transformer; import javax.xml.transform.transformerConfigurationException; importância javax.xml.transform.TransformerFactory; importar javax.xml.transform.dom.domsource; importar javax.xml.transform.stream.streamResult; import org.w3c.dom.document; importação de org.wod.wod.nomem.wd.wd.w3c.w3c.document; import.wod3c.domement; import3c.w3c.w3c.document; importação; org.xml.sax.saxException;/** * @Author Alexia * * Dom Parsing XML Document */public class DomDemo implementa Xmldocument {Documento privado; public void parserxml (string filename) {try {documentBuilderFactory dbf = documentBuilderFactory.NewInstance (); Documentbuilder db = dbf.newdocumentBuilder (); Documento documento = db.parse (nome do arquivo); Usuários nodelist = document.getChildNodes (); for (int i = 0; i <users.getLength (); i ++) {node user = users.item (i); Nodelist userInfo = user.getChildNodes (); for (int j = 0; j <userinfo.getLength (); j ++) {nó nó = userinfo.item (j); Nodelist list UserMeta = node.getChildNodes (); para (int k = 0; k <userMeta.getLength (); k ++) {if (userMeta.iTem (k) .getNodename ()! = "#Text") System.out.println (usermeta.item (k) .getnodename () + ":" + useMeMeMeM (k). } System.out.println (); }}} catch (filenotfoundException e) {e.printStackTrace (); } catch (parserConfigurationException e) {e.printStackTrace (); } catch (saxException e) {e.printStackTrace (); } catch (saxException e) {e.printStackTrace (); } catch (saxException e) {e.printStackTrace (); } catch (ioexception e) {e.printStackTrace (); }}} 2. Exemplo de sax
pacote com.xml; importar java.io.fileInputStream; importar java.io.fileNotFoundException; importar java.io.fileOutputStream; importar java.io.ioException; import java.io.InputStream; importar java.io.outputStream; importar; importar; javax.xml.parsers.parserConfigurationException; importar javax.xml.parsers.saxparser; importar javax.xml.parsers.saxparserFactory; import javax.xml.transform.outputkeys; import javax.xml.trax.trax.xmult; javax.xml.transform.TransformerConfigurationException; importar javax.xml.transform.sax.saxtransformerFactory; importar javax.xml.transform.Sax.TransformerHandler; import javax.transform.streamaMReRSult; importandler; importação; org.xml.sax.saxException; importar org.xml.sax.helpers.attributesImpl; importar org.xml.sax.helpers.defaultHandler;/** ** * @author Alexia * * SAX Parsing Xml SaxParSerFactory saxfac = saxparserFactory.NewInstance (); tente {saxparser saxparser = saxfac.newsaxparser (); InputStream is = new FileInputStream (nome do arquivo); saxparser.parse (é, new mysaxHandler ()); } catch (parserConfigurationException e) {e.printStackTrace (); } catch (saxException e) {e.printStackTrace (); } catch (filenotfoundException e) {e.printStackTrace (); } catch (ioexception e) {e.printStackTrace (); }}} classe MySaxHandler estende o DefaultHandler {boolean hasattribute = false; Atributos atributos = null; public void startDocument () lança saxException {// System.out.println ("O documento começou a imprimir"); } public void enddocument () lança saxException {// System.out.println ("O documento acabou com a impressão"); } public void startElement (String Uri, String LocalName, String qname, atributos atributos) lança saxException {if (qname.equals ("usuários")) {return; } if (qname.equals ("user")) {return; } if (attritutes.getLength ()> 0) {this.attributes = atributes; this.hasattribute = true; }} public void endElement (string uri, string localName, string qname) lança saxException {if (hasattribute && (atributes! = null)) {for (int i = 0; i <attriTutes.getLength (); i ++) {System.out.print (attributes.gutes.gutes) (); }}} Public void caracteres (char [] ch, int start, int length) lança saxException {System.out.print (new String (ch, start, comprimento)); }} 3. Exemplo de jddom
pacote com.xml; importar java.io.fileNotFoundException; importar java.io.fileOutputStream; importar java.io.ioException; importar java.util.list; importação org.jdom2.document; importar org.jdomement; importin.jdom2.jdom2sCception; importação; importar org.jdomement; org.jdom2.output.xmloutputter;/** * @Author Alexia * * Jomia analisando os documentos xml * */public class JdomDemo implementa Xmldocument {public void parserxml (string filename) {saxbuilder construtor = novo saxbuilder (); tente {document document = builder.build (nome do arquivo); Usuários do elemento = document.getrootelement (); Listar userList = usuários.getChildren ("usuário"); for (int i = 0; i <userList.size (); i ++) {elemento user = (element) userList.get (i); Listar userInfo = user.getChildren (); para (int j = 0; j <userInfo.size (); j ++) {System.out.println (((element) userInfo.get (j)). getName () + ":" + ((element) userinfo.get (j)). getValue ()); } System.out.println (); }} catch (jdomexception e) {e.printStackTrace (); } catch (ioexception e) {e.printStackTrace (); }}} 4. DOM4J Exemplo
pacote com.xml; importar java.io.file; importar java.io.filewriter; importar java.io.ioException; importar java.io.writer; importar java.util.iterator; importação ou; (importação.Mument.Mument.Dom4j.document; import org.dom4j.documentExt; org.dom4j.io.saxReader; importar org.dom4j.io.xmlwriter;/** * @Author Alexia * * Dom4j Parse XML Document */public class Dom4jDemo implementa Xmldocument {public void parserXml (string filename) {file inputXML = FILHEN; Saxreader saxreader = new saxReader (); tente {document document = saxreader.read (inputxml); Usuários do elemento = document.getrootelement (); for (iterator i = users.elementIterator (); i.hasnext ();) {elemento user = (element) i.next (); for (iterator j = user.ElementIterator (); j.hasnext ();) {elemento nó = (elemento) j.Next (); System.out.println (node.getName () + ":" + node.getText ()); } System.out.println (); }} catch (documentException e) {System.out.println (e.getMessage ()); }}}O exposto acima é todo o conteúdo deste artigo. Espero que seja útil para o aprendizado de todos e espero que todos apoiem mais o wulin.com.