కోడ్‌తో XML ఫైల్‌లను ఎలా చదవాలి మరియు వ్రాయాలి

మీరు జావా నుండి ఒక XML ఫైల్‌ని చదవడం మరియు రాయడం నేర్చుకోవాలనుకుంటున్నారా?

XML ఫైల్స్ డేటా నిల్వతో సహా వివిధ ప్రయోజనాల కోసం ఉపయోగిస్తారు. JSON ప్రాచుర్యం పొందడానికి ముందు, XML అనేది నిర్మాణాత్మక డేటాను సూచించడానికి, నిల్వ చేయడానికి మరియు రవాణా చేయడానికి ఇష్టపడే ఫార్మాట్. ఇటీవలి సంవత్సరాలలో XML యొక్క ప్రజాదరణ క్షీణించినప్పటికీ, మీరు అప్పుడప్పుడు దీనిని ఎదుర్కొంటారు కాబట్టి కోడ్ నుండి దానితో ఎలా పని చేయాలో నేర్చుకోవడం ముఖ్యం.

---

---

జావా స్టాండర్డ్ ఎడిషన్ (SE) లో ఉన్నాయి XML ప్రాసెసింగ్ కోసం జావా API (JAXP) , ఇది XML ప్రాసెసింగ్ యొక్క చాలా అంశాలను కవర్ చేసే గొడుగు పదం. వీటితొ పాటు:

• తీర్పు: డాక్యుమెంట్ ఆబ్జెక్ట్ మోడల్ మూలకం, నోడ్, గుణాలు మొదలైన XML కళాఖండాలతో పనిచేసే తరగతులను కలిగి ఉంటుంది. DOM API పూర్తి XML పత్రాన్ని ప్రాసెసింగ్ కోసం మెమరీలోకి లోడ్ చేస్తుంది, కనుక ఇది పెద్ద XML ఫైల్స్‌తో పనిచేయడానికి సరిపడదు.
• సాక్స్: XML కోసం సింపుల్ API అనేది XML చదవడానికి ఈవెంట్-ఆధారిత అల్గోరిథం. ఇక్కడ XML చదివేటప్పుడు కనిపించే ఈవెంట్‌ల ద్వారా XML ప్రాసెస్ చేయబడుతుంది. ఈ పద్ధతిని ఉపయోగించడానికి మెమరీ అవసరాలు తక్కువగా ఉన్నాయి, కానీ DOM తో పని చేయడం కంటే API తో పనిచేయడం చాలా క్లిష్టంగా ఉంటుంది.
• స్టాక్స్: XML కోసం స్ట్రీమింగ్ API అనేది XML API లకు ఇటీవలి అదనంగా ఉంది మరియు XML యొక్క అధిక-పనితీరు స్ట్రీమ్ ఫిల్టరింగ్, ప్రాసెసింగ్ మరియు సవరణను అందిస్తుంది. ఇది మొత్తం XML పత్రాన్ని మెమరీలోకి లోడ్ చేయడాన్ని నివారిస్తుంది, ఇది ఈవెంట్-ఆధారిత ఆర్కిటెక్చర్ కాకుండా పుల్-టైప్ ఆర్కిటెక్చర్‌ను అందిస్తుంది, కాబట్టి SAX API ని ఉపయోగించడం కంటే అప్లికేషన్ కోడ్ మరియు అర్థం చేసుకోవడం సులభం.

ఈ వ్యాసంలో, మేము దీనిని ఉపయోగిస్తాము DOM API జావా నుండి XML ఫైల్స్ ఎలా చదవాలి మరియు వ్రాయాలి అని ప్రదర్శించడానికి. మేము భవిష్యత్ కథనాలలో ఇతర రెండు API లను కవర్ చేస్తాము.

నమూనా XML ఫైల్

ఈ ఆర్టికల్ ప్రయోజనం కోసం, మేము ఈ క్రింది నమూనా XML ఉపయోగించి భావనలను ప్రదర్శిస్తాము, వీటిని కనుగొనవచ్చు ఇక్కడ :




Gambardella, Matthew
XML Developer's Guide
Computer
44.95
2000-10-01
An in-depth look at creating applications
with XML.


Ralls, Kim
...


ఒక XML ఫైల్ చదువుతోంది

DOM API ని ఉపయోగించి XML ఫైల్‌ను చదవడానికి అవసరమైన ప్రాథమిక దశలను చూద్దాం.

మొదటి దశ ఒక ఉదాహరణ పొందడం డాక్యుమెంట్ బిల్డర్ . బిల్డర్ XML పత్రాలను అన్వయించడానికి ఉపయోగిస్తారు. ప్రాథమిక ఉపయోగం కోసం, మేము దీన్ని ఇలా చేస్తాము:

---

---

మీ ముఖాన్ని చిత్ర యాప్‌లో ఉంచండి

DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(false);
factory.setValidating(false);
DocumentBuilder builder = factory.newDocumentBuilder();


మేము ఇప్పుడు XML రూట్ మూలకం నుండి మొత్తం పత్రాన్ని మెమరీలోకి లోడ్ చేయవచ్చు. మా ఉదాహరణలో, ఇది జాబితా మూలకం.

File file = ...; // XML file to read
Document document = builder.parse(file);
Element catalog = document.getDocumentElement();


అంతే, ప్రజలారా! XML చదవడానికి DOM API చాలా సులభం. మీరు ఇప్పుడు రూట్ ఎలిమెంట్ నుండి ప్రారంభమయ్యే మొత్తం XML డాక్యుమెంట్‌కి యాక్సెస్ కలిగి ఉన్నారు, జాబితా . దానితో ఎలా పని చేయాలో ఇప్పుడు చూద్దాం.

---

---

DOM API ని ఉపయోగించడం

ఇప్పుడు మాకు XML రూట్ ఉంది మూలకం , మేము ఆసక్తికరమైన నగ్గెట్స్ సమాచారాన్ని సేకరించేందుకు DOM API ని ఉపయోగించవచ్చు.

అన్నీ పొందండి పుస్తకం రూట్ ఎలిమెంట్ యొక్క పిల్లలు మరియు వాటిపై లూప్ చేయండి. అది గమనించండి getChildNodes () తిరిగి వస్తుంది అన్ని పిల్లలు, వచనం, వ్యాఖ్యలు మొదలైనవి.

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
}


తల్లిదండ్రులకు ఇచ్చిన నిర్దిష్ట పిల్లల మూలకాన్ని మీరు ఎలా కనుగొంటారు? కింది స్టాటిక్ పద్ధతి కనుగొనబడితే లేదా శూన్యమైనట్లయితే మొదటి సరిపోలిక మూలకాన్ని అందిస్తుంది. మీరు గమనిస్తే, ఈ ప్రక్రియలో పిల్లల నోడ్‌ల జాబితాను పొందడం మరియు వాటి ద్వారా లూపింగ్ చేయడం ద్వారా పేర్కొన్న పేరుతో మూలకం నోడ్‌లను ఎంచుకోవడం జరుగుతుంది.

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;
}


DOM API ఒక మూలకం లోపల టెక్స్ట్ కంటెంట్‌ను రకం యొక్క ప్రత్యేక నోడ్‌గా పరిగణిస్తుందని గమనించండి TEXT_NODE . అదనంగా, టెక్స్ట్ కంటెంట్ బహుళ ప్రక్కనే ఉన్న టెక్స్ట్ నోడ్‌లుగా విభజించబడవచ్చు. కాబట్టి ఒక మూలకం లోపల టెక్స్ట్ కంటెంట్‌ను పొందడానికి క్రింది ప్రత్యేక ప్రాసెసింగ్ అవసరం.

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();
}


ఈ సౌకర్యవంతమైన ఫంక్షన్లతో సాయుధమై, ఇప్పుడు మా నమూనా XML నుండి కొంత సమాచారాన్ని జాబితా చేయడానికి కొంత కోడ్‌ను చూద్దాం. పుస్తక కేటలాగ్‌లో లభ్యమయ్యే ప్రతి పుస్తకానికి సంబంధించిన వివరణాత్మక సమాచారాన్ని మేము చూపించాలనుకుంటున్నాము.

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);
}


XML అవుట్‌పుట్ రాయడం

జావా అందిస్తుంది XML ట్రాన్స్‌ఫార్మ్ API XML డేటాను మార్చడానికి. మేము ఈ API ని దీనితో ఉపయోగిస్తాము గుర్తింపు మార్పు అవుట్‌పుట్ జనరేట్ చేయడానికి.

ఉదాహరణగా, మనం కొత్తదాన్ని జోడిద్దాం పుస్తకం పైన అందించిన నమూనా కేటలాగ్‌కి మూలకం. పుస్తకం వివరాలు (వంటివి రచయిత , శీర్షిక , మొదలైనవి) బాహ్యంగా పొందవచ్చు, బహుశా ప్రాపర్టీస్ ఫైల్ లేదా డేటాబేస్ నుండి. డేటాను లోడ్ చేయడానికి మేము ఈ క్రింది లక్షణాల ఫైల్‌ని ఉపయోగిస్తాము.

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.


పైన అందించిన పద్ధతిని ఉపయోగించి ఇప్పటికే ఉన్న XML ఫైల్‌ని అన్వయించడం మొదటి దశ. కోడ్ కూడా క్రింద చూపబడింది.

File file = ...; // XML file to read
Document document = builder.parse(file);
Element catalog = document.getDocumentElement();


మేము దానిని ఉపయోగించి ప్రాపర్టీస్ ఫైల్ నుండి డేటాను లోడ్ చేస్తాము గుణాలు జావా అందించిన తరగతి. కోడ్ చాలా సులభం మరియు క్రింద చూపబడింది.

String propsFile = ...;
Properties props = new Properties();
try (FileReader in = new FileReader(propsFile)) {
props.load(in);
}


ప్రాపర్టీలు లోడ్ అయిన తర్వాత, ప్రాపర్టీస్ ఫైల్ నుండి మనం జోడించాలనుకుంటున్న విలువలను తిరిగి పొందుతాము.

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');


ఇప్పుడు మనం ఖాళీని సృష్టిద్దాం పుస్తకం మూలకం.

యుఎస్‌బి నుండి టివి వరకు స్క్రీన్ మిర్రరింగ్

Element book = document.createElement('book');
book.setAttribute('id', id);


చైల్డ్ ఎలిమెంట్‌లను జోడించడం పుస్తకం అల్పమైనది. సౌలభ్యం కోసం, మేము అవసరమైన మూలకం పేర్లను a లో సేకరిస్తాము జాబితా మరియు లూప్‌లో విలువలను జోడించండి.

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);


మరియు అది ఎలా జరుగుతుంది. ది జాబితా మూలకం ఇప్పుడు కొత్తది కలిగి ఉంది పుస్తకం మూలకం జోడించబడింది. నవీకరించబడిన XML ను వ్రాయడం మాత్రమే ఇప్పుడు మిగిలి ఉంది.

XML వ్రాయడానికి, మాకు ఒక ఉదాహరణ అవసరం ట్రాన్స్‌ఫార్మర్ ఇది క్రింద చూపిన విధంగా సృష్టించబడింది. మేము దీనిని ఉపయోగించి అవుట్‌పుట్ XML యొక్క ఇండెంటేషన్‌ను అభ్యర్థిస్తున్నామని గమనించండి setOutputProperty () పద్ధతి

TransformerFactory tfact = TransformerFactory.newInstance();
Transformer tform = tfact.newTransformer();
tform.setOutputProperty(OutputKeys.INDENT, 'yes');
tform.setOutputProperty('{http://xml.apache.org/xslt}indent-amount', '3');


XML అవుట్‌పుట్‌ను రూపొందించడంలో చివరి దశ పరివర్తనను వర్తింపజేయడం. ఫలితం అవుట్‌పుట్ స్ట్రీమ్‌లో కనిపిస్తుంది, System.out .

tform.transform(new DOMSource(document), new StreamResult(System.out));


అవుట్‌పుట్‌ను నేరుగా ఫైల్‌కు వ్రాయడానికి, కింది వాటిని ఉపయోగించండి.

tform.transform(new DOMSource(document), new StreamResult(new File('output.xml')));


మరియు DOM API ని ఉపయోగించి XML ఫైల్‌లను చదవడం మరియు వ్రాయడంపై ఈ కథనాన్ని మూసివేస్తుంది.

మీరు మీ అప్లికేషన్‌లలో DOM API ని ఉపయోగించారా? ఇది ఎలా పని చేసింది? దయచేసి దిగువ వ్యాఖ్యలలో మాకు తెలియజేయండి.

షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ కానన్ వర్సెస్ నికాన్: ఏ కెమెరా బ్రాండ్ మంచిది?

కెనన్ మరియు నికాన్ కెమెరా పరిశ్రమలో రెండు అతిపెద్ద పేర్లు. అయితే ఏ బ్రాండ్ కెమెరాలు మరియు లెన్స్‌ల మెరుగైన శ్రేణిని అందిస్తుంది?

తదుపరి చదవండి సంబంధిత అంశాలు

• ప్రోగ్రామింగ్
• జావా

రచయిత గురుంచి జై శ్రీధర్(17 కథనాలు ప్రచురించబడ్డాయి) జే శ్రీధర్ నుండి మరిన్ని

మా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి

టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!

సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి