1. Prefácio
O DOM4J é uma API de código aberto Java muito excelente, usado principalmente para ler e escrever documentos XML, com excelente desempenho, funções poderosas e uso muito conveniente. Além disso, o XML é frequentemente usado para operadoras de troca de dados, como chamar os parâmetros passados pelo serviço da web e executar operações de sincronização de dados, por isso é muito necessário usar o DOM4J para analisar XML.
2. Condições de preparação
dom4j.jar
Endereço para download: http://sourceforge.net/projects/dom4j/
3. Use DOM4J para praticar
1. Analisando o documento XML
Ideias de implementação:
<1> Depois de ler o caminho XML, ele é passado para o SaxReader e retorna um objeto de documento de documento;
<2> Em seguida, opere este objeto de documento para obter as informações dos seguintes nós e crianças;
O código específico é o seguinte:
importar java.io.file; importar javaifileInputStream; importar javaioInputStream; importar javautiliterator; importar javautillist; importar orgdom4jdocument; importar orgdom4jdocumentHelper; importar orgdom4jElement; importar orgdom4jiosaxreader; /** * Use DOM4J para analisar documentos XML * @Author Administrator * */public class Dom4jParsexmldemo {public void parsexml01 () {try {// Converte o XML abaixo do SRC para entrada de fluxo de entrada de entrada Arquivo ("D:/Project/DynamicWeb/SRC/Resource/Modulexml"); // inputStream inputStream = thisGetClass () getResourceasStream ("/modulexml"); // Você também pode encontrar XML com base no caminho relativo do arquivo compilado da classe // criar um leitor de saxreader, usado especificamente para ler XML SaxReader SaxReader = new SAXReader (); // De acordo com o método de reescrita de leitura do SaxReader, ele pode ser lido através do fluxo de entrada do InputStream ou através do objeto de arquivo // document Document = saxReaderRead (inputStream); Documento Document = SaxReaderRead (novo arquivo ("D:/Project/DynamicWeb/SRC/Resource/Modulexml")); // O caminho absoluto do arquivo deve ser especificado // Além disso, o conversor XML fornecido pelo DocumentHelper também pode ser usado. // document document = documentHelPerParSeText ("<? Xml versão =/" 0/"Encoding =/" utf-8/"?> <Modules id =/" 123/"> <Dodule> Esta é a informação de texto da tag do módulo </module> </modules>"); // Obtenha o elemento do objeto do nó raiz rootElement = DocumentGetrooTelement (); SystemOutPrintln ("Nome do nó raiz:" + rootElementgetName ()); // Obtenha o nome do nó SystemOutPrintln ("Quantos atributos o nó raiz tem:" + rootElementAttributEcount (); // obtém o número de atributos do nó SystemEmOutPrintLn ("o valor do root) value of the node attribute id Systememoutprintln("Text in the root node: " + rootElementgetText());//If the element has children, it returns an empty string, otherwise the text in the node will be returned//rootElementgetText() The reason why the line breaks is because the tab key and newline layout are used between the label and the label, which is also considered text, so the line breaks are displayed. SystemOutPrintln ("Texto (1):" + RootElementTextTrim ()); // O que é removido é a tecla de guia e a linha de linha entre a tag e a tag, etc., não o espaço antes e depois do conteúdo SystemOutPrintln ("Conteúdo do texto do nó da raiz do nó Child:" + RootElementStringValue ()); // Retorna as informações de texto de todos os nós filhos recursivamente no nó atual. // obtém o elemento dos nós da criança = elemento rootElementElement ("módulo"); if (element! = null) {systemeputPrintln ("Texto do sub-nós:" + elementGetText ()); // porque o nó filho e o nó raiz são objetos de elemento, seus métodos de operação são os mesmos} //, no entanto, em alguns casos, o XML é mais complicado e as especificações não são unificadas. Não existe JavalangnullPointerException direto para um determinado nó; portanto, após a obtenção do objeto elemento, você deve primeiro determinar se ele está vazio rootElementSetName ("root"); // suportar para modificar o nome do nó SystemEputPrintln ("o nome após o nó raiz é modificado:" + rootElementname ()); rootElementsettext ("texto"); // O mesmo é verdadeiro para modificar o texto no tag SystemOutPrintln ("Texto após o nó raiz ser modificado:" + rootElementText ()); } catch (Exceção e) {EprintStackTrace (); }} public static void main (string [] args) {dom4jparsexmldemo demo = new Dom4jParsexMldemo (); Demoparsexml01 (); }}Além disso, o XML acima está no SRC, o Module01.xml é o seguinte:
<? xml versão = "0" coding = "utf-8"?> <modules id = "123"> <odule> Esta é a informação de texto da tag do módulo </module> </modules>
Em seguida, execute o principal método desta classe, e o efeito do console é o seguinte:
A partir disso, sabemos:
<1> Existem muitas maneiras de ler arquivos XML;
<2> É muito simples retirar o nome do texto e da etiqueta do objeto elemento;
<3> E é muito conveniente modificar o texto e o rótulo de nomes dos elementos, mas não será gravado nos arquivos XML de disco.
O exposto acima simplesmente obtém o elemento do diretório raiz do XML e, em seguida, atravessa o objeto de documento do documento usando o iterador do iter.
O código específico é o seguinte:
public void parsexml02 () {try {// converte o XML abaixo do SRC no fluxo de entrada inputStream inputStream = thisGetClass () getResourceasStream ("/modulexml"); // Crie um leitor de saxreader especificamente para leitura XML SaxReader SaxReader = new SaxReader (); // De acordo com o método de reescrita de leitura do SaxReader, pode -se ver que ele pode ser lido através do fluxo de entrada do InputStream ou pode ser lido através do documento do objeto de arquivo = saxreadeRread (inputStream); Elemento rootElement = DocumentGleTrooTelement (); Iterator <lement> moduSiberator = rootElementElements ("módulo") iterator (); // rootElementElement ("nome"); Obtenha um certo elemento filho // rootElementElements ("nome"); Obtenha o conjunto de nós de moudule de elementos filhos no nó raiz, retorne o tipo de coleção da lista // rootElementElements ("módulo") iterator (); Iterar cada elemento na coleção de listas devolvidas e retornar todos os nós filhos para uma coleção de iterador enquanto (moduSiteratorHasNext ()) {elemento moduleElement = moduSiteratorNext (); Elemento nameElement = moduleElementElement ("nome"); SystemOutPrintln (NameElementGetName () + ":" + NameElementText ()); Elemento valueElement = moduleElementElement ("valor"); SystemOutPrintln (valueElementGetName () + ":" + valueElementTetText ()); Elemento DescriçãoElement = ModuleElementElement ("Descript"); SystemOutPrintln (descritElementGetName () + ":" + descrecEELEMEMENTTETTEXT ()); }} catch (Exceção e) {EprintStackTrace (); }} Além disso, o XML acima está no SRC, o Module02.xml é o seguinte:
<? xml versão = "1.0" coding = "utf-8"?> <modules id = "123"> <odule> <name> oa </name> <Value> Configuração do sistema básico </value> <Descript> Configuração do sistema básico Diretório raiz </script> </modules> </modules>
Em seguida, execute o principal método desta classe, e o efeito do console é o seguinte:
A partir disso, sabemos:
<1> DOM4J itera sobre os subelementos XML muito eficiente e conveniente;
No entanto, os acima simplesmente iteram sobre os elementos do nó da criança do XML, mas se as regras XML forem mais complicadas, como o Module03.xml a ser testado a seguir, os detalhes são os seguintes:
<? xml versão = "1.0" coding = "utf-8"?> <modules id = "123"> <odule> Esta é a informação de texto da tag do módulo </module> <module id = ""> <name> oa </name> <Value> Configuração do sistema básico </module> <podule> <name> Configuração de gerenciamento </name> <value> nenhum </alue> <secript> Instruções para gerenciar a configuração </descritt> <module id = "106"> <name> gerenciamento do sistema </name> <dalue> 0 </value> <Script> config </descript> <odule id id = "107"> <Doraction> 0 </value> <Script> config </descript> <odule id id = "107. <script> Número </script> </module> </module> </module> </modules>
Como suas estruturas são diferentes, se eles iterarem diretamente, será relatado um erro:
java.lang.nullPointerException
Então você precisa usá -lo com cuidado neste momento. Você não pode colocar os elementos diretamente na iteração a cada vez. O código de implementação específico é o seguinte:
public void parsexml03 () {try {// converte o XML abaixo do SRC no fluxo de entrada inputStream inputStream = thisGetClass () getResourceasStream ("/modulexml"); // Crie um leitor de saxreader especificamente para leitura XML SaxReader SaxReader = new SaxReader (); // De acordo com o método de reescrita de leitura do SaxReader, pode -se ver que ele pode ser lido através do fluxo de entrada do InputStream ou pode ser lido através do documento do objeto de arquivo = saxreadeRread (inputStream); Elemento rootElement = DocumentGleTrooTelement (); if (rootElementElements ("módulo")! = null) {// porque a primeira tag do módulo possui apenas conteúdo e nenhum nós filho, o iterator () é JavalangnullPointerException, por isso precisa implementar a lista <lement> elementList = rootElementElements ("módulo"); para (elemento elemento: elementList) {if (! ElementGetTextTrim () Equals ("" ")) {SystemOutPrintln (" 【1】 " + elementGetTextTrim ()); } else {element nameElement = elementElement ("nome"); SystemOutPrintln ("【2】" + NameElementGetName () + ":" + NameElementText ()); Elemento valueElement = elementElement ("value"); SystemOutPrintln ("【2】" + valueElementGetName () + ":" + valueElementText ()); Elemento DescriçãoElement = ElementElement ("Descript"); SystemOutPrintln ("【2】" + DescriçãoElementGetName () + ":" + DescriçãoElementText ()); List <lement> SubElementList = ElementElements ("Módulo"); para (Subelement de elemento: SubElementList) {if (! SubElementTextTtrim () Equals ("")) {SystemOutPrintln ("【3】" + SubElementTextTrim ()); } else {elemento subnameElement = subelementElement ("nome"); SystemOutPrintln ("【3】" + subnameElementGetName () + ":" + subnameElementText ()); Elemento subvalueElement = subelementElement ("valor"); SystemOutPrintln ("【3】" + subvalueElementGetName () + ":" + subvalueElementText ()); Elemento subdescriptElement = subelementElement ("descritor"); SystemOutPrintln ("【3】" + subdescriptElementGetName () + ":" + subdescriptElementText ()); }}}}}} catch (Exceção e) {eprintStackTrace (); }}Em seguida, execute o principal método desta classe, e o efeito do console é o seguinte:
OK, agora podemos resolver o problema de referências vazias em documentos iterativos.
Além disso, o código pode realmente ser reformado, porque a operação de retirar os elementos da criança no loop é repetitiva e pode ser melhorada pela recursão, mas a legibilidade será um pouco pior.
Se às vezes você precisar obter todas as informações de texto no XML, ou o formato XML passado por outros não é padronizado, como o nome na tag é sensível ao caso, embora o XML não seja sensível ao minúsculas, ela deve aparecer em pares. Portanto, para evitar isso, você pode simplesmente alterar todos os nomes de tags para capitalizar. O código específico é o seguinte:
public static void main (string [] args) {string str = "<? xml versão =/" 0/"Encoding =/" utf-8/"?> <módulos id =/" 123/"> <odule> Esta é a informação de texto da tag do módulo <name> oa </nome> da conferência básica </Value> System </script> </module> </modules> "; SystemUtprintln (strreplaceall ("<[^<]*>", "_")); Padrão padrão = padringcompile ("<[^<]*>"); Matcher Matchaer = PatternMatcher (STR); while (matcherfind ()) {str = strReplaceall (MatcherGroup (0), MatcherGroup (0) touppercase ()); } SystemOutPrintln (str); }Após a corrida, as renderizações são as seguintes:
2. Gere o documento XML
O DOM4J pode analisar XML e definitivamente gerará XML, e é mais fácil de usar.
Ideias de implementação:
<1> O DocumentHelper fornece um método para criar um objeto de documento;
<2> opere este objeto de documento e adicione o nó e o texto, o nome e os valores do atributo no nó;
<3> Em seguida, use o escritor XMLWriter para escrever o objeto de documento encapsulado em disco;
O código específico é o seguinte:
importar java.io.filewriter; importar javaioioException; importar javaiowriter; importar orgdom4jdocument; importar orgdom4jdocumentHelper; importar orgdom4jElement; importar orgdom4jioxmlwriter; /** * Use DOM4J para gerar documentos XML * @Author Administrator * */public class Dom4jbuildxmldemo {public void Build01 () {try {// DocumentHelper fornece um método para criar um documento do documento do documento do documento = documentHelPercreatedocument (); // Adicione o elemento de informação do nó rootElement = documentAdDelement ("módulos"); // Isso pode continuar a adicionar nós filhos ou especificar o Conteúdo RootElementsettext ("Esta é a informação de texto da tag do módulo"); Elemento elemento = rootElementAdDelement ("módulo"); Elemento nameElement = elementAdDelement ("nome"); Elemento valueElement = elementAdDelement ("valor"); Elemento DescriçãoElement = ElementAdDelement ("Descrição"); NameElementsettext ("Nome"); NameElementAddattribute ("Idioma", "Java"); // Adicionar valor de atributo Valor para o nó valueElementSettext ("value"); valueElementAddattribute ("Idioma", "C#"); DescriçãoElementsettext ("Descrição"); DescriçãoElementAddattribute ("Idioma", "SQL Server"); SystemOutPrintln (documentsxml ()); // Converta o objeto do documento diretamente em String Output Writer fileWriter = new FileWriter ("c: // modulexml"); // dom4j fornece um objeto escrito especificamente para arquivos xmlwriter xmlWriter xmlwriter = new XMLWriter (FileWriter); xmlWriterWrite (documento); xmlWriterLush (); xmlWriterClose (); SystemOutPrintln ("O documento XML foi adicionado com sucesso!"); } catch (ioexception e) {eprintStackTrace (); }} public static void main (string [] args) {dom4jbuildxmldemo demo = new Dom4jbuildxmldemo (); Demobuild01 (); }} O efeito de executar o código é o seguinte:
Em seguida, vá para a unidade C abaixo para verificar se a criação foi bem -sucedida. Aconteceu que o conteúdo no arquivo XML é o mesmo que a saída de conteúdo pelo console.
Além disso, o XML gerado acima não especifica o formato de codificação, mas o UTF-8 ainda é exibido, indicando que este é o formato de codificação padrão. Se você deseja re-especificar, pode adicionar document.setxmlencoding ("gbk"); Antes de escrever para o disco.
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.