Home-theater-designers
Nais mo bang malaman kung paano basahin at magsulat ng isang XML file mula sa java?
Mga XML file ay ginagamit para sa iba't ibang mga layunin kabilang ang pag-iimbak ng data. Bago naging tanyag ang JSON, ang XML ang ginustong format para sa kumakatawan, pag-iimbak at pagdadala ng nakabalangkas na data. Kahit na ang katanyagan ng XML ay humina sa mga nagdaang taon, maaari mo itong makasalubong paminsan-minsan kaya't mahalagang malaman kung paano gumana kasama nito mula sa code.
Kasama sa Java Standard Edition (SE) ang Java API para sa XML Processing (JAXP) , na kung saan ay isang termino ng payong na sumasaklaw sa karamihan ng mga aspeto ng pagpoproseso ng XML. Kabilang dito ang:
- HATOL: Ang Modelong Bagay ng Dokumento ay may kasamang mga klase para sa pagtatrabaho sa mga artifact ng XML tulad ng elemento, node, mga katangian, atbp. Nilo-load ng DOM API ang kumpletong dokumento ng XML sa memorya para sa pagproseso, kaya't hindi ito masyadong angkop para sa pagtatrabaho sa malalaking mga file ng XML.
- SAX: Ang Simple API para sa XML ay isang algorithm na hinimok ng kaganapan para sa pagbabasa ng XML. Narito ang XML ay naproseso sa pamamagitan ng pagpapaputok ng mga kaganapan na natagpuan kapag binabasa ang XML. Ang mga kinakailangan sa memorya para sa paggamit ng pamamaraang ito ay mababa, ngunit ang pagtatrabaho sa API ay mas kumplikado kaysa sa pagtatrabaho sa DOM.
- StAX: Ang Streaming API para sa XML ay isang kamakailang karagdagan sa mga XML API at nagbibigay ng mahusay na pagganap ng pag-filter ng stream, pagproseso, at pagbabago ng XML. Habang iniiwasan nito ang paglo-load ng buong dokumento ng XML sa memorya, nagbibigay ito ng isang arkitekturang uri ng pull sa halip na isang arkitektura na hinimok ng kaganapan, kaya mas madaling ma-code at maunawaan ang application kaysa sa paggamit ng SAX API.
Sa artikulong ito, ginagamit namin ang DOM API upang ipakita kung paano basahin at isulat ang mga XML file mula sa java. Saklawin namin ang iba pang dalawang mga API sa mga susunod na artikulo.
Isang Sample na XML File
Para sa layunin ng artikulong ito, ipinapakita namin ang mga konsepto gamit ang sumusunod na sample na XML, na maaaring matagpuan dito :
Gambardella, Matthew
XML Developer's Guide
Computer
44.95
2000-10-01
An in-depth look at creating applications
with XML.
Ralls, Kim
...
Nagbabasa ng isang XML File
Tingnan natin ang mga pangunahing hakbang na kinakailangan para sa pagbabasa ng isang XML file gamit ang DOM API.
Ang unang hakbang ay upang makakuha ng isang halimbawa ng Dokumento ng Tagabuo . Ginagamit ang tagabuo upang mai-parse ang mga dokumento ng XML. Para sa pangunahing paggamit, ginagawa namin ito tulad nito:
kung paano mag-install ng macos sa virtualbox
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(false);
factory.setValidating(false);
DocumentBuilder builder = factory.newDocumentBuilder();
Maaari na nating mai-load ang buong dokumento sa memorya simula sa elemento ng ugat ng XML. Sa aming halimbawa, ito ay ang katalogo elemento.
File file = ...; // XML file to read
Document document = builder.parse(file);
Element catalog = document.getDocumentElement();
At iyon lang, mga kababayan! Ang DOM API para sa pagbabasa ng isang XML ay talagang simple. Mayroon ka nang access sa buong dokumento ng XML simula sa root element nito, katalogo . Tingnan natin ngayon kung paano ito magtrabaho.
Gamit ang DOM API
Ngayon na mayroon kaming XML root Elemento , maaari naming gamitin ang DOM API upang kumuha ng mga kawili-wiling nugget ng impormasyon.
Kunin ang lahat ng libro mga anak ng root element at loop sa kanila. Tandaan na getChildNodes () nagbabalik lahat mga bata, kabilang ang teksto, mga komento, atbp. Para sa aming hangarin, kailangan lang namin ang mga elemento ng bata, kaya't pinalampas namin ang iba pa.
NodeList books = catalog.getChildNodes();
for (int i = 0, ii = 0, n = books.getLength() ; i Node child = books.item(i);
if ( child.getNodeType() != Node.ELEMENT_NODE )
continue;
Element book = (Element)child;
// work with the book Element here
}
Paano mo mahahanap ang isang tukoy na elemento ng bata, na ibinigay sa magulang? Ang sumusunod na static na pamamaraan ay nagbabalik ng unang elemento ng pagtutugma kung nahanap, o null. Tulad ng nakikita mo, ang pamamaraan ay nagsasangkot ng pagkuha ng listahan ng mga node ng bata at pag-loop sa pamamagitan ng pagpili ng mga node ng elemento na may tinukoy na pangalan.
static private Node findFirstNamedElement(Node parent,String tagName)
{
NodeList children = parent.getChildNodes();
for (int i = 0, in = children.getLength() ; i Node child = children.item(i);
if ( child.getNodeType() != Node.ELEMENT_NODE )
continue;
if ( child.getNodeName().equals(tagName) )
return child;
}
return null;
}
Tandaan na tinatrato ng DOM API ang nilalaman ng teksto sa loob ng isang elemento bilang isang hiwalay na node ng uri TEXT_NODE . Bilang karagdagan, ang nilalaman ng teksto ay maaaring hatiin sa maraming katabing mga node ng teksto. Kaya't ang sumusunod na espesyal na pagproseso ay kinakailangan upang makuha ang nilalaman ng teksto sa loob ng isang elemento.
static private String getCharacterData(Node parent)
{
StringBuilder text = new StringBuilder();
if ( parent == null )
return text.toString();
NodeList children = parent.getChildNodes();
for (int k = 0, kn = children.getLength() ; k Node child = children.item(k);
if ( child.getNodeType() != Node.TEXT_NODE )
break;
text.append(child.getNodeValue());
}
return text.toString();
}
Gamit ang mga pagpapaandar na kaginhawaan, tingnan natin ngayon ang ilang code para sa listahan ng ilang impormasyon mula sa aming sample na XML. Nais naming ipakita ang detalyadong impormasyon para sa bawat libro, tulad ng magagamit sa isang katalogo ng libro.
NodeList books = catalog.getChildNodes();
for (int i = 0, ii = 0, n = books.getLength() ; i Node child = books.item(i);
if ( child.getNodeType() != Node.ELEMENT_NODE )
continue;
Element book = (Element)child;
ii++;
String id = book.getAttribute('id');
String author = getCharacterData(findFirstNamedElement(child,'author'));
String title = getCharacterData(findFirstNamedElement(child,'title'));
String genre = getCharacterData(findFirstNamedElement(child,'genre'));
String price = getCharacterData(findFirstNamedElement(child,'price'));
String pubdate = getCharacterData(findFirstNamedElement(child,'pubdate'));
String descr = getCharacterData(findFirstNamedElement(child,'description'));
System.out.printf('%3d. book id = %s
' +
' author: %s
' +
' title: %s
' +
' genre: %s
' +
' price: %s
' +
' pubdate: %s
' +
' descr: %s
',
ii, id, author, title, genre, price, pubdate, descr);
}
Pagsusulat ng XML Output
Ang Java ay nagbibigay ng XML Tranform API upang ibahin ang data ng XML. Ginagamit namin ang API na ito sa pagkakakilanlan pagbabago upang makabuo ng output.
Bilang isang halimbawa, magdagdag tayo ng bago libro elemento sa halimbawang katalogo na ipinakita sa itaas. Ang mga detalye ng libro (tulad ng may akda , pamagat , atbp) ay maaaring makuha sa labas, marahil mula sa isang file ng mga katangian o isang database. Ginagamit namin ang sumusunod na file ng mga katangian upang mai-load ang data.
id=bk113
author=Jane Austen
title=Pride and Prejudice
genre=Romance
price=6.99
publish_date=2010-04-01
description='It is a truth universally acknowledged, that a single man in possession of a good fortune must be in want of a wife.' So begins Pride and Prejudice, Jane Austen's witty comedy of manners-one of the most popular novels of all time-that features splendidly civilized sparring between the proud Mr. Darcy and the prejudiced Elizabeth Bennet as they play out their spirited courtship in a series of eighteenth-century drawing-room intrigues.
Ang unang hakbang ay upang mai-parse ang mayroon nang XML file gamit ang pamamaraang ipinakita sa itaas. Ang code ay ipinakita rin sa ibaba.
File file = ...; // XML file to read
Document document = builder.parse(file);
Element catalog = document.getDocumentElement();
Nilo-load namin ang data mula sa mga file ng mga pag-aari gamit ang Ari-arian klase na ibinigay sa java. Ang code ay medyo simple at ipinapakita sa ibaba.
String propsFile = ...;
Properties props = new Properties();
try (FileReader in = new FileReader(propsFile)) {
props.load(in);
}
Kapag na-load na ang mga pag-aari, makuha namin ang mga halagang nais naming idagdag mula sa file ng mga pag-aari.
String id = props.getProperty('id');
String author = props.getProperty('author');
String title = props.getProperty('title');
String genre = props.getProperty('genre');
String price = props.getProperty('price');
String publish_date = props.getProperty('publish_date');
String descr = props.getProperty('description');
Gumawa tayo ngayon ng isang walang laman libro elemento.
hindi naglo-load nang maayos ang website ng pc gamer
Element book = document.createElement('book');
book.setAttribute('id', id);
Pagdaragdag ng mga elemento ng bata sa libro ay walang halaga. Para sa kaginhawaan, kinokolekta namin ang kinakailangang mga pangalan ng elemento sa a Listahan at idagdag ang mga halaga sa isang loop.
List elnames =Arrays.asList('author', 'title', 'genre', 'price',
'publish_date', 'description');
for (String elname : elnames) {
Element el = document.createElement(elname);
Text text = document.createTextNode(props.getProperty(elname));
el.appendChild(text);
book.appendChild(el);
}
catalog.appendChild(book);
At ganoon ang ginagawa. Ang katalogo Ang elemento ay mayroon nang bago libro idinagdag ang elemento. Ang natitira lamang ngayon ay ang isulat ang na-update na XML.
Para sa pagsusulat ng XML, kailangan namin ng isang halimbawa ng Transpormer na nilikha tulad ng ipinakita sa ibaba. Tandaan na humiling kami ng indentation ng output XML gamit ang setOutputProperty () pamamaraan
TransformerFactory tfact = TransformerFactory.newInstance();
Transformer tform = tfact.newTransformer();
tform.setOutputProperty(OutputKeys.INDENT, 'yes');
tform.setOutputProperty('{http://xml.apache.org/xslt}indent-amount', '3');
Ang pangwakas na hakbang sa pagbuo ng XML output ay upang ilapat ang tranformation. Lumilitaw ang resulta sa output stream, System.out .
tform.transform(new DOMSource(document), new StreamResult(System.out));
Upang direktang isulat ang output sa isang file, gamitin ang sumusunod.
tform.transform(new DOMSource(document), new StreamResult(new File('output.xml')));
At balot nito ang artikulong ito sa pagbabasa at pagsusulat ng mga XML file gamit ang DOM API.
Nagamit mo na ba ang DOM API sa iyong mga application? Paano ito nagganap? Mangyaring ipaalam sa amin sa mga komento sa ibaba.
Magbahagi Magbahagi Mag-tweet Email Canon vs. Nikon: Aling Camera Brand Ay Mas Mabuti?Ang Canon at Nikon ay ang dalawang pinakamalaking pangalan sa industriya ng camera. Ngunit aling tatak ang nag-aalok ng mas mahusay na lineup ng mga camera at lente?
Basahin Susunod Mga Kaugnay na Paksa- Programming
- Java
Mag-subscribe sa aming newsletter
Sumali sa aming newsletter para sa mga tip sa tech, pagsusuri, libreng ebook, at eksklusibong deal!
Mag-click dito upang mag-subscribe