Hallo zusammen, ich baue mir ein XML-Dokument mit einer Klasse, die für das einfügen und traversieren im Dokument zuständig ist. Die Klasse sieht folgendermaßen aus:
Ich kann dann mit Aufrufen wie "new XMLParser("").add("A").up().add("B").toXML();" Ein XML String erstellen.
Mit kleinen Dokumenten geht das auch, aber wenn das XML-Dokument zu groß wird, dann bekomme ich im letzten Schritt bei transformer.transform(...) einen Stackoverflow:
Hat jemand eine Idee für mich, wie ich - ohne die JVM umzuschrauben - das Prozedere Stack-freundlicher gestalten kann?
Java:
import java.io.StringWriter;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
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.Node;
import org.xembly.ImpossibleModificationException;
public class XMLParser {
private Document doc;
private Node currentNode;
public XMLParser(String path) {
try {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();
doc = builder.newDocument();
currentNode = doc.createElement("Root");
((Element) currentNode).setAttribute("Path", path);
doc.appendChild(currentNode);
} catch (ParserConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
public XMLParser add(String name){
currentNode = currentNode.appendChild(doc.createElement(name));
return this;
}
public XMLParser attr(String name, String value){
((Element) currentNode).setAttribute(name, value);
return this;
}
public XMLParser set(String value){
currentNode = currentNode.appendChild(doc.createTextNode(value));
return this;
}
public XMLParser up(){
currentNode = currentNode.getParentNode();
return this;
}
public String toXML() throws ImpossibleModificationException{
final Transformer transformer;
try {
transformer = TransformerFactory.newInstance().newTransformer();
} catch (final TransformerConfigurationException ex) {
throw new IllegalStateException(ex);
}
transformer.setOutputProperty(OutputKeys.INDENT, "yes");
transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "3");
final StringWriter writer = new StringWriter();
try {
transformer.transform(
new DOMSource(doc),
new StreamResult(writer)
);
} catch (final TransformerException ex) {
throw new IllegalArgumentException(ex);
}
return writer.toString();
}
}
Ich kann dann mit Aufrufen wie "new XMLParser("").add("A").up().add("B").toXML();" Ein XML String erstellen.
Mit kleinen Dokumenten geht das auch, aber wenn das XML-Dokument zu groß wird, dann bekomme ich im letzten Schritt bei transformer.transform(...) einen Stackoverflow:
Code:
Exception in thread "main" java.lang.StackOverflowError
at com.sun.org.apache.xml.internal.serializer.ToStream.characters(Unknown Source)
at com.sun.org.apache.xml.internal.serializer.ToUnknownStream.characters(Unknown Source)
at com.sun.org.apache.xml.internal.serializer.ToUnknownStream.characters(Unknown Source)
at com.sun.org.apache.xalan.internal.xsltc.trax.DOM2TO.parse(Unknown Source)
at com.sun.org.apache.xalan.internal.xsltc.trax.DOM2TO.parse(Unknown Source)
at com.sun.org.apache.xalan.internal.xsltc.trax.DOM2TO.parse(Unknown Source)
at com.sun.org.apache.xalan.internal.xsltc.trax.DOM2TO.parse(Unknown Source)
at com.sun.org.apache.xalan.internal.xsltc.trax.DOM2TO.parse(Unknown Source)
at com.sun.org.apache.xalan.internal.xsltc.trax.DOM2TO.parse(Unknown Source)
at com.sun.org.apache.xalan.internal.xsltc.trax.DOM2TO.parse(Unknown Source)
at com.sun.org.apache.xalan.internal.xsltc.trax.DOM2TO.parse(Unknown Source)
at com.sun.org.apache.xalan.internal.xsltc.trax.DOM2TO.parse(Unknown Source)
at com.sun.org.apache.xalan.internal.xsltc.trax.DOM2TO.parse(Unknown Source)
...[1000 Zeilen lang]
Hat jemand eine Idee für mich, wie ich - ohne die JVM umzuschrauben - das Prozedere Stack-freundlicher gestalten kann?