# JTable per DOMReader befüllen



## tb303 (8. Jan 2008)

Hallo,

Ich habe ein Programm geschrieben was Daten per GUI in eine ArrayList schreibt. Diese ArrayLisst speichere ich wie folgt als XML ab:


```
import org.w3c.dom.*;
import org.apache.xerces.dom.DOMImplementationImpl;
import org.apache.xml.serialize.*;
import java.io.*;
import java.util.ArrayList;

public class RecordListGenerator {
    
    private ArrayList<Album> alben;
    private XMLGui gui;

public RecordListGenerator(ArrayList<Album> alben, XMLGui gui) 
{
    this.alben = alben;
    this.gui = gui;
}    
public void writeXML(String xmlFile, Document doc)
    {
        try
        {
            FileWriter writer = new FileWriter(new File(xmlFile));            
            OutputFormat formatter = new OutputFormat();            
            formatter.setEncoding("ISO-8859-1");            
            formatter.setIndenting(true);            
            formatter.setIndent(5);
            formatter.setLineSeparator("\r\n");
            XMLSerializer serializer = new XMLSerializer(writer, formatter);
            serializer.serialize(doc);
        }
        catch (Exception ex)
        {
            System.out.println("Fehler: " + ex.getMessage());
        }
    }

public Document createDom()
    {
        Document doc = null;
        if (!alben.isEmpty())
        {
            DOMImplementationImpl domImpl = new DOMImplementationImpl();
        
            doc  = domImpl.createDocument(null, "RecordList", null);
            //DTD
            DocumentType docType = domImpl.createDocumentType("RecordList", null, "RecordList.dtd");
            doc.appendChild(docType);            
            
            int anzahl = 1;
            
            for (Album a : alben)
            {
                Element elRecord = doc.createElement("Record");
                elRecord.setAttribute("Record_ID", "_000" + anzahl);
                elRecord.setAttribute("CatalogID", a.getcatalogid());
                elRecord.setAttribute("Format", a.getformat());
                
                Element elArtist = doc.createElement("Artist");
                Text tnArtist = doc.createTextNode(a.getartist());
                elArtist.appendChild(tnArtist);
                
                Element elTitle = doc.createElement("Title");
                Text tnTitle = doc.createTextNode(a.gettitle());
                elTitle.appendChild(tnTitle);
                
                Element elRecordlabel = doc.createElement("Recordlabel");
                Text tnReclabel = doc.createTextNode(a.getreclabel());
                elRecordlabel.appendChild(tnReclabel);
                
                Element elGenre = doc.createElement("Genre");
                Text tnGenre= doc.createTextNode(a.getgenre());
                elGenre.appendChild(tnGenre);
                
                elRecord.appendChild(elArtist);
                elRecord.appendChild(elTitle);
                elRecord.appendChild(elRecordlabel);
                elRecord.appendChild(elGenre);
                
                doc.getDocumentElement().appendChild(elRecord);
                anzahl ++;
            }
    }     
  return doc;      
 }
    public void domWrite(String xmlFile)
    {
        writeXML(xmlFile, createDom());
    }
    
}
```

In einem anderen JFrame (das sich per Button klick auf der GUI öffnet) habe ich jetzt eine JTable. Diese JTable soll mit Daten die aus der XML gelesen werden (DOMReader) aufgefüllt werden. Also beim Buttonklick auf "Tabelle anzeigen" soll das JFrame mit der Tabelle geöffnet werden und die aktuelle Datei dort darstellen.

Hier ein Test von mir (im Java codebook gesehen   )


```
import org.apache.xerces.parsers.DOMParser;
import org.w3c.dom.Node;
import org.xml.sax.SAXException;
import java.io.IOException;

public class DomReader
{
public void domRead(String documentName) 
{
// Parser zum Einlesen des Dokuments erzeugen
DOMParser parser = new DOMParser();
    try {
    // Dokument einlesen
    parser.parse(documentName);
    // Dokument verarbeiten
    analyze(parser.getDocument());
    } catch (SAXException e) {
    e.printStackTrace();
    } catch (IOException e) {
    e.printStackTrace();
    }
}
/**
* Analysiert den übergebenen Knoten
* @param node Zu analysierender Knoten
*/
private void analyze(Node node) {
    // Wenn es sich um einen Text-Knoten handelt, Inhalt ausgeben
    if(node != null &&
    node.getNodeType() == Node.TEXT_NODE) {
    // Wert lokal zwischenspeichern
    String value = node.getNodeValue().trim();
    // Wenn Textinhalt vorhanden, dann ausgeben
    if(value.length() > 0) {
    System.out.println(String.format("Wert: %s", value));
    }
    } else {
    // Name des Knotens ausgeben
    System.out.println(
    String.format("Gefundendes Element: %s",
    node.getNodeName()));
    // Überprüfen, ob untergeordnete Knoten existieren
    if(node.hasChildNodes()) {
    // Alle untergeordneten Knoten durchlaufen
        for(int i=0,
        items = node.getChildNodes().getLength();
        i<items;i++) {
        // Aktuellen Knoten analysieren
        analyze(node.getChildNodes().item(i));
                }
         }
        }
    }
}
```

Das ist nur ein Test gewesen und würde so funktionieren. Nur würde ich jetzt gern meine Klasse die "TableView" heißt und die JTable enthält benutzen um auf das Dokument zugreifen zu können.

Ich wäre für Tipps sehr dankbar.[/quote]


----------



## André Uhres (9. Jan 2008)

```
class TableView ...{
...
            model = new DefaultTableModel(...);
            DomReader r = new DomReader(model);
            r.domRead("TestAlbum.xml");
...
}
public class DomReader {
    private DefaultTableModel model;
    private int column;
    public DomReader(DefaultTableModel model) {
        this.model = model;
    }
...
    private void analyze(Node node) {
        // Wenn es sich um einen Text-Knoten handelt, Inhalt ausgeben
        if (node != null &&
                node.getNodeType() == Node.TEXT_NODE) {
            // Wert lokal zwischenspeichern
            String value = node.getNodeValue().trim();
            // Wenn Textinhalt vorhanden, dann ausgeben
            if (value.length() > 0) {
                System.out.println(String.format("Wert: %s", value));
                model.setValueAt(value, model.getRowCount()-1, column);
            }
        } else {
            // Name des Knotens ausgeben
            String name = node.getNodeName();
            System.out.println(
                    String.format("Gefundendes Element: %s",
                    name));
            if(name.equals("Record")){
                model.addRow(new Object[]{null, null, null, null});
            }else if(name.equals("Artist")){
                column = 0;
            }else if(name.equals("Title")){
                column = 1;
            }else if(name.equals("Recordlabel")){
                column = 2;
            }else if(name.equals("Genre")){
                column = 3;
            }
            
            // Überprüfen, ob untergeordnete Knoten existieren
            if (node.hasChildNodes()) {
                // Alle untergeordneten Knoten durchlaufen
                for (int i = 0,  items = node.getChildNodes().getLength();
                        i < items; i++) {
                    // Aktuellen Knoten analysieren
                    analyze(node.getChildNodes().item(i));
                }
            }
        }
    }
}
```


----------



## tb303 (9. Jan 2008)

Also, ich habe nochmal umgebaut:

XmlDomBuilder.java


```
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;
import javax.swing.table.DefaultTableModel;
import org.apache.xerces.parsers.DOMParser;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;


public class XmlDomBuilder 
{
    private String xmlFile;
    private Document domDoc = null;
    private XMLOpenDialog dialog;
    private boolean valid;
    private DefaultTableModel recordListTable;
    private int column;
    
    public XmlDomBuilder(XMLOpenDialog dialog, String xmlFile)
    {
        this.dialog = dialog;
        this.xmlFile = xmlFile;
    }
    
    public Document domReader(boolean isValidate)
    {
            DOMParser parser = new DOMParser();
            ErrorHandler error = new ValidationError(dialog, valid, this);
            valid = true;
        try
        {
            parser.setFeature("http://xml.org/sax/features/validation", isValidate);
            parser.setFeature("http://apache.org/xml/features/dom/include-ignorable-whitespace", false);
            parser.setErrorHandler(error);
            parser.parse(xmlFile);
        } 
        catch (SAXException ex) 
        {
            Logger.getLogger(XmlDomBuilder.class.getName()).log(Level.SEVERE, null, ex);
        } 
        catch (IOException ex) 
        {
            Logger.getLogger(XmlDomBuilder.class.getName()).log(Level.SEVERE, null, ex);
        }
        domDoc = parser.getDocument();
        return domDoc;

    }
        
    private void analyze(Node node) 
    {
        // Wenn es sich um einen Text-Knoten handelt, Inhalt ausgeben
        recordListTable = new DefaultTableModel();
        if (node != null &&
                node.getNodeType() == Node.TEXT_NODE) {
            // Wert lokal zwischenspeichern
            String value = node.getNodeValue().trim();
            // Wenn Textinhalt vorhanden, dann ausgeben
            if (value.length() > 0) {
                recordListTable.setValueAt(value, recordListTable.getRowCount()-1, column);
            }
        } else {
            // Name des Knotens ausgeben
            String name = node.getNodeName();
            if(name.equals("Record")){
                recordListTable.addRow(new Object[]{null, null, null, null});
            }else if(name.equals("Artist")){
                column = 0;
            }else if(name.equals("Title")){
                column = 1;
            }else if(name.equals("Recordlabel")){
                column = 2;
            }else if(name.equals("Genre")){
                column = 3;
            }
           
            // Überprüfen, ob untergeordnete Knoten existieren
            if (node.hasChildNodes()) {
                // Alle untergeordneten Knoten durchlaufen
                for (int i = 0,  items = node.getChildNodes().getLength();
                        i < items; i++) {
                    // Aktuellen Knoten analysieren
                    analyze(node.getChildNodes().item(i));
                }
            }
        }
    }
    
    public void loadDom()
    {
        Document doc = domReader(true);
        if (valid)
        {
            
        }
            JOptionPane.showMessageDialog(dialog, "alles io", "Super geil", JOptionPane.OK_OPTION);
    }
     
    public void setValid(boolean valid) 
    {
        this.valid = valid;
    }

  
}
class ValidationError implements ErrorHandler
{
    private XMLOpenDialog dialog;
    private boolean valid;
    private XmlDomBuilder xdb;
    public ValidationError(XMLOpenDialog dialog, boolean valid, XmlDomBuilder xdb)
    {
        this.dialog = dialog;
        this.valid = valid;
        this.xdb = xdb;
    }
    
    public void warning(SAXParseException exception) throws SAXException 
    {
        JOptionPane.showMessageDialog(dialog, exception.getMessage(),"Warnung!", 
                                 JOptionPane.WARNING_MESSAGE);
    }

    public void error(SAXParseException exception) throws SAXException 
    {
        JOptionPane.showMessageDialog(dialog, "Keine gültige Recordliste \n " + 
                                 exception.getMessage(),"Fehler", 
                                 JOptionPane.ERROR_MESSAGE);
        xdb.setValid(false);
    }

    public void fatalError(SAXParseException exception) throws SAXException 
    {
        JOptionPane.showMessageDialog(dialog, "Kein XML Dokument","Fehler", 
                                 JOptionPane.ERROR_MESSAGE);
        xdb.setValid(false);
    }
    
}
```

So,

jetzt habe ich das JFrame in dem die Tabelle und der Button für'S öffnen einer XML liegt (openButton). Wie bekomme ich jetzt den Inhalt des DOM doc in die JTable. Meine Ansätze / Ideen haben nicht wirklich funktioniert. Das mit dem DefaultTableModel verstehe ich nicht richtig 

hier die XMLOpenDialog.java


```
import java.io.File;
import javax.swing.JFileChooser;
import javax.swing.table.DefaultTableModel;

public class XMLOpenDialog extends javax.swing.JDialog {
    private DefaultTableModel model;
    private DefaultTableModel recordListTable;
    
    /** Creates new form XMLOpenDialog */
    public XMLOpenDialog(java.awt.Frame parent, boolean modal) {
        super(parent, modal);
        initComponents();
    }
    
    /** This method is called from within the constructor to
     * initialize the form.
     * WARNING: Do NOT modify this code. The content of this method is
     * always regenerated by the Form Editor.
     */
    // <editor-fold defaultstate="collapsed" desc="Generated Code">                          
    private void initComponents() {

        jToolBar1 = new javax.swing.JToolBar();
        openButton = new javax.swing.JButton();

        setDefaultCloseOperation(javax.swing.WindowConstants.DISPOSE_ON_CLOSE);

        jToolBar1.setRollover(true);

        openButton.setText("öffnen");
        openButton.setFocusable(false);
        openButton.setHorizontalTextPosition(javax.swing.SwingConstants.CENTER);
        openButton.setVerticalTextPosition(javax.swing.SwingConstants.BOTTOM);
        openButton.addActionListener(new java.awt.event.ActionListener() {
            public void actionPerformed(java.awt.event.ActionEvent evt) {
                openButtonActionPerformed(evt);
            }
        });

        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
        getContentPane().setLayout(layout);
        layout.setHorizontalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
                    .addComponent(jToolBar1, javax.swing.GroupLayout.PREFERRED_SIZE, 100, javax.swing.GroupLayout.PREFERRED_SIZE)
                    .addComponent(openButton))
                .addContainerGap(300, Short.MAX_VALUE))
        );
        layout.setVerticalGroup(
            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
            .addGroup(layout.createSequentialGroup()
                .addComponent(jToolBar1, javax.swing.GroupLayout.PREFERRED_SIZE, 25, javax.swing.GroupLayout.PREFERRED_SIZE)
                .addGap(221, 221, 221)
                .addComponent(openButton)
                .addContainerGap(77, Short.MAX_VALUE))
        );

        pack();
    }// </editor-fold>                        

    private void openButtonActionPerformed(java.awt.event.ActionEvent evt) {                                           
        String xmlFile ="";
        JFileChooser jfc = new JFileChooser();
        jfc.setCurrentDirectory(new File("."));
        jfc.setAcceptAllFileFilterUsed(false);
        int result = jfc.showOpenDialog(this);
        if ( result == JFileChooser.APPROVE_OPTION )
        {
//            xmlFile = jfc.getSelectedFile().getPath();
//            XmlDomBuilder xdb = new XmlDomBuilder(this, xmlFile);
//           recordListTable.setModel(xdb.buildTable());
//
//            
//        }
//        XmlDomBuilder xdb = new XmlDomBuilder(this, xmlFile);
//        model = new DefaultTableModel();
//        DomReader r = new DomReader(model);
//        xdb.loadDom("TestAlbum.xml");
//   
    }                                          
    }
    /**
     * @param args the command line arguments
     */
    public static void main(String args[]) {
        java.awt.EventQueue.invokeLater(new Runnable() {
            public void run() {
                XMLOpenDialog dialog = new XMLOpenDialog(new javax.swing.JFrame(), true);
                dialog.addWindowListener(new java.awt.event.WindowAdapter() {
                    @Override
                    public void windowClosing(java.awt.event.WindowEvent e) {
                        System.exit(0);
                    }
                });
                dialog.setVisible(true);
            }
        });
    }
    
    // Variables declaration - do not modify                     
    private javax.swing.JToolBar jToolBar1;
    private javax.swing.JButton openButton;
    // End of variables declaration                   
    
}
```
[/code]


----------



## André Uhres (9. Jan 2008)

Falls du nicht weisst wozu ein TableModel gut ist, dann schau doch mal in das JTable Tutorial in den FAQ :wink:


----------

