Java XML - Guia rápido
O que é XML?
XML é uma linguagem simples baseada em texto que foi projetada para armazenar e transportar dados em formato de texto simples. Significa Extensible Markup Language. A seguir estão alguns dos recursos mais importantes do XML.
XML é uma linguagem de marcação.
XML é uma linguagem baseada em tags como HTML.
As tags XML não são predefinidas como HTML.
Você pode definir suas próprias tags, por isso é chamado de linguagem extensível.
As tags XML são projetadas para serem autodescritivas.
XML é a recomendação do W3C para armazenamento e transferência de dados.
Exemplo
<?xml version = "1.0"?>
<Class>
<Name>First</Name>
<Sections>
<Section>
<Name>A</Name>
<Students>
<Student>Rohan</Student>
<Student>Mohan</Student>
<Student>Sohan</Student>
<Student>Lalit</Student>
<Student>Vinay</Student>
</Students>
</Section>
<Section>
<Name>B</Name>
<Students>
<Student>Robert</Student>
<Student>Julie</Student>
<Student>Kalie</Student>
<Student>Michael</Student>
</Students>
</Section>
</Sections>
</Class>Vantagens
A seguir estão as vantagens que o XML oferece -
Technology agnostic- Por ser um texto simples, o XML é independente de tecnologia. Ele pode ser usado por qualquer tecnologia para fins de armazenamento e transferência de dados.
Human readable- XML usa formato de texto simples. É legível e compreensível por humanos.
Extensible - Em XML, tags personalizadas podem ser criadas e usadas com muita facilidade.
Allow Validation - Usando XSD, estruturas DTD e XML podem ser validadas facilmente.
Desvantagens
A seguir estão as desvantagens de usar XML -
Redundant Syntax - Normalmente os arquivos XML contêm muitos termos repetitivos.
Verbose - Por ser uma linguagem detalhada, o tamanho do arquivo XML aumenta os custos de transmissão e armazenamento.
Análise XML refere-se a passar por um documento XML para acessar ou modificar dados.
O que é XML Parser?
O XML Parser fornece uma maneira de acessar ou modificar dados em um documento XML. Java oferece várias opções para analisar documentos XML. A seguir estão os vários tipos de analisadores que são comumente usados para analisar documentos XML.
Dom Parser - Analisa um documento XML carregando o conteúdo completo do documento e criando sua árvore hierárquica completa na memória.
SAX Parser- Analisa um documento XML em gatilhos baseados em eventos. Não carrega o documento completo na memória.
JDOM Parser - Analisa um documento XML de maneira semelhante ao analisador DOM, mas de uma maneira mais fácil.
StAX Parser - Analisa um documento XML de maneira semelhante ao analisador SAX, mas de forma mais eficiente.
XPath Parser - Analisa um documento XML com base na expressão e é amplamente usado em conjunto com o XSLT.
DOM4J Parser- Uma biblioteca java para analisar XML, XPath e XSLT usando o Java Collections Framework. Ele fornece suporte para DOM, SAX e JAXP.
Existem APIs JAXB e XSLT disponíveis para lidar com a análise de XML de forma orientada a objetos. Elaboraremos cada analisador em detalhes nos capítulos subsequentes deste tutorial.
O Document Object Model (DOM) é uma recomendação oficial do World Wide Web Consortium (W3C). Ele define uma interface que permite que os programas acessem e atualizem o estilo, a estrutura e o conteúdo dos documentos XML. Os analisadores XML que suportam DOM implementam esta interface.
Quando usar?
Você deve usar um analisador DOM quando -
Você precisa saber muito sobre a estrutura de um documento.
Você precisa mover partes de um documento XML (você pode querer classificar certos elementos, por exemplo).
Você precisa usar as informações em um documento XML mais de uma vez.
O que você ganha?
Ao analisar um documento XML com um analisador DOM, você obtém uma estrutura em árvore que contém todos os elementos do seu documento. O DOM fornece uma variedade de funções que você pode usar para examinar o conteúdo e a estrutura do documento.
Vantagens
O DOM é uma interface comum para manipular estruturas de documentos. Um de seus objetivos de design é que o código Java escrito para um analisador compatível com DOM deve ser executado em qualquer outro analisador compatível com DOM sem ter que fazer nenhuma modificação.
Interfaces DOM
O DOM define várias interfaces Java. Aqui estão as interfaces mais comuns -
Node - O tipo de dados base do DOM.
Element - A grande maioria dos objetos com os quais você lidará são Elementos.
Attr - Representa um atributo de um elemento.
Text - O conteúdo real de um Elemento ou Atr.
Document- Representa todo o documento XML. Um objeto Document é freqüentemente referido como uma árvore DOM.
Métodos DOM comuns
Quando você está trabalhando com DOM, existem vários métodos que você usa com frequência -
Document.getDocumentElement() - Retorna o elemento raiz do documento.
Node.getFirstChild() - Retorna o primeiro filho de um determinado Nó.
Node.getLastChild() - Retorna o último filho de um determinado Nó.
Node.getNextSibling() - Esses métodos retornam o próximo irmão de um determinado Nó.
Node.getPreviousSibling() - Esses métodos retornam o irmão anterior de um determinado Nó.
Node.getAttribute(attrName) - Para um determinado Nó, retorna o atributo com o nome solicitado.
Passos para usar JDOM
A seguir estão as etapas usadas ao analisar um documento usando o JDOM Parser.
- Importe pacotes relacionados a XML.
- Crie um DocumentBuilder
- Crie um documento a partir de um arquivo ou fluxo
- Extraia o elemento raiz
- Examine os atributos
- Examine os subelementos
Importar pacotes relacionados a XML
import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.*;Crie um DocumentBuilder
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();Crie um documento a partir de um arquivo ou fluxo
StringBuilder xmlStringBuilder = new StringBuilder();
xmlStringBuilder.append("<?xml version="1.0"?>
");
ByteArrayInputStream input = new ByteArrayInputStream(
xmlStringBuilder.toString().getBytes("UTF-8"));
Document doc = builder.parse(input);Extraia o elemento raiz
Element root = document.getDocumentElement();Examine os atributos
//returns specific attribute
getAttribute("attributeName");
//returns a Map (table) of names/values
getAttributes();Examine os subelementos
//returns a list of subelements of specified name
getElementsByTagName("subelementName");
//returns a list of all child nodes
getChildNodes();Exemplo de demonstração
Aqui está o arquivo xml de entrada que precisamos analisar -
<?xml version = "1.0"?>
<class>
<student rollno = "393">
<firstname>dinkar</firstname>
<lastname>kad</lastname>
<nickname>dinkar</nickname>
<marks>85</marks>
</student>
<student rollno = "493">
<firstname>Vaneet</firstname>
<lastname>Gupta</lastname>
<nickname>vinni</nickname>
<marks>95</marks>
</student>
<student rollno = "593">
<firstname>jasvir</firstname>
<lastname>singn</lastname>
<nickname>jazz</nickname>
<marks>90</marks>
</student>
</class>DomParserDemo.java
package com.tutorialspoint.xml;
import java.io.File;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;
public class DomParserDemo {
public static void main(String[] args) {
try {
File inputFile = new File("input.txt");
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
Document doc = dBuilder.parse(inputFile);
doc.getDocumentElement().normalize();
System.out.println("Root element :" + doc.getDocumentElement().getNodeName());
NodeList nList = doc.getElementsByTagName("student");
System.out.println("----------------------------");
for (int temp = 0; temp < nList.getLength(); temp++) {
Node nNode = nList.item(temp);
System.out.println("\nCurrent Element :" + nNode.getNodeName());
if (nNode.getNodeType() == Node.ELEMENT_NODE) {
Element eElement = (Element) nNode;
System.out.println("Student roll no : "
+ eElement.getAttribute("rollno"));
System.out.println("First Name : "
+ eElement
.getElementsByTagName("firstname")
.item(0)
.getTextContent());
System.out.println("Last Name : "
+ eElement
.getElementsByTagName("lastname")
.item(0)
.getTextContent());
System.out.println("Nick Name : "
+ eElement
.getElementsByTagName("nickname")
.item(0)
.getTextContent());
System.out.println("Marks : "
+ eElement
.getElementsByTagName("marks")
.item(0)
.getTextContent());
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
Root element :class
----------------------------
Current Element :student
Student roll no : 393
First Name : dinkar
Last Name : kad
Nick Name : dinkar
Marks : 85
Current Element :student
Student roll no : 493
First Name : Vaneet
Last Name : Gupta
Nick Name : vinni
Marks : 95
Current Element :student
Student roll no : 593
First Name : jasvir
Last Name : singn
Nick Name : jazz
Marks : 90Exemplo de demonstração
Aqui está o arquivo xml de entrada que precisamos consultar -
<?xml version = "1.0"?>
<cars>
<supercars company = "Ferrari">
<carname type = "formula one">Ferarri 101</carname>
<carname type = "sports car">Ferarri 201</carname>
<carname type = "sports car">Ferarri 301</carname>
</supercars>
<supercars company = "Lamborgini">
<carname>Lamborgini 001</carname>
<carname>Lamborgini 002</carname>
<carname>Lamborgini 003</carname>
</supercars>
<luxurycars company = "Benteley">
<carname>Benteley 1</carname>
<carname>Benteley 2</carname>
<carname>Benteley 3</carname>
</luxurycars>
</cars>QueryXmlFileDemo.java
package com.tutorialspoint.xml;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;
import java.io.File;
public class QueryXmlFileDemo {
public static void main(String argv[]) {
try {
File inputFile = new File("input.txt");
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
Document doc = dBuilder.parse(inputFile);
doc.getDocumentElement().normalize();
System.out.print("Root element: ");
System.out.println(doc.getDocumentElement().getNodeName());
NodeList nList = doc.getElementsByTagName("supercars");
System.out.println("----------------------------");
for (int temp = 0; temp < nList.getLength(); temp++) {
Node nNode = nList.item(temp);
System.out.println("\nCurrent Element :");
System.out.print(nNode.getNodeName());
if (nNode.getNodeType() == Node.ELEMENT_NODE) {
Element eElement = (Element) nNode;
System.out.print("company : ");
System.out.println(eElement.getAttribute("company"));
NodeList carNameList = eElement.getElementsByTagName("carname");
for (int count = 0; count < carNameList.getLength(); count++) {
Node node1 = carNameList.item(count);
if (node1.getNodeType() == node1.ELEMENT_NODE) {
Element car = (Element) node1;
System.out.print("car name : ");
System.out.println(car.getTextContent());
System.out.print("car type : ");
System.out.println(car.getAttribute("type"));
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
Root element: cars
----------------------------
Current Element :
supercarscompany : Ferrari
car name : Ferarri 101
car type : formula one
car name : Ferarri 201
car type : sports car
car name : Ferarri 301
car type : sports car
Current Element :
supercarscompany : Lamborgini
car name : Lamborgini 001
car type :
car name : Lamborgini 002
car type :
car name : Lamborgini 003
car type :Exemplo de demonstração
Aqui está o XML que precisamos criar -
<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars>
<supercars company = "Ferrari">
<carname type = "formula one">Ferrari 101</carname>
<carname type = "sports">Ferrari 202</carname>
</supercars>
</cars>CreateXmlFileDemo.java
package com.tutorialspoint.xml;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import java.io.File;
public class CreateXmlFileDemo {
public static void main(String argv[]) {
try {
DocumentBuilderFactory dbFactory =
DocumentBuilderFactory.newInstance();
DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
Document doc = dBuilder.newDocument();
// root element
Element rootElement = doc.createElement("cars");
doc.appendChild(rootElement);
// supercars element
Element supercar = doc.createElement("supercars");
rootElement.appendChild(supercar);
// setting attribute to element
Attr attr = doc.createAttribute("company");
attr.setValue("Ferrari");
supercar.setAttributeNode(attr);
// carname element
Element carname = doc.createElement("carname");
Attr attrType = doc.createAttribute("type");
attrType.setValue("formula one");
carname.setAttributeNode(attrType);
carname.appendChild(doc.createTextNode("Ferrari 101"));
supercar.appendChild(carname);
Element carname1 = doc.createElement("carname");
Attr attrType1 = doc.createAttribute("type");
attrType1.setValue("sports");
carname1.setAttributeNode(attrType1);
carname1.appendChild(doc.createTextNode("Ferrari 202"));
supercar.appendChild(carname1);
// write the content into xml file
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
DOMSource source = new DOMSource(doc);
StreamResult result = new StreamResult(new File("C:\\cars.xml"));
transformer.transform(source, result);
// Output to console for testing
StreamResult consoleResult = new StreamResult(System.out);
transformer.transform(source, consoleResult);
} catch (Exception e) {
e.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars>
<supercars company = "Ferrari">
<carname type = "formula one">Ferrari 101</carname>
<carname type = "sports">Ferrari 202</carname>
</supercars>
</cars>Exemplo de demonstração
Aqui está o arquivo xml de entrada que precisamos modificar -
<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars>
<supercars company = "Ferrari">
<carname type = "formula one">Ferrari 101</carname>
<carname type = "sports">Ferrari 202</carname>
</supercars>
<luxurycars company = "Benteley">
<carname>Benteley 1</carname>
<carname>Benteley 2</carname>
<carname>Benteley 3</carname>
</luxurycars>
</cars>ModifyXmlFileDemo.java
package com.tutorialspoint.xml;
import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
public class ModifyXmlFileDemo {
public static void main(String argv[]) {
try {
File inputFile = new File("input.xml");
DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
Document doc = docBuilder.parse(inputFile);
Node cars = doc.getFirstChild();
Node supercar = doc.getElementsByTagName("supercars").item(0);
// update supercar attribute
NamedNodeMap attr = supercar.getAttributes();
Node nodeAttr = attr.getNamedItem("company");
nodeAttr.setTextContent("Lamborigini");
// loop the supercar child node
NodeList list = supercar.getChildNodes();
for (int temp = 0; temp < list.getLength(); temp++) {
Node node = list.item(temp);
if (node.getNodeType() == Node.ELEMENT_NODE) {
Element eElement = (Element) node;
if ("carname".equals(eElement.getNodeName())) {
if("Ferrari 101".equals(eElement.getTextContent())) {
eElement.setTextContent("Lamborigini 001");
}
if("Ferrari 202".equals(eElement.getTextContent()))
eElement.setTextContent("Lamborigini 002");
}
}
}
NodeList childNodes = cars.getChildNodes();
for(int count = 0; count < childNodes.getLength(); count++) {
Node node = childNodes.item(count);
if("luxurycars".equals(node.getNodeName()))
cars.removeChild(node);
}
// write the content on console
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
DOMSource source = new DOMSource(doc);
System.out.println("-----------Modified File-----------");
StreamResult consoleResult = new StreamResult(System.out);
transformer.transform(source, consoleResult);
} catch (Exception e) {
e.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
-----------Modified File-----------
<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars>
<supercars company = "Lamborigini">
<carname type = "formula one">Lamborigini 001</carname>
<carname type = "sports">Lamborigini 002</carname>
</supercars>
</cars>SAX (Simple API for XML) é um analisador baseado em eventos para documentos XML. Ao contrário de um analisador DOM, um analisador SAX não cria nenhuma árvore de análise. SAX é uma interface de streaming para XML, o que significa que os aplicativos que usam SAX recebem notificações de eventos sobre o documento XML que está sendo processado como um elemento e um atributo, em um momento em ordem sequencial começando no topo do documento e terminando com o fechamento do Elemento ROOT.
Lê um documento XML de cima para baixo, reconhecendo os tokens que constituem um documento XML bem formado.
Os tokens são processados na mesma ordem em que aparecem no documento.
Relata ao programa de aplicativo a natureza dos tokens que o analisador encontrou conforme eles ocorrem.
O programa de aplicativo fornece um manipulador de "evento" que deve ser registrado com o analisador.
Conforme os tokens são identificados, os métodos de retorno de chamada no manipulador são chamados com as informações relevantes.
Quando usar?
Você deve usar um analisador SAX quando -
Você pode processar o documento XML de maneira linear de cima para baixo.
O documento não está profundamente aninhado.
Você está processando um documento XML muito grande cuja árvore DOM consumiria muita memória. Implementações típicas de DOM usam dez bytes de memória para representar um byte de XML.
O problema a ser resolvido envolve apenas uma parte do documento XML.
Os dados estão disponíveis assim que são vistos pelo analisador, portanto, SAX funciona bem para um documento XML que chega por meio de um fluxo.
Desvantagens de SAX
Não temos acesso aleatório a um documento XML, pois ele é processado apenas de forma direta.
Se você precisar controlar os dados que o analisador viu ou alterar a ordem dos itens, deverá escrever o código e armazenar os dados por conta própria.
Interface ContentHandler
Essa interface especifica os métodos de retorno de chamada que o analisador SAX usa para notificar um programa de aplicativo sobre os componentes do documento XML que ele viu.
void startDocument() - Chamado no início de um documento.
void endDocument() - Chamado no final de um documento.
void startElement(String uri, String localName, String qName, Attributes atts) - Chamado no início de um elemento.
void endElement(String uri, String localName,String qName) - Chamado no final de um elemento.
void characters(char[] ch, int start, int length) - Chamado quando os dados do personagem são encontrados.
void ignorableWhitespace( char[] ch, int start, int length) - Chamado quando um DTD está presente e um espaço em branco ignorável é encontrado.
void processingInstruction(String target, String data) - Chamado quando uma instrução de processamento é reconhecida.
void setDocumentLocator(Locator locator)) - Fornece um localizador que pode ser usado para identificar posições no documento.
void skippedEntity(String name) - Chamado quando uma entidade não resolvida é encontrada.
void startPrefixMapping(String prefix, String uri) - Chamado quando um novo mapeamento de namespace é definido.
void endPrefixMapping(String prefix) - Chamado quando uma definição de namespace termina seu escopo.
Interface de atributos
Esta interface especifica métodos para processar os atributos conectados a um elemento.
int getLength() - Retorna o número de atributos.
String getQName(int index)
String getValue(int index)
String getValue(String qname)
Exemplo de demonstração
Aqui está o arquivo xml de entrada que precisamos analisar -
<?xml version = "1.0"?>
<class>
<student rollno = "393">
<firstname>dinkar</firstname>
<lastname>kad</lastname>
<nickname>dinkar</nickname>
<marks>85</marks>
</student>
<student rollno = "493">
<firstname>Vaneet</firstname>
<lastname>Gupta</lastname>
<nickname>vinni</nickname>
<marks>95</marks>
</student>
<student rollno = "593">
<firstname>jasvir</firstname>
<lastname>singn</lastname>
<nickname>jazz</nickname>
<marks>90</marks>
</student>
</class>UserHandler.java
package com.tutorialspoint.xml;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class UserHandler extends DefaultHandler {
boolean bFirstName = false;
boolean bLastName = false;
boolean bNickName = false;
boolean bMarks = false;
@Override
public void startElement(String uri,
String localName, String qName, Attributes attributes) throws SAXException {
if (qName.equalsIgnoreCase("student")) {
String rollNo = attributes.getValue("rollno");
System.out.println("Roll No : " + rollNo);
} else if (qName.equalsIgnoreCase("firstname")) {
bFirstName = true;
} else if (qName.equalsIgnoreCase("lastname")) {
bLastName = true;
} else if (qName.equalsIgnoreCase("nickname")) {
bNickName = true;
}
else if (qName.equalsIgnoreCase("marks")) {
bMarks = true;
}
}
@Override
public void endElement(String uri,
String localName, String qName) throws SAXException {
if (qName.equalsIgnoreCase("student")) {
System.out.println("End Element :" + qName);
}
}
@Override
public void characters(char ch[], int start, int length) throws SAXException {
if (bFirstName) {
System.out.println("First Name: "
+ new String(ch, start, length));
bFirstName = false;
} else if (bLastName) {
System.out.println("Last Name: " + new String(ch, start, length));
bLastName = false;
} else if (bNickName) {
System.out.println("Nick Name: " + new String(ch, start, length));
bNickName = false;
} else if (bMarks) {
System.out.println("Marks: " + new String(ch, start, length));
bMarks = false;
}
}
}SAXParserDemo.java
package com.tutorialspoint.xml;
import java.io.File;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class SAXParserDemo {
public static void main(String[] args) {
try {
File inputFile = new File("input.txt");
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser saxParser = factory.newSAXParser();
UserHandler userhandler = new UserHandler();
saxParser.parse(inputFile, userhandler);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class UserHandler extends DefaultHandler {
boolean bFirstName = false;
boolean bLastName = false;
boolean bNickName = false;
boolean bMarks = false;
@Override
public void startElement(
String uri, String localName, String qName, Attributes attributes)
throws SAXException {
if (qName.equalsIgnoreCase("student")) {
String rollNo = attributes.getValue("rollno");
System.out.println("Roll No : " + rollNo);
} else if (qName.equalsIgnoreCase("firstname")) {
bFirstName = true;
} else if (qName.equalsIgnoreCase("lastname")) {
bLastName = true;
} else if (qName.equalsIgnoreCase("nickname")) {
bNickName = true;
}
else if (qName.equalsIgnoreCase("marks")) {
bMarks = true;
}
}
@Override
public void endElement(String uri,
String localName, String qName) throws SAXException {
if (qName.equalsIgnoreCase("student")) {
System.out.println("End Element :" + qName);
}
}
@Override
public void characters(char ch[], int start, int length) throws SAXException {
if (bFirstName) {
System.out.println("First Name: " + new String(ch, start, length));
bFirstName = false;
} else if (bLastName) {
System.out.println("Last Name: " + new String(ch, start, length));
bLastName = false;
} else if (bNickName) {
System.out.println("Nick Name: " + new String(ch, start, length));
bNickName = false;
} else if (bMarks) {
System.out.println("Marks: " + new String(ch, start, length));
bMarks = false;
}
}
}Isso produziria o seguinte resultado -
Roll No : 393
First Name: dinkar
Last Name: kad
Nick Name: dinkar
Marks: 85
End Element :student
Roll No : 493
First Name: Vaneet
Last Name: Gupta
Nick Name: vinni
Marks: 95
End Element :student
Roll No : 593
First Name: jasvir
Last Name: singn
Nick Name: jazz
Marks: 90
End Element :studentExemplo de demonstração
Aqui está o arquivo de texto de entrada que precisamos consultar para rollno: 393
<?xml version = "1.0"?>
<class>
<student rollno = "393">
<firstname>dinkar</firstname>
<lastname>kad</lastname>
<nickname>dinkar</nickname>
<marks>85</marks>
</student>
<student rollno = "493">
<firstname>Vaneet</firstname>
<lastname>Gupta</lastname>
<nickname>vinni</nickname>
<marks>95</marks>
</student>
<student rollno = "593">
<firstname>jasvir</firstname>
<lastname>singn</lastname>
<nickname>jazz</nickname>
<marks>90</marks>
</student>
</class>UserHandler.java
package com.tutorialspoint.xml;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class UserHandler extends DefaultHandler {
boolean bFirstName = false;
boolean bLastName = false;
boolean bNickName = false;
boolean bMarks = false;
String rollNo = null;
@Override
public void startElement(
String uri, String localName, String qName, Attributes attributes)
throws SAXException {
if (qName.equalsIgnoreCase("student")) {
rollNo = attributes.getValue("rollno");
}
if(("393").equals(rollNo) &&
qName.equalsIgnoreCase("student")) {
System.out.println("Start Element :" + qName);
}
if (qName.equalsIgnoreCase("firstname")) {
bFirstName = true;
} else if (qName.equalsIgnoreCase("lastname")) {
bLastName = true;
} else if (qName.equalsIgnoreCase("nickname")) {
bNickName = true;
}
else if (qName.equalsIgnoreCase("marks")) {
bMarks = true;
}
}
@Override
public void endElement(
String uri, String localName, String qName) throws SAXException {
if (qName.equalsIgnoreCase("student")) {
if(("393").equals(rollNo) && qName.equalsIgnoreCase("student"))
System.out.println("End Element :" + qName);
}
}
@Override
public void characters(char ch[], int start, int length) throws SAXException {
if (bFirstName && ("393").equals(rollNo)) {
//age element, set Employee age
System.out.println("First Name: " + new String(ch, start, length));
bFirstName = false;
} else if (bLastName && ("393").equals(rollNo)) {
System.out.println("Last Name: " + new String(ch, start, length));
bLastName = false;
} else if (bNickName && ("393").equals(rollNo)) {
System.out.println("Nick Name: " + new String(ch, start, length));
bNickName = false;
} else if (bMarks && ("393").equals(rollNo)) {
System.out.println("Marks: " + new String(ch, start, length));
bMarks = false;
}
}
}SAXQueryDemo.java
package com.tutorialspoint.xml;
import java.io.File;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class SAXQueryDemo {
public static void main(String[] args) {
try {
File inputFile = new File("input.txt");
SAXParserFactory factory = SAXParserFactory.newInstance();
SAXParser saxParser = factory.newSAXParser();
UserHandler userhandler = new UserHandler();
saxParser.parse(inputFile, userhandler);
} catch (Exception e) {
e.printStackTrace();
}
}
}
class UserHandler extends DefaultHandler {
boolean bFirstName = false;
boolean bLastName = false;
boolean bNickName = false;
boolean bMarks = false;
String rollNo = null;
@Override
public void startElement(String uri,
String localName, String qName, Attributes attributes)
throws SAXException {
if (qName.equalsIgnoreCase("student")) {
rollNo = attributes.getValue("rollno");
}
if(("393").equals(rollNo) && qName.equalsIgnoreCase("student")) {
System.out.println("Start Element :" + qName);
}
if (qName.equalsIgnoreCase("firstname")) {
bFirstName = true;
} else if (qName.equalsIgnoreCase("lastname")) {
bLastName = true;
} else if (qName.equalsIgnoreCase("nickname")) {
bNickName = true;
}
else if (qName.equalsIgnoreCase("marks")) {
bMarks = true;
}
}
@Override
public void endElement(
String uri, String localName, String qName) throws SAXException {
if (qName.equalsIgnoreCase("student")) {
if(("393").equals(rollNo)
&& qName.equalsIgnoreCase("student"))
System.out.println("End Element :" + qName);
}
}
@Override
public void characters(
char ch[], int start, int length) throws SAXException {
if (bFirstName && ("393").equals(rollNo)) {
//age element, set Employee age
System.out.println("First Name: " + new String(ch, start, length));
bFirstName = false;
} else if (bLastName && ("393").equals(rollNo)) {
System.out.println("Last Name: " + new String(ch, start, length));
bLastName = false;
} else if (bNickName && ("393").equals(rollNo)) {
System.out.println("Nick Name: " + new String(ch, start, length));
bNickName = false;
} else if (bMarks && ("393").equals(rollNo)) {
System.out.println("Marks: " + new String(ch, start, length));
bMarks = false;
}
}
}Isso produziria o seguinte resultado -
Start Element :student
First Name: dinkar
Last Name: kad
Nick Name: dinkar
Marks: 85
End Element :studentIt is better to use StAX parser for creating XML documents rather than using SAX parser. Please refer the Java StAX Parser section for the same.
Exemplo de demonstração
Aqui está o arquivo XML de entrada que precisamos modificar, anexando <Result> Pass <Result /> no final da tag </marks>.
<?xml version = "1.0"?>
<class>
<student rollno = "393">
<firstname>dinkar</firstname>
<lastname>kad</lastname>
<nickname>dinkar</nickname>
<marks>85</marks>
</student>
<student rollno = "493">
<firstname>Vaneet</firstname>
<lastname>Gupta</lastname>
<nickname>vinni</nickname>
<marks>95</marks>
</student>
<student rollno = "593">
<firstname>jasvir</firstname>
<lastname>singn</lastname>
<nickname>jazz</nickname>
<marks>90</marks>
</student>
</class>SAXModifyDemo.java
package com.tutorialspoint.xml;
import java.io.*;
import org.xml.sax.*;
import javax.xml.parsers.*;
import org.xml.sax.helpers.DefaultHandler;
public class SAXModifyDemo extends DefaultHandler {
static String displayText[] = new String[1000];
static int numberLines = 0;
static String indentation = "";
public static void main(String args[]) {
try {
File inputFile = new File("input.txt");
SAXParserFactory factory =
SAXParserFactory.newInstance();
SAXModifyDemo obj = new SAXModifyDemo();
obj.childLoop(inputFile);
FileWriter filewriter = new FileWriter("newfile.xml");
for(int loopIndex = 0; loopIndex < numberLines; loopIndex++) {
filewriter.write(displayText[loopIndex].toCharArray());
filewriter.write('\n');
System.out.println(displayText[loopIndex].toString());
}
filewriter.close();
}
catch (Exception e) {
e.printStackTrace(System.err);
}
}
public void childLoop(File input) {
DefaultHandler handler = this;
SAXParserFactory factory = SAXParserFactory.newInstance();
try {
SAXParser saxParser = factory.newSAXParser();
saxParser.parse(input, handler);
} catch (Throwable t) {}
}
public void startDocument() {
displayText[numberLines] = indentation;
displayText[numberLines] += "<?xml version = \"1.0\" encoding = \""+
"UTF-8" + "\"?>";
numberLines++;
}
public void processingInstruction(String target, String data) {
displayText[numberLines] = indentation;
displayText[numberLines] += "<?";
displayText[numberLines] += target;
if (data != null && data.length() > 0) {
displayText[numberLines] += ' ';
displayText[numberLines] += data;
}
displayText[numberLines] += "?>";
numberLines++;
}
public void startElement(String uri, String localName, String qualifiedName,
Attributes attributes) {
displayText[numberLines] = indentation;
indentation += " ";
displayText[numberLines] += '<';
displayText[numberLines] += qualifiedName;
if (attributes != null) {
int numberAttributes = attributes.getLength();
for (int loopIndex = 0; loopIndex < numberAttributes; loopIndex++) {
displayText[numberLines] += ' ';
displayText[numberLines] += attributes.getQName(loopIndex);
displayText[numberLines] += "=\"";
displayText[numberLines] += attributes.getValue(loopIndex);
displayText[numberLines] += '"';
}
}
displayText[numberLines] += '>';
numberLines++;
}
public void characters(char characters[], int start, int length) {
String characterData = (new String(characters, start, length)).trim();
if(characterData.indexOf("\n") < 0 && characterData.length() > 0) {
displayText[numberLines] = indentation;
displayText[numberLines] += characterData;
numberLines++;
}
}
public void endElement(String uri, String localName, String qualifiedName) {
indentation = indentation.substring(0, indentation.length() - 4) ;
displayText[numberLines] = indentation;
displayText[numberLines] += "</";
displayText[numberLines] += qualifiedName;
displayText[numberLines] += '>';
numberLines++;
if (qualifiedName.equals("marks")) {
startElement("", "Result", "Result", null);
characters("Pass".toCharArray(), 0, "Pass".length());
endElement("", "Result", "Result");
}
}
}Isso produziria o seguinte resultado -
<?xml version = "1.0" encoding = "UTF-8"?>
<class>
<student rollno = "393">
<firstname>
dinkar
</firstname>
<lastname>
kad
</lastname>
<nickname>
dinkar
</nickname>
<marks>
85
</marks>
<Result>
Pass
</Result>
</student>
<student rollno = "493">
<firstname>
Vaneet
</firstname>
<lastname>
Gupta
</lastname>
<nickname>
vinni
</nickname>
<marks>
95
</marks>
<Result>
Pass
</Result>
</student>
<student rollno = "593">
<firstname>
jasvir
</firstname>
<lastname>
singn
</lastname>
<nickname>
jazz
</nickname>
<marks>
90
</marks>
<Result>
Pass
</Result>
</student>
</class>JDOM é uma biblioteca de código aberto baseada em Java para analisar documentos XML. Normalmente é uma API amigável do desenvolvedor Java. É otimizado para Java e usa coleções Java como List e Arrays.
JDOM funciona com APIs DOM e SAX e combina o melhor dos dois. Ele ocupa pouco espaço de memória e é quase tão rápido quanto o SAX.
Configuração de ambiente
Para usar o analisador JDOM, você deve ter jdom.jar no classpath de seu aplicativo. Baixe jdom-2.0.5.zip.
Quando usar?
Você deve usar um analisador JDOM quando -
Você precisa saber muito sobre a estrutura de um documento XML.
Você precisa mover partes de um documento XMl (você pode querer classificar certos elementos, por exemplo).
Você precisa usar as informações em um documento XML mais de uma vez.
Você é um desenvolvedor Java e deseja aproveitar a análise otimizada Java de XML.
O que você ganha?
Ao analisar um documento XML com um analisador JDOM, você obtém a flexibilidade de obter de volta uma estrutura em árvore que contém todos os elementos de seu documento sem afetar a área de cobertura da memória do aplicativo.
O JDOM fornece uma variedade de funções utilitárias que você pode usar para examinar o conteúdo e a estrutura de um documento XML, caso o documento seja bem estruturado e sua estrutura seja conhecida.
Vantagens
JDOM fornece aos desenvolvedores Java a flexibilidade e facilidade de manutenção do código de análise XML. É uma API leve e rápida.
Aulas JDOM
JDOM define várias classes Java. Aqui estão as classes mais comuns -
Document- Representa um documento XML inteiro. Um objeto Document é freqüentemente referido como uma árvore DOM.
Element- Representa um elemento XML. O objeto Element possui métodos para manipular seus elementos filho, seu texto, atributos e namespaces.
Attribute- Representa um atributo de um elemento. O atributo tem um método para obter e definir o valor do atributo. Tem pai e tipo de atributo.
Text - Representa o texto da tag XML.
Comment - Representa os comentários em um documento XML.
Métodos JDOM comuns
Quando você está trabalhando com JDOM, existem vários métodos que você usa com frequência -
SAXBuilder.build(xmlSource)() - Construa o documento JDOM a partir do código-fonte xml.
Document.getRootElement() - Obtenha o elemento raiz do XML.
Element.getName() - Obtenha o nome do nó XML.
Element.getChildren() - Obtenha todos os nós filhos diretos de um elemento.
Node.getChildren(Name) - Obtenha todos os nós filhos diretos com um determinado nome.
Node.getChild(Name) - Obtenha o primeiro nó filho com o nome fornecido.
Passos para usar JDOM
A seguir estão as etapas usadas ao analisar um documento usando o JDOM Parser.
- Importe pacotes relacionados a XML.
- Crie um SAXBuilder
- Crie um documento a partir de um arquivo ou fluxo
- Extraia o elemento raiz
- Examine os atributos
- Examine os subelementos
Importar pacotes relacionados a XML
import java.io.*;
import java.util.*;
import org.jdom2.*;Crie um DocumentBuilder
SAXBuilder saxBuilder = new SAXBuilder();Crie um documento a partir de um arquivo ou fluxo
File inputFile = new File("input.txt");
SAXBuilder saxBuilder = new SAXBuilder();
Document document = saxBuilder.build(inputFile);Extraia o elemento raiz
Element classElement = document.getRootElement();Examine os atributos
//returns specific attribute
getAttribute("attributeName");Examine os subelementos
//returns a list of subelements of specified name
getChildren("subelementName");
//returns a list of all child nodes
getChildren();
//returns first child node
getChild("subelementName");Exemplo de demonstração
Aqui está o arquivo xml de entrada que precisamos analisar -
<?xml version = "1.0"?>
<class>
<student rollno = "393">
<firstname>dinkar</firstname>
<lastname>kad</lastname>
<nickname>dinkar</nickname>
<marks>85</marks>
</student>
<student rollno = "493">
<firstname>Vaneet</firstname>
<lastname>Gupta</lastname>
<nickname>vinni</nickname>
<marks>95</marks>
</student>
<student rollno = "593">
<firstname>jasvir</firstname>
<lastname>singn</lastname>
<nickname>jazz</nickname>
<marks>90</marks>
</student>
</class>DomParserDemo.java
import java.io.File;
import java.io.IOException;
import java.util.List;
import org.jdom2.Attribute;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
public class JDomParserDemo {
public static void main(String[] args) {
try {
File inputFile = new File("input.txt");
SAXBuilder saxBuilder = new SAXBuilder();
Document document = saxBuilder.build(inputFile);
System.out.println("Root element :" + document.getRootElement().getName());
Element classElement = document.getRootElement();
List<Element> studentList = classElement.getChildren();
System.out.println("----------------------------");
for (int temp = 0; temp < studentList.size(); temp++) {
Element student = studentList.get(temp);
System.out.println("\nCurrent Element :"
+ student.getName());
Attribute attribute = student.getAttribute("rollno");
System.out.println("Student roll no : "
+ attribute.getValue() );
System.out.println("First Name : "
+ student.getChild("firstname").getText());
System.out.println("Last Name : "
+ student.getChild("lastname").getText());
System.out.println("Nick Name : "
+ student.getChild("nickname").getText());
System.out.println("Marks : "
+ student.getChild("marks").getText());
}
} catch(JDOMException e) {
e.printStackTrace();
} catch(IOException ioe) {
ioe.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
Root element :class
----------------------------
Current Element :student
Student roll no : 393
First Name : dinkar
Last Name : kad
Nick Name : dinkar
Marks : 85
Current Element :student
Student roll no : 493
First Name : Vaneet
Last Name : Gupta
Nick Name : vinni
Marks : 95
Current Element :student
Student roll no : 593
First Name : jasvir
Last Name : singn
Nick Name : jazz
Marks : 90Exemplo de demonstração
Aqui está o arquivo xml de entrada que precisamos consultar -
<?xml version = "1.0"?>
<cars>
<supercars company = "Ferrari">
<carname type = "formula one">Ferarri 101</carname>
<carname type = "sports car">Ferarri 201</carname>
<carname type = "sports car">Ferarri 301</carname>
</supercars>
<supercars company = "Lamborgini">
<carname>Lamborgini 001</carname>
<carname>Lamborgini 002</carname>
<carname>Lamborgini 003</carname>
</supercars>
<luxurycars company = "Benteley">
<carname>Benteley 1</carname>
<carname>Benteley 2</carname>
<carname>Benteley 3</carname>
</luxurycars>
</cars>QueryXmlFileDemo.java
import java.io.File;
import java.io.IOException;
import java.util.List;
import org.jdom2.Attribute;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
public class QueryXmlFileDemo {
public static void main(String[] args) {
try {
File inputFile = new File("input.txt");
SAXBuilder saxBuilder = new SAXBuilder();
Document document = saxBuilder.build(inputFile);
System.out.println("Root element :" + document.getRootElement().getName());
Element classElement = document.getRootElement();
List<Element> supercarList = classElement.getChildren("supercars");
System.out.println("----------------------------");
for (int temp = 0; temp < supercarList.size(); temp++) {
Element supercarElement = supercarList.get(temp);
System.out.println("\nCurrent Element :" + supercarElement.getName());
Attribute attribute = supercarElement.getAttribute("company");
System.out.println("company : " + attribute.getValue() );
List<Element> carNameList = supercarElement.getChildren("carname");
for (int count = 0; count < carNameList.size(); count++) {
Element carElement = carNameList.get(count);
System.out.print("car name : ");
System.out.println(carElement.getText());
System.out.print("car type : ");
Attribute typeAttribute = carElement.getAttribute("type");
if(typeAttribute != null)
System.out.println(typeAttribute.getValue());
else {
System.out.println("");
}
}
}
} catch(JDOMException e) {
e.printStackTrace();
} catch(IOException ioe) {
ioe.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
Root element :cars
----------------------------
Current Element :supercars
company : Ferrari
car name : Ferarri 101
car type : formula one
car name : Ferarri 201
car type : sports car
car name : Ferarri 301
car type : sports car
Current Element :supercars
company : Lamborgini
car name : Lamborgini 001
car type :
car name : Lamborgini 002
car type :
car name : Lamborgini 003
car type :Exemplo de demonstração
Aqui está o arquivo XML que precisamos criar -
<?xml version = "1.0" encoding = "UTF-8"?>
<cars>
<supercars company = "Ferrari">
<carname type = "formula one">Ferrari 101</carname>
<carname type = "sports">Ferrari 202</carname>
</supercars>
</cars>CreateXmlFileDemo.java
import java.io.IOException;
import org.jdom2.Attribute;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;
public class CreateXmlFileDemo {
public static void main(String[] args) {
try{
//root element
Element carsElement = new Element("cars");
Document doc = new Document(carsElement);
//supercars element
Element supercarElement = new Element("supercars");
supercarElement.setAttribute(new Attribute("company","Ferrari"));
//supercars element
Element carElement1 = new Element("carname");
carElement1.setAttribute(new Attribute("type","formula one"));
carElement1.setText("Ferrari 101");
Element carElement2 = new Element("carname");
carElement2.setAttribute(new Attribute("type","sports"));
carElement2.setText("Ferrari 202");
supercarElement.addContent(carElement1);
supercarElement.addContent(carElement2);
doc.getRootElement().addContent(supercarElement);
XMLOutputter xmlOutput = new XMLOutputter();
// display ml
xmlOutput.setFormat(Format.getPrettyFormat());
xmlOutput.output(doc, System.out);
} catch(IOException e) {
e.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
<?xml version = "1.0" encoding = "UTF-8"?>
<cars>
<supercars company = "Ferrari">
<carname type = "formula one">Ferrari 101</carname>
<carname type = "sports">Ferrari 202</carname>
</supercars>
</cars>Exemplo de demonstração
Aqui está o arquivo de texto de entrada que precisamos modificar -
<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars>
<supercars company = "Ferrari">
<carname type = "formula one">Ferrari 101</carname>
<carname type = "sports">Ferrari 202</carname>
</supercars>
<luxurycars company = "Benteley">
<carname>Benteley 1</carname>
<carname>Benteley 2</carname>
<carname>Benteley 3</carname>
</luxurycars>
</cars>ModifyXmlFileDemo.java
import java.io.File;
import java.io.IOException;
import java.util.List;
import org.jdom2.Attribute;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;
public class ModifyXMLFileDemo {
public static void main(String[] args) {
try {
File inputFile = new File("input.txt");
SAXBuilder saxBuilder = new SAXBuilder();
Document document = saxBuilder.build(inputFile);
Element rootElement = document.getRootElement();
//get first supercar
Element supercarElement = rootElement.getChild("supercars");
// update supercar attribute
Attribute attribute = supercarElement.getAttribute("company");
attribute.setValue("Lamborigini");
// loop the supercar child node
List<Element> list = supercarElement.getChildren();
for (int temp = 0; temp < list.size(); temp++) {
Element carElement = list.get(temp);
if("Ferrari 101".equals(carElement.getText())) {
carElement.setText("Lamborigini 001");
}
if("Ferrari 202".equals(carElement.getText())) {
carElement.setText("Lamborigini 002");
}
}
//get all supercars element
List<Element> supercarslist = rootElement.getChildren();
for (int temp = 0; temp < supercarslist.size(); temp++) {
Element tempElement = supercarslist.get(temp);
if("luxurycars".equals(tempElement.getName())) {
rootElement.removeContent(tempElement);
}
}
XMLOutputter xmlOutput = new XMLOutputter();
// display xml
xmlOutput.setFormat(Format.getPrettyFormat());
xmlOutput.output(document, System.out);
} catch (JDOMException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
<?xml version = "1.0" encoding = "UTF-8"?>
<cars>
<supercars company = "Lamborigini">
<carname type = "formula one">Lamborigini 001</carname>
<carname type = "sports">Lamborigini 002</carname>
</supercars>
</cars>StAX é uma API baseada em Java para analisar documentos XML de forma semelhante ao analisador SAX. Mas existem duas diferenças principais entre as duas APIs -
StAX é uma API PULL, enquanto SAX é uma API PUSH. Isso significa que no caso do analisador StAX, um aplicativo cliente precisa solicitar ao analisador StAX para obter informações do XML sempre que necessário. Mas, no caso do analisador SAX, um aplicativo cliente é necessário para obter informações quando o analisador SAX notifica o aplicativo cliente de que as informações estão disponíveis.
StAX API pode ler e escrever documentos XML. Usando SAX API, um arquivo XML só pode ser lido.
Configuração de ambiente
Para usar o analisador StAX, você deve ter stax.jar no classpath de seu aplicativo.
A seguir estão os recursos da API StAX -
Lê um documento XML de cima para baixo, reconhecendo os tokens que constituem um documento XML bem formado.
Os tokens são processados na mesma ordem em que aparecem no documento.
Relata ao programa de aplicativo a natureza dos tokens que o analisador encontrou conforme eles ocorrem.
O programa de aplicação fornece um leitor de "evento" que atua como um iterador e itera sobre o evento para obter as informações necessárias. Outro leitor disponível é o "cursor" que atua como um ponteiro para os nós XML.
Conforme os eventos são identificados, os elementos XML podem ser recuperados do objeto de evento e podem ser processados posteriormente.
Quando usar?
Você deve usar um analisador StAX quando -
Você pode processar o documento XML de maneira linear de cima para baixo.
O documento não está profundamente aninhado.
Você está processando um documento XML muito grande cuja árvore DOM consumiria muita memória. Implementações típicas de DOM usam dez bytes de memória para representar um byte de XML.
O problema a ser resolvido envolve apenas uma parte do documento XML.
Os dados estão disponíveis assim que são vistos pelo analisador, portanto, StAX funciona bem para um documento XML que chega por meio de um fluxo.
Desvantagens de SAX
Não temos acesso aleatório a um documento XML, uma vez que ele é processado somente de encaminhamento.
Se você precisa acompanhar os dados que o analisador viu ou onde o analisador alterou a ordem dos itens, você deve escrever o código e armazenar os dados por conta própria.
Classe XMLEventReader
Esta classe fornece iterador de eventos que pode ser usado para iterar sobre eventos conforme eles ocorrem durante a análise de um documento XML.
StartElement asStartElement() - Usado para recuperar o valor e os atributos de um elemento.
EndElement asEndElement() - Chamado no final de um elemento.
Characters asCharacters() - Pode ser usado para obter caracteres como CDATA, espaço em branco, etc.
Classe XMLEventWriter
Esta interface especifica métodos para criar um evento.
add(Event event) - Adicionar eventos contendo elementos ao XML.
Classe XMLStreamReader
Esta classe fornece iterador de eventos que pode ser usado para iterar sobre eventos conforme eles ocorrem durante a análise de um documento XML.
int next() - Usado para recuperar o próximo evento.
boolean hasNext() - Usado para verificar se outros eventos existem ou não.
String getText() - Usado para obter o texto de um elemento.
String getLocalName() - Usado para obter o nome de um elemento.
Classe XMLStreamWriter
Esta interface especifica métodos para criar um evento.
writeStartElement(String localName) - Adicione um elemento inicial do nome fornecido.
writeEndElement(String localName) - Adicione um elemento final do nome fornecido.
writeAttribute(String localName, String value) - Grave atributos em um elemento.
Exemplo de demonstração
Aqui está o arquivo xml de entrada que precisamos analisar -
<?xml version = "1.0"?>
<class>
<student rollno = "393">
<firstname>dinkar</firstname>
<lastname>kad</lastname>
<nickname>dinkar</nickname>
<marks>85</marks>
</student>
<student rollno = "493">
<firstname>Vaneet</firstname>
<lastname>Gupta</lastname>
<nickname>vinni</nickname>
<marks>95</marks>
</student>
<student rollno = "593">
<firstname>jasvir</firstname>
<lastname>singn</lastname>
<nickname>jazz</nickname>
<marks>90</marks>
</student>
</class>StAXParserDemo.java
package com.tutorialspoint.xml;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Iterator;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.Characters;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;
public class StAXParserDemo {
public static void main(String[] args) {
boolean bFirstName = false;
boolean bLastName = false;
boolean bNickName = false;
boolean bMarks = false;
try {
XMLInputFactory factory = XMLInputFactory.newInstance();
XMLEventReader eventReader =
factory.createXMLEventReader(new FileReader("input.txt"));
while(eventReader.hasNext()) {
XMLEvent event = eventReader.nextEvent();
switch(event.getEventType()) {
case XMLStreamConstants.START_ELEMENT:
StartElement startElement = event.asStartElement();
String qName = startElement.getName().getLocalPart();
if (qName.equalsIgnoreCase("student")) {
System.out.println("Start Element : student");
Iterator<Attribute> attributes = startElement.getAttributes();
String rollNo = attributes.next().getValue();
System.out.println("Roll No : " + rollNo);
} else if (qName.equalsIgnoreCase("firstname")) {
bFirstName = true;
} else if (qName.equalsIgnoreCase("lastname")) {
bLastName = true;
} else if (qName.equalsIgnoreCase("nickname")) {
bNickName = true;
}
else if (qName.equalsIgnoreCase("marks")) {
bMarks = true;
}
break;
case XMLStreamConstants.CHARACTERS:
Characters characters = event.asCharacters();
if(bFirstName) {
System.out.println("First Name: " + characters.getData());
bFirstName = false;
}
if(bLastName) {
System.out.println("Last Name: " + characters.getData());
bLastName = false;
}
if(bNickName) {
System.out.println("Nick Name: " + characters.getData());
bNickName = false;
}
if(bMarks) {
System.out.println("Marks: " + characters.getData());
bMarks = false;
}
break;
case XMLStreamConstants.END_ELEMENT:
EndElement endElement = event.asEndElement();
if(endElement.getName().getLocalPart().equalsIgnoreCase("student")) {
System.out.println("End Element : student");
System.out.println();
}
break;
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (XMLStreamException e) {
e.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
Start Element : student
Roll No : 393
First Name: dinkar
Last Name: kad
Nick Name: dinkar
Marks: 85
End Element : student
Start Element : student
Roll No : 493
First Name: Vaneet
Last Name: Gupta
Nick Name: vinni
Marks: 95
End Element : student
Start Element : student
Roll No : 593
First Name: jasvir
Last Name: singn
Nick Name: jazz
Marks: 90
End Element : studentExemplo de demonstração
Aqui está o arquivo xml de entrada que precisamos analisar -
<?xml version = "1.0"?>
<class>
<student rollno = "393">
<firstname>dinkar</firstname>
<lastname>kad</lastname>
<nickname>dinkar</nickname>
<marks>85</marks>
</student>
<student rollno = "493">
<firstname>Vaneet</firstname>
<lastname>Gupta</lastname>
<nickname>vinni</nickname>
<marks>95</marks>
</student>
<student rollno = "593">
<firstname>jasvir</firstname>
<lastname>singn</lastname>
<nickname>jazz</nickname>
<marks>90</marks>
</student>
</class>StAXParserDemo.java
package com.tutorialspoint.xml;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Iterator;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.Characters;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;
public class StAXQueryDemo {
public static void main(String[] args) {
boolean bFirstName = false;
boolean bLastName = false;
boolean bNickName = false;
boolean bMarks = false;
boolean isRequestRollNo = false;
try {
XMLInputFactory factory = XMLInputFactory.newInstance();
XMLEventReader eventReader =
factory.createXMLEventReader(new FileReader("input.txt"));
String requestedRollNo = "393";
while(eventReader.hasNext()) {
XMLEvent event = eventReader.nextEvent();
switch(event.getEventType()) {
case XMLStreamConstants.START_ELEMENT:
StartElement startElement = event.asStartElement();
String qName = startElement.getName().getLocalPart();
if (qName.equalsIgnoreCase("student")) {
Iterator<Attribute> attributes = startElement.getAttributes();
String rollNo = attributes.next().getValue();
if(rollNo.equalsIgnoreCase(requestedRollNo)) {
System.out.println("Start Element : student");
System.out.println("Roll No : " + rollNo);
isRequestRollNo = true;
}
} else if (qName.equalsIgnoreCase("firstname")) {
bFirstName = true;
} else if (qName.equalsIgnoreCase("lastname")) {
bLastName = true;
} else if (qName.equalsIgnoreCase("nickname")) {
bNickName = true;
}
else if (qName.equalsIgnoreCase("marks")) {
bMarks = true;
}
break;
case XMLStreamConstants.CHARACTERS:
Characters characters = event.asCharacters();
if(bFirstName && isRequestRollNo) {
System.out.println("First Name: " + characters.getData());
bFirstName = false;
}
if(bLastName && isRequestRollNo) {
System.out.println("Last Name: " + characters.getData());
bLastName = false;
}
if(bNickName && isRequestRollNo) {
System.out.println("Nick Name: " + characters.getData());
bNickName = false;
}
if(bMarks && isRequestRollNo) {
System.out.println("Marks: " + characters.getData());
bMarks = false;
}
break;
case XMLStreamConstants.END_ELEMENT:
EndElement endElement = event.asEndElement();
if(endElement.getName().getLocalPart().equalsIgnoreCase(
"student") && isRequestRollNo) {
System.out.println("End Element : student");
System.out.println();
isRequestRollNo = false;
}
break;
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (XMLStreamException e) {
e.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
Start Element : student
Roll No : 393
First Name: dinkar
Last Name: kad
Nick Name: dinkar
Marks: 85
End Element : studentExemplo de demonstração
Aqui está o XML que precisamos criar -
<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars>
<supercars company = "Ferrari">
<carname type = "formula one">Ferrari 101</carname>
<carname type = "sports">Ferrari 202</carname>
</supercars>
</cars>StAXCreateXMLDemo.java
package com.tutorialspoint.xml;
import java.io.IOException;
import java.io.StringWriter;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;
public class StAXCreateXMLDemo {
public static void main(String[] args) {
try {
StringWriter stringWriter = new StringWriter();
XMLOutputFactory xMLOutputFactory = XMLOutputFactory.newInstance();
XMLStreamWriter xMLStreamWriter =
xMLOutputFactory.createXMLStreamWriter(stringWriter);
xMLStreamWriter.writeStartDocument();
xMLStreamWriter.writeStartElement("cars");
xMLStreamWriter.writeStartElement("supercars");
xMLStreamWriter.writeAttribute("company", "Ferrari");
xMLStreamWriter.writeStartElement("carname");
xMLStreamWriter.writeAttribute("type", "formula one");
xMLStreamWriter.writeCharacters("Ferrari 101");
xMLStreamWriter.writeEndElement();
xMLStreamWriter.writeStartElement("carname");
xMLStreamWriter.writeAttribute("type", "sports");
xMLStreamWriter.writeCharacters("Ferrari 202");
xMLStreamWriter.writeEndElement();
xMLStreamWriter.writeEndElement();
xMLStreamWriter.writeEndDocument();
xMLStreamWriter.flush();
xMLStreamWriter.close();
String xmlString = stringWriter.getBuffer().toString();
stringWriter.close();
System.out.println(xmlString);
} catch (XMLStreamException e) {
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars>
<supercars company = "Ferrari">
<carname type = "formula one">Ferrari 101</carname>
<carname type = "sports">Ferrari 202</carname>
</supercars>
</cars>Exemplo de demonstração
Aqui está o XML que precisamos modificar -
<?xml version = "1.0"?>
<class>
<student rollno = "393">
<firstname>dinkar</firstname>
<lastname>kad</lastname>
<nickname>dinkar</nickname>
<marks>85</marks>
</student>
<student rollno = "493">
<firstname>Vaneet</firstname>
<lastname>Gupta</lastname>
<nickname>vinni</nickname>
<marks>95</marks>
</student>
<student rollno = "593">
<firstname>jasvir</firstname>
<lastname>singh</lastname>
<nickname>jazz</nickname>
<marks>90</marks>
</student>
</class>StAXModifyDemo.java
package com.tutorialspoint.xml;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;
public class StAXModifyDemo {
public static void main(String[] args) {
try {
XMLInputFactory factory = XMLInputFactory.newInstance();
XMLEventReader eventReader = factory.createXMLEventReader(
new FileReader("input.txt"));
SAXBuilder saxBuilder = new SAXBuilder();
Document document = saxBuilder.build(new File("input.txt"));
Element rootElement = document.getRootElement();
List<Element> studentElements = rootElement.getChildren("student");
while(eventReader.hasNext()) {
XMLEvent event = eventReader.nextEvent();
switch(event.getEventType()) {
case XMLStreamConstants.START_ELEMENT:
StartElement startElement = event.asStartElement();
String qName = startElement.getName().getLocalPart();
if (qName.equalsIgnoreCase("student")) {
Iterator<Attribute> attributes = startElement.getAttributes();
String rollNo = attributes.next().getValue();
if(rollNo.equalsIgnoreCase("393")) {
//get the student with roll no 393
for(int i = 0;i < studentElements.size();i++) {
Element studentElement = studentElements.get(i);
if(studentElement.getAttribute(
"rollno").getValue().equalsIgnoreCase("393")) {
studentElement.removeChild("marks");
studentElement.addContent(new Element("marks").setText("80"));
}
}
}
}
break;
}
}
XMLOutputter xmlOutput = new XMLOutputter();
// display xml
xmlOutput.setFormat(Format.getPrettyFormat());
xmlOutput.output(document, System.out);
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (XMLStreamException e) {
e.printStackTrace();
} catch (JDOMException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
<?xml version = "1.0" encoding = "UTF-8"?>
<student rollno = "393">
<firstname>dinkar</firstname>
<lastname>kad</lastname>
<nickname>dinkar</nickname>
<marks>80</marks>
</student>
<student rollno = "493">
<firstname>Vaneet</firstname>
<lastname>Gupta</lastname>
<nickname>vinni</nickname>
<marks>95</marks>
</student>
<student rollno = "593">
<firstname>jasvir</firstname>
<lastname>singh</lastname>
<nickname>jazz</nickname>
<marks>90</marks>
</student>XPath é uma recomendação oficial do World Wide Web Consortium (W3C). Ele define um idioma para localizar informações em um arquivo XML. É usado para percorrer elementos e atributos de um documento XML. XPath fornece vários tipos de expressões que podem ser usadas para consultar informações relevantes do documento XML.
O que é XPath?
Structure Definations - XPath define as partes de um documento XML como elemento, atributo, texto, namespace, instrução de processamento, comentário e nós de documento.
Path Expressions - XPath fornece expressões de caminho poderosas, como nós selecionados ou lista de nós em documentos XML.
Standard Functions - XPath fornece uma rica biblioteca de funções padrão para manipulação de valores de string, valores numéricos, comparação de data e hora, manipulação de nó e QName, manipulação de sequência, valores booleanos, etc.
Major part of XSLT - XPath é um dos principais elementos do padrão XSLT e deve-se ter conhecimento suficiente do XPath para trabalhar com documentos XSLT.
W3C recommendation - XPath é a recomendação oficial do World Wide Web Consortium (W3C).
Expressões XPath
XPath usa uma expressão de caminho para selecionar o nó ou lista de nós de um documento XML. A seguir está uma lista de caminhos e expressões úteis para selecionar qualquer nó / lista de nós de um documento XML.
| Sr. Não. | Expressão e Descrição |
|---|---|
| 1 | node-name Selecione todos os nós com o nome "nodename" fornecido |
| 2 | / A seleção começa a partir do nó raiz |
| 3 | // A seleção começa a partir do nó atual que corresponde à seleção |
| 4 | . Seleciona o nó atual |
| 5 | .. Seleciona o pai do nó atual |
| 6 | @ Seleciona atributos |
| 7 | student Example - Seleciona todos os nós com o nome "aluno" |
| 8 | class/student Example - Seleciona todos os elementos do aluno que são filhos da classe |
| 9 | //student Seleciona todos os elementos do aluno, não importa onde eles estejam no documento |
Predicados
Os predicados são usados para encontrar um nó específico ou um nó que contém um valor específico e são definidos usando [...].
| Expressão | Resultado |
|---|---|
| / class / student [1] | Seleciona o primeiro elemento de aluno que é filho do elemento de classe. |
| / classe / aluno [último ()] | Seleciona o último elemento de aluno que é filho do elemento de classe. |
| / classe / aluno [último () - 1] | Seleciona o último, exceto um elemento de aluno que é filho do elemento de classe. |
| // aluno [@rollno = '493'] | Seleciona todos os elementos do aluno que possuem um atributo chamado rollno com um valor de '493' |
Etapas para usar XPath
A seguir estão as etapas usadas ao analisar um documento usando o XPath Parser.
Importe pacotes relacionados a XML.
Crie um DocumentBuilder.
Crie um documento a partir de um arquivo ou fluxo.
Crie um objeto Xpath e uma expressão de caminho XPath.
Compile a expressão XPath usando XPath.compile() e obter uma lista de nós avaliando a expressão compilada via XPath.evaluate().
Repita a lista de nós.
Examine os atributos.
Examine os subelementos.
Importar pacotes relacionados a XML
import org.w3c.dom.*;
import org.xml.sax.*;
import javax.xml.parsers.*;
import javax.xml.xpath.*;
import java.io.*;Crie um DocumentBuilder
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();Crie um documento a partir de um arquivo ou fluxo
StringBuilder xmlStringBuilder = new StringBuilder();
xmlStringBuilder.append("<?xml version = "1.0"?> <class> </class>");
ByteArrayInputStream input = new ByteArrayInputStream(
xmlStringBuilder.toString().getBytes("UTF-8"));
Document doc = builder.parse(input);Build XPath
XPath xPath = XPathFactory.newInstance().newXPath();Prepare a expressão do caminho e avalie-a
String expression = "/class/student";
NodeList nodeList = (NodeList) xPath.compile(expression).evaluate(
doc, XPathConstants.NODESET);Iterar sobre NodeList
for (int i = 0; i < nodeList.getLength(); i++) {
Node nNode = nodeList.item(i);
...
}Examine os atributos
//returns specific attribute
getAttribute("attributeName");
//returns a Map (table) of names/values
getAttributes();Examine os subelementos
//returns a list of subelements of specified name
getElementsByTagName("subelementName");
//returns a list of all child nodes
getChildNodes();Exemplo de demonstração
Aqui está o arquivo de texto de entrada que precisamos analisar -
<?xml version = "1.0"?>
<class>
<student rollno = "393">
<firstname>dinkar</firstname>
<lastname>kad</lastname>
<nickname>dinkar</nickname>
<marks>85</marks>
</student>
<student rollno = "493">
<firstname>Vaneet</firstname>
<lastname>Gupta</lastname>
<nickname>vinni</nickname>
<marks>95</marks>
</student>
<student rollno = "593">
<firstname>jasvir</firstname>
<lastname>singh</lastname>
<nickname>jazz</nickname>
<marks>90</marks>
</student>
</class>XPathParserDemo.java
package com.tutorialspoint.xml;
import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;
import org.xml.sax.SAXException;
public class XPathParserDemo {
public static void main(String[] args) {
try {
File inputFile = new File("input.txt");
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder dBuilder;
dBuilder = dbFactory.newDocumentBuilder();
Document doc = dBuilder.parse(inputFile);
doc.getDocumentElement().normalize();
XPath xPath = XPathFactory.newInstance().newXPath();
String expression = "/class/student";
NodeList nodeList = (NodeList) xPath.compile(expression).evaluate(
doc, XPathConstants.NODESET);
for (int i = 0; i < nodeList.getLength(); i++) {
Node nNode = nodeList.item(i);
System.out.println("\nCurrent Element :" + nNode.getNodeName());
if (nNode.getNodeType() == Node.ELEMENT_NODE) {
Element eElement = (Element) nNode;
System.out.println("Student roll no :" + eElement.getAttribute("rollno"));
System.out.println("First Name : "
+ eElement
.getElementsByTagName("firstname")
.item(0)
.getTextContent());
System.out.println("Last Name : "
+ eElement
.getElementsByTagName("lastname")
.item(0)
.getTextContent());
System.out.println("Nick Name : "
+ eElement
.getElementsByTagName("nickname")
.item(0)
.getTextContent());
System.out.println("Marks : "
+ eElement
.getElementsByTagName("marks")
.item(0)
.getTextContent());
}
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (XPathExpressionException e) {
e.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
Current Element :student
Student roll no : 393
First Name : dinkar
Last Name : kad
Nick Name : dinkar
Marks : 85
Current Element :student
Student roll no : 493
First Name : Vaneet
Last Name : Gupta
Nick Name : vinni
Marks : 95
Current Element :student
Student roll no : 593
First Name : jasvir
Last Name : singh
Nick Name : jazz
Marks : 90Exemplo de demonstração
Aqui está o arquivo de texto de entrada que precisamos consultar -
<?xml version = "1.0"?>
<class>
<student rollno = "393">
<firstname>dinkar</firstname>
<lastname>kad</lastname>
<nickname>dinkar</nickname>
<marks>85</marks>
</student>
<student rollno = "493">
<firstname>Vaneet</firstname>
<lastname>Gupta</lastname>
<nickname>vinni</nickname>
<marks>95</marks>
</student>
<student rollno = "593">
<firstname>jasvir</firstname>
<lastname>singn</lastname>
<nickname>jazz</nickname>
<marks>90</marks>
</student>
</class>XPathParserDemo.java
package com.tutorialspoint.xml;
import java.io.File;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;
import org.xml.sax.SAXException;
public class XPathParserDemo {
public static void main(String[] args) {
try {
File inputFile = new File("input.txt");
DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder dBuilder;
dBuilder = dbFactory.newDocumentBuilder();
Document doc = dBuilder.parse(inputFile);
doc.getDocumentElement().normalize();
XPath xPath = XPathFactory.newInstance().newXPath();
String expression = "/class/student[@rollno = '493']";
NodeList nodeList = (NodeList) xPath.compile(expression).evaluate(
doc, XPathConstants.NODESET);
for (int i = 0; i < nodeList.getLength(); i++) {
Node nNode = nodeList.item(i);
System.out.println("\nCurrent Element :" + nNode.getNodeName());
if (nNode.getNodeType() == Node.ELEMENT_NODE) {
Element eElement = (Element) nNode;
System.out.println("Student roll no : "
+ eElement.getAttribute("rollno"));
System.out.println("First Name : "
+ eElement
.getElementsByTagName("firstname")
.item(0)
.getTextContent());
System.out.println("Last Name : "
+ eElement
.getElementsByTagName("lastname")
.item(0)
.getTextContent());
System.out.println("Nick Name : "
+ eElement
.getElementsByTagName("nickname")
.item(0)
.getTextContent());
System.out.println("Marks : "
+ eElement
.getElementsByTagName("marks")
.item(0)
.getTextContent());
}
}
} catch (ParserConfigurationException e) {
e.printStackTrace();
} catch (SAXException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (XPathExpressionException e) {
e.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
Current Element :student
Student roll no : 493
First Name : Vaneet
Last Name : Gupta
Nick Name : vinni
Marks : 95XPath parser is used to navigate XML Documents only. It is better to use DOM parser for creating XML. Please refer the Java DOM Parser section for the same.
XPath parser is used to navigate XML Documents only. It is better to use DOM parser for modifying XML. Please refer the Java DOM Parser section for the same.
DOM4J é uma biblioteca de código aberto baseada em Java para analisar documentos XML. É uma API altamente flexível e com uso eficiente de memória. É otimizado para Java e usa coleções Java como List e Arrays.
DOM4J funciona com DOM, SAX, XPath e XSLT. Ele pode analisar grandes documentos XML com uma pegada de memória muito baixa.
Configuração de ambiente
Para usar o analisador DOM4J, você deve ter dom4j-1.6.1.jar e jaxen.jar no classpath de seu aplicativo. Baixe dom4j-1.6.1.zip.
Quando usar?
Você deve usar um analisador DOM4J quando -
Você precisa saber muito sobre a estrutura de um documento XML.
Você precisa mover partes de um documento XML (você pode querer classificar certos elementos, por exemplo).
Você precisa usar as informações em um documento XML mais de uma vez.
Você é um desenvolvedor Java e deseja aproveitar a análise de XML otimizada para Java.
O que você ganha?
Ao analisar um documento XML com um analisador DOM4J, você obtém a flexibilidade de obter de volta uma estrutura de árvore que contém todos os elementos do seu documento sem afetar a área de cobertura da memória do aplicativo.
DOM4J fornece uma variedade de funções utilitárias que você pode usar para examinar o conteúdo e a estrutura de um documento XML, caso o documento seja bem estruturado e sua estrutura seja conhecida.
DOM4J usa a expressão XPath para navegar por um documento XML.
Vantagens
DOM4J fornece aos desenvolvedores Java a flexibilidade e facilidade de manutenção do código de análise XML. É uma API leve e rápida.
Classes DOM4J
DOM4J define várias classes Java. Aqui estão as classes mais comuns -
Document- Representa todo o documento XML. Um objeto Document é freqüentemente referido como uma árvore DOM.
Element- Representa um elemento XML. O objeto Element tem métodos para manipular seus elementos filho, texto, atributos e namespaces.
Attribute- Representa um atributo de um elemento. O atributo tem um método para obter e definir o valor do atributo. Tem pai e tipo de atributo.
Node - Representa elemento, atributo ou ProcessingInstruction.
Métodos DOM4J comuns
Quando você está trabalhando com o DOM4J, existem vários métodos que você usa com frequência -
SAXReader.read(xmlSource)() - Construa o documento DOM4J a partir de uma fonte XML.
Document.getRootElement() - Obtenha o elemento raiz de um documento XML.
Element.node(index) - Obtenha o nó XML em um índice específico em um elemento.
Element.attributes() - Obtenha todos os atributos de um elemento.
Node.valueOf(@Name) - Obtenha os valores de um atributo com o nome fornecido de um elemento.
Passos para usar DOM4J
A seguir estão as etapas usadas ao analisar um documento usando o analisador DOM4J.
Importe pacotes relacionados a XML.
Crie um SAXReader.
Crie um documento a partir de um arquivo ou fluxo.
Obtenha os nós necessários usando XPath Expression chamando document.selectNodes ()
Extraia o elemento raiz.
Repita a lista de nós.
Examine os atributos.
Examine os subelementos.
Importar pacotes relacionados a XML
import java.io.*;
import java.util.*;
import org.dom4j.*;Crie um DocumentBuilder
SAXBuilder saxBuilder = new SAXBuilder();Crie um documento a partir de um arquivo ou fluxo
File inputFile = new File("input.txt");
SAXBuilder saxBuilder = new SAXBuilder();
Document document = saxBuilder.build(inputFile);Extraia o elemento raiz
Element classElement = document.getRootElement();Examine os atributos
//returns specific attribute
valueOf("@attributeName");Examine os subelementos
//returns first child node
selectSingleNode("subelementName");Exemplo de demonstração
Aqui está o arquivo xml de entrada que precisamos analisar -
<?xml version = "1.0"?>
<class>
<student rollno = "393">
<firstname>dinkar</firstname>
<lastname>kad</lastname>
<nickname>dinkar</nickname>
<marks>85</marks>
</student>
<student rollno = "493">
<firstname>Vaneet</firstname>
<lastname>Gupta</lastname>
<nickname>vinni</nickname>
<marks>95</marks>
</student>
<student rollno = "593">
<firstname>jasvir</firstname>
<lastname>singn</lastname>
<nickname>jazz</nickname>
<marks>90</marks>
</student>
</class>DOM4JParserDemo.java
package com.tutorialspoint.xml;
import java.io.File;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
public class DOM4JParserDemo {
public static void main(String[] args) {
try {
File inputFile = new File("input.txt");
SAXReader reader = new SAXReader();
Document document = reader.read( inputFile );
System.out.println("Root element :" + document.getRootElement().getName());
Element classElement = document.getRootElement();
List<Node> nodes = document.selectNodes("/class/student" );
System.out.println("----------------------------");
for (Node node : nodes) {
System.out.println("\nCurrent Element :"
+ node.getName());
System.out.println("Student roll no : "
+ node.valueOf("@rollno") );
System.out.println("First Name : "
+ node.selectSingleNode("firstname").getText());
System.out.println("Last Name : "
+ node.selectSingleNode("lastname").getText());
System.out.println("First Name : "
+ node.selectSingleNode("nickname").getText());
System.out.println("Marks : "
+ node.selectSingleNode("marks").getText());
}
} catch (DocumentException e) {
e.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
Root element :class
----------------------------
Current Element :student
Student roll no :
First Name : dinkar
Last Name : kad
First Name : dinkar
Marks : 85
Current Element :student
Student roll no :
First Name : Vaneet
Last Name : Gupta
First Name : vinni
Marks : 95
Current Element :student
Student roll no :
First Name : jasvir
Last Name : singn
First Name : jazz
Marks : 90Exemplo de demonstração
Aqui está o arquivo xml de entrada que precisamos analisar -
<?xml version = "1.0"?>
<class>
<student rollno = "393">
<firstname>dinkar</firstname>
<lastname>kad</lastname>
<nickname>dinkar</nickname>
<marks>85</marks>
</student>
<student rollno = "493">
<firstname>Vaneet</firstname>
<lastname>Gupta</lastname>
<nickname>vinni</nickname>
<marks>95</marks>
</student>
<student rollno = "593">
<firstname>jasvir</firstname>
<lastname>singn</lastname>
<nickname>jazz</nickname>
<marks>90</marks>
</student>
</class>DOM4JQueryDemo.java
package com.tutorialspoint.xml;
import java.io.File;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;
public class DOM4JQueryDemo {
public static void main(String[] args) {
try {
File inputFile = new File("input.txt");
SAXReader reader = new SAXReader();
Document document = reader.read( inputFile );
System.out.println("Root element :" + document.getRootElement().getName());
Element classElement = document.getRootElement();
List<Node> nodes = document.selectNodes("/class/student[@rollno = '493']" );
System.out.println("----------------------------");
for (Node node : nodes) {
System.out.println("\nCurrent Element :"
+ node.getName());
System.out.println("Student roll no : "
+ node.valueOf("@rollno") );
System.out.println("First Name : "
+ node.selectSingleNode("firstname").getText());
System.out.println("Last Name : "
+ node.selectSingleNode("lastname").getText());
System.out.println("First Name : "
+ node.selectSingleNode("nickname").getText());
System.out.println("Marks : "
+ node.selectSingleNode("marks").getText());
}
} catch (DocumentException e) {
e.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
Root element :class
----------------------------
Current Element :student
Student roll no : 493
First Name : Vaneet
Last Name : Gupta
First Name : vinni
Marks : 95Exemplo de demonstração
Aqui está o XML que precisamos criar -
<?xml version = "1.0" encoding = "UTF-8"?>
<cars>
<supercars company = "Ferrari">
<carname type = "formula one">Ferrari 101</carname>
<carname type = "sports">Ferrari 202</carname>
</supercars>
</cars>CreateXmlFileDemo.java
package com.tutorialspoint.xml;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;
public class DOM4JCreateXMLDemo {
public static void main(String[] args) {
try {
Document document = DocumentHelper.createDocument();
Element root = document.addElement( "cars" );
Element supercarElement = root.addElement("supercars")
.addAttribute("company", "Ferrai");
supercarElement.addElement("carname")
.addAttribute("type", "Ferrari 101")
.addText("Ferrari 101");
supercarElement.addElement("carname")
.addAttribute("type", "sports")
.addText("Ferrari 202");
// Pretty print the document to System.out
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter writer;
writer = new XMLWriter( System.out, format );
writer.write( document );
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
<?xml version = "1.0" encoding = "UTF-8"?>
<cars>
<supercars company = "Ferrari">
<carname type = "formula one">Ferrari 101</carname>
<carname type = "sports">Ferrari 202</carname>
</supercars>
</cars>Exemplo de demonstração
Aqui está o XML que precisamos modificar -
<?xml version = "1.0"?>
<class>
<student rollno = "393">
<firstname>dinkar</firstname>
<lastname>kad</lastname>
<nickname>dinkar</nickname>
<marks>85</marks>
</student>
<student rollno = "493">
<firstname>Vaneet</firstname>
<lastname>Gupta</lastname>
<nickname>vinni</nickname>
<marks>95</marks>
</student>
<student rollno = "593">
<firstname>jasvir</firstname>
<lastname>singn</lastname>
<nickname>jazz</nickname>
<marks>90</marks>
</student>
</class>DOM4jModifyXMLDemo.java
package com.tutorialspoint.xml;
import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Iterator;
import java.util.List;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;
public class DOM4jModifyXMLDemo {
public static void main(String[] args) {
try {
File inputFile = new File("input.txt");
SAXReader reader = new SAXReader();
Document document = reader.read( inputFile );
Element classElement = document.getRootElement();
List<Node> nodes = document.selectNodes("/class/student[@rollno = '493']" );
for (Node node : nodes) {
Element element = (Element)node;
Iterator<Element> iterator = element.elementIterator("marks");
while(iterator.hasNext()) {
Element marksElement = (Element)iterator.next();
marksElement.setText("80");
}
}
// Pretty print the document to System.out
OutputFormat format = OutputFormat.createPrettyPrint();
XMLWriter writer;
writer = new XMLWriter( System.out, format );
writer.write( document );
} catch (DocumentException e) {
e.printStackTrace();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}Isso produziria o seguinte resultado -
<?xml version = "1.0" encoding = "UTF-8"?>
<class>
<student rollno = "393">
<firstname>dinkar</firstname>
<lastname>kad</lastname>
<nickname>dinkar</nickname>
<marks>85</marks>
</student>
<student rollno = "493">
<firstname>Vaneet</firstname>
<lastname>Gupta</lastname>
<nickname>vinni</nickname>
<marks>80</marks>
</student>
<student rollno = "593">
<firstname>jasvir</firstname>
<lastname>singn</lastname>
<nickname>jazz</nickname>
<marks>90</marks>
</student>
</class>