1. Conhecimentos básicos:
Geralmente existem quatro métodos para Java analisar XML: DOM, SAX, JDOM e DOM4J.
2. Introdução ao uso
1), DOM
(1)Introdução
A interface fornecida pelo W3C (org.w3c.dom) lê todo o documento XML na memória e constrói uma árvore DOM para operar em cada nó. A vantagem é que todo o documento está sempre na memória, podemos acessar qualquer nó a qualquer momento, e o percurso em árvore também é uma operação relativamente familiar. A desvantagem é que consome memória e devemos esperar até que todos os documentos sejam lidos na memória; antes do processamento.
(2) Código de amostra:
Copie o código do código da seguinte forma:
<?xml version="1.0" encoding="UTF-8" autônomo="não"?>
<raiz>
<Telefone>
<tipo nome="nokia">
<preço>599</preço>
<operador>CMCC</operador>
</type>
<tipo nome="xiaomi">
<preço>699</preço>
<operador>ChinaNet</operador>
</type>
</Telefone>
</raiz>
Copie o código do código da seguinte forma:
importar java.io.ByteArrayOutputStream;
importar java.io.File;
importar java.io.FileOutputStream;
importar java.io.IOException;
importar java.io.StringReader;
importar javax.xml.parsers.DocumentBuilder;
importar javax.xml.parsers.DocumentBuilderFactory;
importar javax.xml.parsers.ParserConfigurationException;
importar javax.xml.transform.Transformer;
importar javax.xml.transform.TransformerConfigurationException;
importar javax.xml.transform.TransformerException;
importar javax.xml.transform.TransformerFactory;
importar javax.xml.transform.dom.DOMSource;
importar javax.xml.transform.stream.StreamResult;
importar org.w3c.dom.Document;
importar org.w3c.dom.Element;
importar org.w3c.dom.Node;
importar org.w3c.dom.NodeList;
importar org.xml.sax.InputSource;
importar org.xml.sax.SAXException;
classe pública XMLHandler {
XMLHandler público(){
}
String pública createXML(){
String xmlStr=nulo;
Fábrica de DocumentBuilderFactory = DocumentBuilderFactory.newInstance();
tentar {
Construtor DocumentBuilder = factory.newDocumentBuilder();
Documento documento = construtor.newDocument();
document.setXmlVersion("1.0");
Elemento raiz = document.createElement("root");
document.appendChild(raiz);
Elemento telefone = document.createElement("Telefone");
Elemento nokia = document.createElement("tipo");
nokia.setAttribute("nome", "nokia");
Elemento preçoNokia = document.createElement("preço");
preçoNokia.setTextContent("599");
nokia.appendChild(preçoNokia);
Elemento operadorNokia = document.createElement("operador");
operadorNokia.setTextContent("CMCC");
nokia.appendChild(operadorNokia);
telefone.appendChild(nokia);
Elemento xiaomi = document.createElement("tipo");
xiaomi.setAttribute("nome", "xiaomi");
Elemento preçoXiaoMi = document.createElement("preço");
preçoXiaoMi.setTextContent("699");
xiaomi.appendChild(preçoXiaoMi);
Elemento operadorXiaoMi = document.createElement("operador");
operadorXiaoMi.setTextContent("ChinaNet");
xiaomi.appendChild(operadorXiaoMi);
telefone.appendChild(xiaomi);
root.appendChild(telefone);
TransformerFactory transFactory = TransformerFactory.newInstance();
Transformador transformer = transFactory.newTransformer();
DOMSource domSource = new DOMSource(documento);
//exporta string
ByteArrayOutputStream bos = new ByteArrayOutputStream();
transFormer.transform(domSource, new StreamResult(bos));
xmlStr = bos.toString();
//-------
//salva como arquivo
Arquivo arquivo = new Arquivo("TelePhone.xml");
if(!file.exists()){
arquivo.createNewFile();
}
FileOutputStream out = new FileOutputStream(arquivo);
StreamResult xmlResult = new StreamResult(out);
transFormer.transform(domSource, xmlResult);
//--------
} catch (ParserConfigurationException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}catch(TransformerConfigurationException e){
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}catch(TransformerException e){
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}catch(IOException e){
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
retornar xmlStr;
}
analisador de vazio públicoXML(String strXML){
Fábrica de DocumentBuilderFactory = DocumentBuilderFactory.newInstance();
tentar {
Construtor DocumentBuilder = factory.newDocumentBuilder();
StringReader sr = novo StringReader(strXML);
InputSource é = new InputSource(sr);
Documento doc=builder.parse(is);
Elemento rootElement = doc.getDocumentElement();
Telefones NodeList = rootElement.getElementsByTagName("tipo");
for (int i = 0; i <phones.getLength(); i++) {
Tipo de nó = phones.item(i);
String phoneName = ((Element)type).getAttribute("nome");
System.out.println("Nome do telefone = "+phoneName);
Propriedades de NodeList = type.getChildNodes();
for (int j = 0; j < propriedades.getLength(); j++) {
Propriedade do nó = propriedades.item(j);
String nodeName = propriedade.getNodeName();
if (nodeName.equals("preço")) {
String preço=propriedade.getFirstChild().getNodeValue();
System.out.println("preço="+preço);
} else if (nodeName.equals("operador")) {
String operador=property.getFirstChild().getNodeValue();
System.out.println("operador="+operador);
}
}
}
} catch (ParserConfigurationException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}catch(SAXException e){
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
} catch (IOException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
}
public static void main(String[] args) {
Manipulador XMLHandler = novo XMLHandler();
String xml = manipulador.createXML();
System.out.println(xml);
manipulador.parserXML(xml);
}
}
(3) A diferença entre elemento e nó (org.w3c.dom)
O objeto Node é o principal tipo de dados de todo o modelo de objeto de documento. É o objeto mais básico do DOM e representa o nó abstrato na árvore de documentos. No entanto, no uso real, o objeto Node raramente é usado diretamente. Em vez disso, os subobjetos Element, Attr, Text, etc. do objeto Node são usados.
O objeto Element representa um elemento em um documento HTML ou XML e é o subobjeto principal da classe Node. O elemento pode conter atributos, portanto Element possui métodos para acessar seus atributos.
O elemento é herdado do nó. Elemento é uma definição em pequena escala. Deve ser um nó contendo informações completas para ser um elemento, como <div>...</div>. Mas um nó não é necessariamente um elemento e um elemento deve ser um nó.
node possui vários subtipos: Element, Text, Attribute, RootElement, Comment, Namespace, etc.
2), SAXO
3), JDOM
4), DOM4J
(1)Introdução
dom4j é atualmente o melhor em análise de XML (Hibernate e JAXM da Sun também usam dom4j para analisar XML). Ele incorpora muitas funções além da representação básica de documentos XML, incluindo suporte integrado a XPath, suporte a esquema XML e processamento baseado em eventos de documentos grandes ou de streaming.
Ao usar XPATH, adicione jaxen.jar, caso contrário ocorrerá o seguinte erro:
Copie o código do código da seguinte forma:
Exceção no thread "principal" java.lang.NoClassDefFoundError: org/jaxen/JaxenException
em org.dom4j.DocumentFactory.createXPath(DocumentFactory.java:230)
em org.dom4j.tree.AbstractNode.createXPath(AbstractNode.java:207)
em org.dom4j.tree.AbstractNode.selectNodes(AbstractNode.java:164)
(2) Código de amostra:
Copie o código do código da seguinte forma:
importar java.io.File;
importar java.io.FileWriter;
importar java.io.IOException;
importar java.io.StringReader;
importar java.io.StringWriter;
importar java.util.List;
importar org.dom4j.Document;
importar org.dom4j.DocumentException;
importar org.dom4j.DocumentHelper;
importar org.dom4j.Element;
importar org.dom4j.io.OutputFormat;
importar org.dom4j.io.SAXReader;
importar org.dom4j.io.XMLWriter;
importar org.xml.sax.InputSource;
classe pública XMLHandler {
publicXMLHandler() {
// TODO stub do construtor gerado automaticamente
}
String pública createXML(){
String strXML = nulo;
Documento documento = DocumentHelper.createDocument();
Elemento raiz = document.addElement("root");
Elemento telefone = root.addElement("Telefone");
Elemento nokia = phone.addElement("tipo");
nokia.addAttribute("nome", "nokia");
Elemento price_nokia = nokia.addElement("preço");
preço_nokia.addText("599");
Elemento operador_nokia = nokia.addElement("operador");
operador_nokia.addText("CMCC");
Elemento xiaomi = phone.addElement("tipo");
xiaomi.addAttribute("nome", "xiaomi");
Elemento preço_xiaomi = xiaomi.addElement("preço");
preço_xiaomi.addText("699");
Elemento operador_xiaomi = xiaomi.addElement("operador");
operador_xiaomi.addText("ChinaNet");
//--------
StringWriter strWtr = new StringWriter();
Formato OutputFormat = OutputFormat.createPrettyPrint();
format.setEncoding("UTF-8");
XMLWriter xmlWriter = novo XMLWriter(strWtr, formato);
tentar {
xmlWriter.write(documento);
} catch (IOException e1) {
// TODO Bloco catch gerado automaticamente
e1.printStackTrace();
}
strXML = strWtr.toString();
//--------
//-------
//strXML=document.asXML();
//------
//-------------
Arquivo arquivo = new Arquivo("TelePhone.xml");
if (arquivo.exists()) {
arquivo.delete();
}
tentar {
arquivo.createNewFile();
Saída XMLWriter = novo XMLWriter(novo FileWriter(arquivo));
out.write(documento);
fora.flush();
out.close();
} catch (IOException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
//-------------
retornar strXML;
}
analisador de vazio públicoXML(String strXML){
Leitor SAXReader = novo SAXReader();
StringReader sr = novo StringReader(strXML);
InputSource é = new InputSource(sr);
tentar {
Documento documento = leitor.read(is);
Raiz do elemento = document.getRootElement();
//obtém o elemento
List<Element> phoneList = root.elements("Telefone");
List<Element> typeList = phoneList.get(0).elements("type");
for (int i=0;i<typeList.size();i++){
Elemento elemento = typeList.get(i);
String phoneName = element.attributeValue("nome");
System.out.println("nomedotelefone = "+nomedotelefone);
//obtém todos os elementos
List<Element> childList = element.elements();
for (int j=0;j<childList.size();j++){
Elemento e = childList.get(j);
System.out.println(e.getName()+"="+e.getText());
}
}
} catch (DocumentException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
}
analisador de vazio públicoXMLbyXPath(String strXML){
Leitor SAXReader = novo SAXReader();
StringReader sr = novo StringReader(strXML);
InputSource é = new InputSource(sr);
tentar {
Documento documento = leitor.read(is);
Lista lista = document.selectNodes("/root/TelePhone/type");
for(int i=0;i<list.size();i++){
Elemento e = (Elemento) list.get(i);
System.out.println("phonename="+e.attributeValue("nome"));
Lista lista1 = e.selectNodes("./*");
for(int j=0;j<lista1.tamanho();j++){
Elemento e1 = (Elemento) list1.get(j);
System.out.println(e1.getName()+"="+e1.getText());
}
}
} catch (DocumentException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
}
/**
* @param argumentos
*/
public static void main(String[] args) {
// TODO stub de método gerado automaticamente
Manipulador XMLHandler = novo XMLHandler();
String strXML=handler.createXML();
System.out.println(strXML);
manipulador.parserXML(strXML);
System.out.println("-----------");
manipulador.parserXMLbyXPath(strXML);
}
}
5)XPATH
(1)Introdução
XPath é uma linguagem para localizar informações em documentos XML. XPath é usado para navegar por elementos e atributos em documentos XML.
Para introdução de sintaxe específica, consulte: http://w3school.com.cn/xpath/index.asp
(2) Código de amostra:
Copie o código do código da seguinte forma:
importar java.io.IOException;
importar java.io.StringReader;
importar javax.xml.parsers.DocumentBuilder;
importar javax.xml.parsers.DocumentBuilderFactory;
importar javax.xml.parsers.ParserConfigurationException;
importar javax.xml.xpath.XPath;
importar javax.xml.xpath.XPathConstants;
importar javax.xml.xpath.XPathExpression;
importar javax.xml.xpath.XPathExpressionException;
importar javax.xml.xpath.XPathFactory;
importar org.w3c.dom.Document;
importar org.w3c.dom.Element;
importar org.w3c.dom.Node;
importar org.w3c.dom.NodeList;
importar org.xml.sax.InputSource;
importar org.xml.sax.SAXException;
classe pública XMLHandler {
publicXMLHandler() {
// TODO stub do construtor gerado automaticamente
}
analisador de vazio públicoXML(String strXML){
Fábrica de DocumentBuilderFactory = DocumentBuilderFactory.newInstance();
tentar {
Construtor DocumentBuilder = factory.newDocumentBuilder();
StringReader sr = novo StringReader(strXML);
InputSource é = new InputSource(sr);
Documento doc=builder.parse(is);
XPathFactory xFactory = XPathFactory.newInstance();
XPath xpath = xFactory.newXPath();
XPathExpression expr = xpath.compile("/root/TelePhone/type");
Telefones NodeList = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
for (int i = 0; i <phones.getLength(); i++) {
Tipo de nó = phones.item(i);
String phoneName = ((Element)type).getAttribute("nome");
System.out.println("Nome do telefone = "+phoneName);
XPathExpression expr1 = xpath.compile("./*");
Lista NodeList = (NodeList) expr1.evaluate(tipo, XPathConstants.NODESET);
for(int j =0;j<list.getLength();j++){
Elemento e1 = (Elemento) list.item(j);
System.out.println(e1.getNodeName()+"="+e1.getTextContent());
}
}
} catch (ParserConfigurationException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}catch(SAXException e){
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
} catch (IOException e) {
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}catch(XPathExpressionException e){
// TODO Bloco catch gerado automaticamente
e.printStackTrace();
}
}
/**
* @param argumentos
*/
public static void main(String[] args) {
// TODO stub de método gerado automaticamente
String strXML="<?xml version=/"1.0/" encoding=/"UTF-8/" standalone=/"no/"?>"+
"<raiz>"+
"<Telefone>"+
"<tipo nome="nokia/">"+
"<preço>599</preço>"+
"<operador>CMCC</operador>"+
"</type>"+
"<tipo nome="xiaomi/">"+
"<preço>699</preço>"+
"<operador>ChinaNet</operador>"+
"</type>"+
"</Telefone>"+
"</root>";
Manipulador XMLHandler = novo XMLHandler();
manipulador.parserXML(strXML);
}
}
PS: Aqui estão várias ferramentas online para operações XML para sua referência:
Ferramenta online de conversão XML/JSON:
http://tools.VeVB.COm/code/xmljson
Formatação on-line de XML/Compactação de XML on-line:
http://tools.VeVB.COm/code/xmlformat
Ferramenta de compactação/formatação XML online:
http://tools.VeVB.COm/code/xml_format_compress