# Baumstruktur in JSP mit ein- und ausklappen aus XML-Datei erstellen



## riseX (2. Mai 2007)

Hallo,

ich habe eine XML-Datei ... die ist mehr oder minder immer ziemlich gleich ... ich versuche nun mir eine JSP Datei zusammenzubasteln.

Irgendwie stehe ich da aufm Schlauch ... auch habe ich keinerlei Erfahrung mit der Verarbeitung von XML-Dateien in Java.

Ich muss ja auch irgendwie wissen, welche Node ich habe mit welchen Attributen ... welche Kinder diese Node hat und wieviele Unterebenen?

Gibts da vielleicht irgendwas Fertiges oder hat jemand schon was in der Richtung gemacht?


```
public CXMLHandler( String filename ) { 
    try {
        // ---- Parse XML file ----
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        factory.setNamespaceAware( true );

        // factory.setValidating( true );
        DocumentBuilder builder  = factory.newDocumentBuilder();
        document = builder.parse( new File( filename ) );

        Node rootNode = document.getDocumentElement();
		
	} catch (ParserConfigurationException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (SAXException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	} catch (IOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
}
```

Mhh das ist mehr oder minder mein Anfang ... leider habe ich keinen weiteren Ansatz. Ich hätte gern eine JSP Datei in der ich die einzelnen Nodes anklicken kann ... und die unteren sich halt einklappen etc.

Wäre für jede Hilfe dankbar.

Gruß vom riseX


----------



## Andron (2. Mai 2007)

Ich mache das durch das Servlet.
Das Servlet hat eine Instanz der Klasse XMLParser.
Hier ist die komplette Klasse:


```
import org.jdom.Document;
import org.jdom.Element;
import org.jdom.JDOMException;
import org.jdom.input.SAXBuilder;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;

public class XMLParser
{

	private Document doc = new Document();
	
	private SAXBuilder builder = new SAXBuilder();

	private Element root = null;

	private Logger logger = Logger.getLogger(XMLParser.class);

	
	HeapMemoryMonitor memoryMonitor = new HeapMemoryMonitor();
	
	
	
	public XMLParser()
	{
		
	}

	// xml-file finden
	public Element searchDoc(String datei)
	{
		logger.debug("[XMLParser] Parse Datei: " + datei);
		
		File tempFile = new File(datei);
		logger.debug("[XMLParser] searchDoc - Dateipfad: "+tempFile.getPath());

		if (tempFile.exists())
		{
			logger.debug("[XMLParser] searchDoc - Datei: " + datei
					+ " wurde lokalisiert");
			try
			{				
				doc = builder.build(tempFile);
				root = readXml(doc);
			}
			catch (JDOMException e)
			{
				logger.debug("[XMLParser] searchDoc - Fehler JDOMException");
				e.printStackTrace();
			}
			catch (IOException e)
			{
				logger.debug("[XMLParser] searchDoc - Fehler IOException");
				e.printStackTrace();
			}
			logger.debug("[XMLParser] searchDoc - RootElement: "
					+ root.getName());
			return root;
		}
		else
		{
			logger.debug("[XMLParser] searchDoc - Datei: " + datei
					+ " konnte nicht gefunden werden");
		}
		return null;
	}

	// Liest xml-file und gibt das root-Element zurück
	private Element readXml(Document doc) throws IOException
	{
		// Element project = doc.getRootElement();

		// Lesen der Projektparameter
		// String projectline = readProjectLine();

		Element rootelement = doc.getRootElement();
		if (rootelement != null)
			logger.debug("[XMLParser] ROOT ELEMENT GEFUNDEN: "
					+ rootelement.getName());
		else
			logger.debug("[XMLParser] ROOT ELEMENT NICHT DEFINIERT");
		// System.out.println("ROOT ELEMENT GEFUNDEN: "+rootelement.getName());
		return rootelement;
	}

	public void writeXML(String datei) throws JDOMException, IOException
	{
		memoryMonitor.usage_monitor();
		String klasse =  new Throwable().getStackTrace()[0].getClassName();
		String methode =  new Throwable().getStackTrace()[0].getMethodName();
		String line = new Throwable().getStackTrace()[0].getLineNumber()+"";
		logger.debug("[XMLParser] writeXML ----------------- DEBUG ---------------------");
		logger.debug("[XMLParser] writeXML - Aufruf von Klasse: "+klasse);
		logger.debug("[XMLParser] writeXML - Aufruf von Methode: "+methode);
		logger.debug("[XMLParser] writeXML - Aufruf von Line: "+line);
		logger.debug("[XMLParser] writeXML - Datei: " + datei);
		logger.debug("[XMLParser] writeXML - Root: " + this.root.getName());
		XMLOutputter outputter = new XMLOutputter(Format.getPrettyFormat());
		FileOutputStream output = new FileOutputStream(datei);
		logger.debug("[XMLParser] writeXML - Document: " + doc.getBaseURI());
		logger.debug("[XMLParser] writeXML - Document-Root: " + doc.getRootElement().getName());
		outputter.output(doc, output);
		output.close();
		logger.debug("[XMLParser] writeXML ------------------- ENDE --------------------");
		memoryMonitor.usage_monitor();
	}
	
	public void createNewXML(String filename, Element rt) throws IOException, JDOMException
	{
		File f = new File(filename);
		logger.debug("[XMLParser] createNewXML - Datei existiert nicht: " + filename);
		logger.debug("[XMLParser] createNewXML - Pfad: " + f.getParent());
		boolean md = new File(f.getParent()).mkdir();
		logger.debug("[XMLParser] createNewXML - verzeichnisse erzeugt: " + md);
		boolean cr = f.createNewFile();
		logger.debug("[XMLParser] createNewXML - Datei erzeugt: " + cr);
		
		this.root = rt;
		doc = new Document(this.root);
		doc.setRootElement(this.root);
		
		logger.debug("[XMLParser] createNewXML - Document: " + doc.getBaseURI());
		logger.debug("[XMLParser] createNewXML - Document-Root: " + doc.getRootElement().getName());
		this.writeXML(filename);

	}

	// Vor allen Änderungen wird ein Backup erstellt
	public synchronized void createBackup(String datei) throws IOException
	{
		logger.debug("[XMLParser] createBackup - Datei: " + datei);
		Date d = new Date();
		SimpleDateFormat formater = new SimpleDateFormat();
		String pattern = "dd.MM.yy,H.mm.ss";
		formater.applyPattern(pattern);
		String formattedDate = formater.format(d);

		StringTokenizer tk = new StringTokenizer(datei, ".");
		String f = tk.nextToken();
		String t = tk.nextToken();
		String backfile = f + formattedDate + "." + t + ".bak";
		File file = new File(backfile);
		logger.debug("[XMLParser] createBackup - Filepfad: " + file.getAbsolutePath());
		try
		{
			file.createNewFile();
		}
		catch (IOException e)
		{
			e.printStackTrace();
		}
		logger.debug("[XMLParser] createBackup - File created: " + backfile);

		XMLOutputter outputter = new XMLOutputter(Format.getPrettyFormat());
		FileOutputStream output = new FileOutputStream(backfile);
		logger.debug("[XMLParser] createBackup - Document: " + doc.getBaseURI());
		logger.debug("[XMLParser] createBackup - Document-Root: " + doc.getRootElement().getName());
		outputter.output(doc, output);
	}

	public void deleteElement(String elementname)
	{
		// Finde aus allen Elementen das Element mit dem Attribut
		// name="elementname"
		logger.debug("[XMLParser] deleteElement - Element to delete: "
				+ elementname);
		List tasks = root.getChildren();
		for (int i = 0; i < tasks.size(); i++)
		{
			Element task = (Element) tasks.get(i);
			String name = task.getAttributeValue("name");
			logger.debug("[XMLParser] deleteElement - Element found: " + name);
			if (name.equals(elementname))
			{
				root.removeContent(task);
			}
			// root.removeChild("task");
		}
	}

}
```


----------

