XPath: त्वरित नोडल इटरेशन

जब मैंने एक बहुत-सी नियमित एक्सएमएल फ़ाइल (वास्तव में, केवल एक हजार रिकॉर्ड के बारे में) संसाधित करने की कोशिश की, तो मैंने पाया कि एक्सडैट का उपयोग करने के साथ निष्कर्षण के साथ-साथ नोडलिस्ट पर पुनरावृत्ति काफी धीमी गति से शुरू होती है (मेरी फाइल पर लगभग 2 मिनट लगते हैं), और प्रसंस्करण के साथ ब्रेक बढ़ जाते हैं। प्रत्येक बाद का नोड (नोड)। यह समस्या भी सामने आती है।

blog.astradele.com/2006/02/24/slow-xpath-evaluation-for-large-xml-documents-in-java-15

jbwhammie.blogspot.com/2011/02/make-java-xpath-work-on-large-files.html

जैसा कि मैं इसे समझता हूं, यह JDK में DOM & XPath कार्यान्वयन की कुछ विशेषता है, जिसमें इस तथ्य में शामिल है कि अगर हमें XPath अनुरोध से एक निश्चित XML नोड प्राप्त होता है, तो यह नोड माता-पिता द्वारा XML दस्तावेज़ के माध्यम से संदर्भित रहता है। और बाद में इस नोड के लिए XPath अनुरोध इस तथ्य की ओर ले जाता है कि न केवल खुद नोड बल्कि पूरे XML दस्तावेज़ संसाधित होता है। इसलिए, माता-पिता को नोड से रीसेट करने की कोशिश करना तर्कसंगत है, उदाहरण के लिए, इस नोड को इसके मूल नोड से हटाकर। यह इस विधि को ऊपर दिए गए लिंक पर पेश किया जाता है, और यह काम करता है। इसका एकमात्र दोष यह है कि यह XML दस्तावेज़ को ही संशोधित करता है, जिससे यह आगे डेटा निष्कर्षण के लिए उपयुक्त नहीं रह जाता है। मैंने पाया कि एक और तरीका है जो XML दस्तावेज़ को स्वयं नहीं बदलता है - क्लोन नोड, क्योंकि, प्रलेखन के अनुसार, क्लोन में पैरेंट = अशक्त है ।

दरअसल, वर्णित समस्या और समाधान के लिए दृष्टिकोण निम्नलिखित कोड द्वारा सचित्र हैं।

import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpression;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;
import java.io.ByteArrayInputStream;

public class SlowXPath {
public static void main( String [] args) throws Exception {
final DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();

final DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();

String xmlString = prepareXml(5000);

// System.out.println(xmlString);
final Document xmlDoc = documentBuilder.parse( new ByteArrayInputStream(xmlString.getBytes()));

final XPathFactory xPathFactory = XPathFactory.newInstance();

final XPathExpression nodeXPath = xPathFactory.newXPath().compile( "//node" );
final XPathExpression iXPath = xPathFactory.newXPath().compile( "./i/text()" );

final NodeList nodeList = (NodeList) nodeXPath.evaluate(xmlDoc, XPathConstants.NODESET);

System. out .println( "Nodes number=" + nodeList.getLength());

timeIt( "Simple iterate" , new Runnable() {
@Override
public void run() {
int sum = 0;

for ( int i = 0; i < nodeList.getLength(); i++) {
final Node node = nodeList.item(i);
try {
final String iStr = ( String ) iXPath.evaluate(node, XPathConstants.STRING);
sum += Integer.parseInt(iStr.trim());
} catch (XPathExpressionException e) {
e.printStackTrace();
}
}

System. out .println( "Sum=" + sum);
}
});
timeIt( "Iterate with cloning" , new Runnable() {
@Override
public void run() {
int sum = 0;

for ( int i = 0; i < nodeList.getLength(); i++) {
final Node node = nodeList.item(i).cloneNode( true ); // <-- Note cloning here
try {
final String iStr = ( String ) iXPath.evaluate(node, XPathConstants.STRING);
sum += Integer.parseInt(iStr.trim());
} catch (XPathExpressionException e) {
e.printStackTrace();
}
}

System. out .println( "Sum=" + sum);
}
});
timeIt( "Iterate with detaching node" , new Runnable() {
@Override
public void run() {
int sum = 0;

for ( int i = 0; i < nodeList.getLength(); i++) {
final Node node = nodeList.item(i);

node.getParentNode().removeChild(node); // <-- Note detaching node

try {
final String iStr = ( String ) iXPath.evaluate(node, XPathConstants.STRING);
sum += Integer.parseInt(iStr.trim());
} catch (XPathExpressionException e) {
e.printStackTrace();
}
}

System. out .println( "Sum=" + sum);
}
});
}

private static String prepareXml( int n) {
StringBuilder sb = new StringBuilder ();

sb.append( "<root>" );

for ( int i = 0; i < n; i++) {
sb.append( "<node><i>\n" )
.append(i)
.append( "</i></node>\n" );
}

sb.append( "</root>" );

return sb.toString();
}

private static void timeIt( String name, Runnable runnable) {
long t0 = System.currentTimeMillis();
runnable.run();
long t1 = System.currentTimeMillis();

System. out .println(name + " executed " + ((t1 - t0) / 1000f) + "sec." );
}
}

* This source code was highlighted with Source Code Highlighter .

और यहाँ काम का परिणाम है:

Nodes number=5000
Sum=12497500
Simple iterate executed 17.359sec.
Sum=12497500
Iterate with cloning executed 1.047sec.
Sum=12497500
Iterate with detaching node executed 1.031sec.