Hallo,

wie extrahiere ich einen Teilbaum aus einem DOM-Document und Parse diesen als String?

<root>
<erster>
<...> </...>
</erster>

<zweiter>
<...> </...>
</zweiter>
</root>

Ich hätte nun gerne den Teilbaum "zweiter".
Und hätte es so gemacht:
NodeTree nTree = doc.getElementbyTagName("zweiter");
String meinBaum = nTree.toString();

Aber irgendwie klappt das nicht...

[Murray]

Zitat von wersi77

NodeTree nTree = doc.getElementbyTagName("zweiter");

Meinst Du org.wc3.dom.NodeList statt NodeTree? Wenn nicht: welche XML/DOM-Bibliothek willst Du verwenden?

Zitat von wersi77

String meinBaum = nTree.toString();

Das ist nicht so einfach.


Lösen könnte man das so:

try {
	
		//--- Datei parsen
		javax.xml.parsers.DocumentBuilder db = javax.xml.parsers.DocumentBuilderFactory.newInstance().newDocumentBuilder();
		org.w3c.dom.Document doc = db.parse( new java.io.FileInputStream( "myfile.xml"));
		
		//--- das erste Element mit dem Tag "<zweiter>" holen
		org.w3c.dom.NodeList nl = doc.getElementsByTagName( "zweiter");
		org.w3c.dom.Node n = nl.item( 0);
	
		//--- OutputStream fuer die Serialisierung vorbereiten
		java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
		
		//--- Teilbaum serialisieren
		javax.xml.transform.Transformer trans = javax.xml.transform.TransformerFactory.newInstance().newTransformer();
		trans.transform( new javax.xml.transform.dom.DOMSource( n), new javax.xml.transform.stream.StreamResult( baos));
		
		//--- Ergebnis in String überführen und ausgeben
		String str = baos.toString();
		System.out.println( str);
		
	} catch ( Exception e) {
		e.printStackTrace();
	}

Besten Dank...
Ist aber komplizierter als ich dachte...
Gibts da nichts einfacheres, zumal solche Methoden doch auf der Hand liegen...

[Murray]

Die APIs sind eigentlich wesentlich mächtiger; so kann man am Transformer noch diverse Einbstellungen vornehmen (Endocing, Formatierung, ...). Außerdem will man meistens eben nicht einfach nur einen String erzeugen, sondern braucht auch die Möglichkeit, z.B. in andere Streams schreiben zu lassen. Daher sind die javax.xml.* und org.w3c.dom.* APIs auf den ersten Blick sehr kompliziert. Es bietet sich meistens an, für die eigenen "Standardaufgaben" einen kleine Hilfsklasse zu schreiben, die das intern kapselt.

Bei mir sieht das so aus:

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.List;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
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.w3c.dom.NodeList;

import org.xml.sax.SAXException;

public class DOMHelper {

	private static DocumentBuilder DocBldr;
	private static Transformer Trans;
  
	  
	static {
		try {
		    DocBldr = DocumentBuilderFactory.newInstance().newDocumentBuilder();
		   
			Trans = TransformerFactory.newInstance().newTransformer();
		    Trans.setOutputProperty( OutputKeys.OMIT_XML_DECLARATION, "no");
			Trans.setOutputProperty( OutputKeys.INDENT, "yes");
			Trans.setOutputProperty( OutputKeys.STANDALONE, "yes");
			Trans.setOutputProperty( OutputKeys.ENCODING, "ISO-8859-1");
		   
  

		} catch ( Exception e) {
			e.printStackTrace();
		}
	}
   

	public static Element getChild( Node nd, String name)  {
	   
		NodeList nl = nd.getChildNodes();
		if ( nl == null) return null;
		int len = nl.getLength();
		if ( len == 0) return null;
		ArrayList<Element> eLst = new ArrayList<Element>();
		for ( int i=0; i<len; i++) {
			Node ni = nl.item( i);
			if ( ni instanceof Element) {
				Element ei = (Element)ni;
				if ( name.equals( ei.getTagName())) {
				    eLst.add( ei);
				}
			}		
		}
		len = eLst.size();
		if ( len == 0) return null;
		if ( len == 1) return eLst.get( 0);
		throw new IllegalArgumentException( "Tag-name " + name + " not unique in node " + nd);
	}
   
	public static String getChildAsText( Node nd, String name){
		Element e = getChild( nd, name);
		return (e == null) ? null : e.getTextContent();
	}

	public static List<Element> getChildren( Node nd) {
	   
		List<Element> lst = new ArrayList<Element>();
		NodeList nl = nd.getChildNodes();
		if ( nl != null) {
				int len = nl.getLength();
				for ( int i=0; i<len; i++) {
				    Node ni = nl.item( i);
				 if ( ni instanceof Element) {
					 lst.add( (Element)ni);
					}
				}
			}
	   
		return lst;	   
	}

	public static void output( Node nd, OutputStream out) throws TransformerException {

		synchronized ( Trans) {
			
			DOMSource src = new DOMSource( nd);
			Trans.transform( src, new StreamResult( out));
		}
	}

	public static synchronized Document parse( File f) throws IOException, SAXException {
	   
		return DocBldr.parse( new FileInputStream( f));
	}

	public static synchronized Document parse( InputStream in) throws IOException, SAXException {
	   
		return DocBldr.parse( in);
	}
   
	public static String serialize( Node nd) throws TransformerException {

		ByteArrayOutputStream baos = new ByteArrayOutputStream();
		output( nd, baos);
	   
		return baos.toString();
	}


}

Damit vereinfacht sich das Beispiel zu:

	try {
		org.w3c.dom.Document doc = DOMHelper.parse( new java.io.File( "myfile.xml"));
		org.w3c.dom.Node n = DOMHelper.getChild( doc.getDocumentElement(), "zweiter");
		String str = DOMHelper.serialize( n);
		System.out.println( str);
	} catch ( Exception e) {
		e.printStackTrace();
	}

Nicht schlecht.
So ähnlich haben wir das bestimmt irgendwo auch...
Allerdings gehen einige Funktionen in dem Wust unseres Projektes bei ca. 400000 Zeilen Code ein wenig unter...
Mal sehen, ob ich Deine Funktionen verwenden kann...

[sparrow]

JDom ist auch ein sehr guter XML-Parser, und meiner Meinung nach einfacher zu bedienen als die Standartimplementierung.

Die Lib gibts hier: http://www.jdom.org

Und ein gutes tut steht auf der Insel: http://www.galileocomputing.de/openb...00047C1F030100

[Murray]

JDOM ist näher an den Java-APIs als das W3C-DOM (welches ja eher sprachunabhängig definiert ist und daher - s. NodeList - Strukturen mitbringt, die eher gewöhnungbedürftig sind). Allerdings kann man sich auch hier mit dem Helper-Ansatz (s.o.) behelfen und sich Utilities schreiben, die z.B. eine org.w3c.dom.NodeList in eine java.util.List<org.w3c.Node> wandeln.

BTW: ich habe früher auch lieber mit JDOM gearbeitet

"//root/zweiter" :cool:

myNode.cloneNode(true)