XML --- Daten ausgeben

[megachucky]

ich komm mal wieder mit nem ganz einfachen einstiegs-problem nicht weiter.

habe folgende XML datei:

<?xml version="1.0" encoding="ISO-8859-1"?>
<buch 
  auflage="2">

  

  <titel>C für Windows</titel> 
  <autor>
    <name>Erlenkötter</name> 
    <vorname>Helmut</vorname> 
  </autor>
  <autor>
    <name>Reher</name> 
    <vorname>Volker</vorname> 
  </autor>
  <verlag>Rowohlt</verlag> 
  <isbn>3-499-19234-9</isbn> 
  <seiten>240</seiten>
</buch>

der java code ist:

package test;

import java.io.*;         // 1
import org.xml.sax.*;     // 2
import org.xml.sax.helpers.DefaultHandler;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.parsers.SAXParser;

public class SAX extends DefaultHandler  // 3
{
static String dateiName;    // 4
static String elementName;

//---- main ----
public static void main(String args[])  // 5
{
if (args.length != 2)     // 6
{
 System.err.println    // 7
   ("Aufruf: SaxBsp01 <dateiname> <element>");
 System.exit(1);
}
dateiName = args[0];    // 8
elementName = args[1];      
DefaultHandler handler = new SAX();  // 9
}

//---- constructor ----
public SAX()         // 10
{
SAXParserFactory factory =  // 11
 SAXParserFactory.newInstance();
factory.setNamespaceAware(true);  // 12
try                 // 13
{
 SAXParser saxParser =   // 14
   factory.newSAXParser();
 saxParser.parse     // 15
   ( new File(dateiName), this);

} catch (Throwable t) { // 16
 t.printStackTrace();    // 17
}
System.exit(0);       // 18
}

//----------------------------------------------
//Überschreibe Methoden des SAX DocumentHandler 
//----------------------------------------------
public void startDocument() // 19
throws SAXException
{
System.out.println("Dokumentanfang"); // 20
}

public void endDocument() 
throws SAXException
{
System.out.println("\nDokumentende");
}


public void startElement    // 21
(String namespaceURI,
String lName,           // 22
String qName, 
Attributes attrs)     // 23
throws SAXException
{
if (lName.equals(elementName))  // 24
{
 System.out.println("\nELEMENT: "+lName);
 for(int x=0; x<attrs.getLength(); x++)  // 25
 {
   String localName=   // 26
     attrs.getLocalName(x);
   System.out.print("  ATTR : ");  // 27
   System.out.println(localName);
   System.out.println
     ("         "+attrs.getValue(x));
 }
}
}
}

ich komme einfach nicht drauf, wie ich nun den inhalt / text ausgeben kann, also zb "erlenkötter" oder "helmut".


mit folgendem code kann man die attribute ausgeben, aber ich finde irgend wie nirgends eine möglichkeit obiges auszugeben.

dachte zuerst ich muss es mit der methode "characters" machen, aber bringe es nicht zu stande. auch in der APi schaffe ich es nicht, die lösung zu finden.

kann mir da jemand kurz weiterhelfen?

 

[akira]

Die characters-Methode ist schon richtig, Du must dann nur noch einen String draus machen.

Oder wo genau kommst Du nicht weiter?

 

[megachucky]

mir ist ehrlich gesagt nicht ganz klar, wie ich da jetzt nen string draus mache.
wie greife ich jetzt zb nur auf alle vornamen zu?

 

[akira]

Einen String kannst du daraus wie folgt machen:

public void characters(char[] ch, int start, int length) {
    String str = new String(ch,start,length);
}

Laß Dir den String einfach mal ausgeben und probiere ein bischen rum.
Im Prizip wird bei jedem Tag zuerst die startElement-Methode aufgerufen, dann charachters und zum Schluß endElement.

 

[Bleiglanz]

vorsicht:

ein einziges Element <foo>a b c </foo> kann mehrere character Events erzeugen (erst a, dann b, dann c)

man muss einen StringBuffer nehmen und die zusammenhängen

 

[megachucky]

public void startElement(String uri, String localName, String qName,
			Attributes attributes)
	{
		if (localName.equals("name"))
				{
			System.out.println("\nELEMENT: " + localName);
				}
	}
	
	public void characters(char ch[], int start, int length)
	{
		for (int i = start; i < (start + length); i++)
		{
			System.out.print(ch[i]);
		}
			
	}

hab es nun nochmal probiert, so wie oben. allerdings wird nicht nur der name ausgegeben, sondern eben alle daten, also vorname, nachname, isbn, seiten (falls vorhanden).

und wie beschränke ich es nun zb nur auf vorname ausgeben? da ist mir einfach nicht klar, was ich in der for schleife (ich nehme an man macht es trotzdem mit ner for-schleife) angeben soll ?!?

 

[Bleiglanz]

du musst dir den Kontext merken (so ist das eben bei SAX) und für jedes "Element" einen eigenen String bauen

 

[akira]

Ok, ich poste mal den Code einer vor längerer Zeit von mir geschriebenen Klasse zum Einlesen einer XML-Datei in einen Objektbaum, vielleicht hilfts Dir weiter:

public class XMLFileReader extends DefaultHandler {
	
	private XMLNode current;
	
	private XMLFileReader(XMLNode root) {
		current = root;
	}	
	
	/**
	* einlesen einer XML-Datei in einen Baum
	* @param file XML-Datei
	* @return root-Knoten des erzeugten Baumes
	*/
	public static XMLNode read(File file)
	throws IOException, ParserConfigurationException, SAXException {
		XMLNode root = new XMLNode();
		XMLReader reader = SAXParserFactory.newInstance().newSAXParser().getXMLReader();
		reader.setContentHandler(new XMLFileReader(root));
		reader.parse(new InputSource(new FileInputStream(file)));
		return root;
	}
	
	public void startElement(String namespaceURI, String localName, String qName, Attributes atts) {
		XMLNode node = new XMLNode(qName);
		if(atts.getLength()>0) {
			for(int i=0;i<atts.getLength();i++) node.addAttribute(atts.getQName(i), atts.getValue(i));
		}	
		current.addChild(node);
		current = node;
	}
	
	public void endElement(String namespaceURI, String localName, String qName) {
		current = current.getParent();	
	}
	
	public void characters(char[] ch, int start, int length) {
		boolean valid = false;
		for(int i=start;i<(start+length);i++) {
			if(!Character.isWhitespace(ch[i])) {
				valid = true;
				break;	
			}	
		} // wenn Zeichen außer Whitespaces vorkommen -> Wert setzen
		if(valid) current.setValue(new String(ch, start, length));
	}
}

Und hier die Knotenklasse:

public class XMLNode {
	
	private XMLNode parent;
	
	private String name;
	
	private Map attributes;
	
	private String value;
	
	private List children;
	
	/**
	* Konstruktor für root-Knoten
	*/
	XMLNode() {
		this("ROOT");
	}
	
	/**
	* Konstruktor für Unterknoten
	* @param name Name des Knotens
	*/
	XMLNode(String name) {
		this.name = name;
	}
	
	/**
	* Liefert den Eltern-Knoten
	* @return Eltern-Knoten
	*/
	public XMLNode getParent() {
		return parent;
	}
	
	/**
	* Testet, ob Knoten ein root ist
	* @return true, wenn root
	*/
	public boolean isRoot() {
		return parent==null;
	}
	
	/**
	* Liefert den Namen des Knotens
	* @return Name
	*/
	public String getName() {
		return name;
	}
	
	/**
	* Liefert den Wert (Inhalt) des Knotens
	* @return Wert
	*/
	public String getValue() {
		return value;
	}
	
	/**
	* liefert true, wenn der Wert des Knotens eins der folgenden Werte hat:
	* true, 1, yes, ja
	*/
	public boolean isTrue() {
		return "true".equals(value) ||
		       "1".equals(value) ||
		       "yes".equals(value) ||
		       "ja".equals(value);
	}
	
	
	/**
	* Liefert das Attribut mit dem übergebenen Namen
	* @return Wert des Attributes
	*/
	public String getAttribute(String name) {
		return attributes!=null?(String)attributes.get(name):null;
	}
	
	/**
	* Liefert true, wenn entsprechender Kindknoten vorh.
	*/
	public boolean hasNode(String name) {
		return getNode(name)!=null;
	}
	
	
	/**
	* liefert einen (den ersten, falls mehrere vorh.) Kind-Knoten
	* mit dem übergebenen Namen
	* @param name Namen des Knotens
	* @return Knoten
	*/
	public XMLNode getNode(String name) {
		XMLNode node = null;
		Iterator ic = children();
		while(ic.hasNext()) {
			XMLNode tmp = (XMLNode)ic.next();
			if(tmp.name.equals(name)) {
				node = tmp;
				break;	
			}	
		}
		return node;
	}
	
	/**
	* liefert eine Collection aller Kind-Knoten mit diesem Namen
	* @param name Name des Knotens
	* @return Collection aller Knoten dieses Namens
	*/
	public Collection getNodes(String name) {
		Collection col = new LinkedList();	
		Iterator ic = children();
		while(ic.hasNext()) {
			XMLNode tmp = (XMLNode)ic.next();
			if(tmp.name.equals(name)) col.add(tmp);
		}
		return col;
	}
	
	/**
	* Testet, ob Kind-Knoten vorhanden sind
	* @return true, wenn Kind-Knoten vorh.
	*/
	public boolean hasChildren() {
		return children!=null;
	}
	
	/**
	* Liefert alle Kind-Knoten (nicht rekursiv!)
	* @return Iterator über alle Kind-Knoten
	*/
	public Iterator children() {
		return hasChildren()?children.iterator():Collections.EMPTY_LIST.iterator();
	}
	
	
	void setValue(String value) {
		this.value = value;
	}
	
	void addAttribute(String key, String value) {
		if(attributes==null) attributes = new HashMap();
		attributes.put(key, value);	
	}
	
	void addChild(XMLNode child) {
		if(children==null) children = new LinkedList();
		child.parent = this;	
		children.add(child);
	} 
	
	/**
	* Liefert einen String-Repäsentation des Knotens einschliesslich aller Kind-Knoten
	* @return Baum als String
	*/
	public String toString() {
		return toString(this, 0);
	}
	
	private String toString(XMLNode node, int depth) {
		StringBuffer buf = new StringBuffer();
		for(int i=0;i<depth;i++) buf.append(" ");
		String tab = buf.toString();
		buf = new StringBuffer();
		buf.append(tab).append("[").append(node.name).append("]");
		if(node.value!=null) buf.append(" : ").append(node.value);
		buf.append("\n");
		if(node.attributes!=null) {
			Iterator ia = node.attributes.keySet().iterator();
			while(ia.hasNext()) {
				String key = (String)ia.next();
				buf.append(tab).append(" - ").append(key).append(" : ").append((String)node.attributes.get(key)).append("\n");	
			}
		}
		if(node.children!=null) {
			Iterator ic = node.children.iterator();
			while(ic.hasNext()) buf.append(toString((XMLNode)ic.next(), depth+4));	
		}
		return buf.toString();
	}
}

 

[megachucky]

hm, da der quellcode doch schon ziemlich groß ist, der gepostet wurde, ist es wohl sinnvoller für mein ziel gleich DOM zu benutzen als SAX, oder?