JTable mit XML datei befüllen

[Marciixy]

HI!

Ich bin momentan dabei einen kleinen Vokabeltrainer zu schreiben und habe folgendes Problem:
Mein GUI-Fenster "Katalog" soll in der Lage sein Vokabeln anzulegen, Kataloge zu speichern, Kataloge zu laden und Vokabeln aus einem aktiven oder geladenen Katalog zu löschen.
Die beiden Punkte die nicht funktionieren sind das Löschen und das Laden.
Das laden an sich funktioniert nur es wird nicht in meiner GUI angezeigt und beim löschen bin ich völlig ratlos.

Dies ist der Aufruf in der GUI

//Laden Button
        JButton btnKatLaden = new JButton("Kat. laden");
        GridBagConstraints gbbtnKatLaden = new GridBagConstraints();
        gbbtnKatLaden.fill = GridBagConstraints.HORIZONTAL;
        gbbtnKatLaden.insets = new Insets(0, 0, 0, 5);
        gbbtnKatLaden.gridx = 1;
        gbbtnKatLaden.gridy = 4;
        btnKatLaden.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e) {
                write.katLaden(loadDialog());
            }
        });
        contentPane.add(btnKatLaden, gbbtnKatLaden);

Dies ist die aufegrufene Lade-Methode

public void katLaden(String filename) {
        SAXBuilder builder = new SAXBuilder();
        File xmlFile = new File(filename);
        try {
            Document doc = (Document) builder.build(xmlFile);
            Element rootNode = doc.getRootElement();
            List<Element> listvoks = rootNode.getChildren("Vokabel");
            for (int vokcount = 0; vokcount < listvoks.size(); vokcount++) {
                Vokabel vokabel = new Vokabel();
                Element voknode = (Element) listvoks.get(vokcount);
                vokabel.setVokabel(voknode.getChildText("Deutsch"));
                vokabel.setUebersetzung(voknode.getChildText("Uebersetzung"));
                ht.put(vokcount , vokabel);
                System.out.println(vokabel);
            }
        } catch (IOException io) {
            System.out.println("Katalog nicht gefunden");
        } catch (JDOMException e) {
            e.printStackTrace();
        }

Nun weiß ich allerdings nicht, wie die gefundenen Vokabeln in meine JList kommen sollen.

Zu meinem zweiten Problem:
GUI Aufruf um eine einzelne Vokabel aus der aktiven JTable entfernen:

btnDel.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                Vokabel vokabel = new Vokabel();
            }
        });

Und die dazu gehörige Methode:

public void vokDel(Vokabel vokabel) {
        ht.get(vokabel);
        ht.remove(vokabel);
        for (int count = 1; count < ht.size(); count++) {
            if (ht.isEmpty()) {
                System.out.println("Gefunden!");
            }
        }
    }

Über Hilfe eurerseits würde ich mich sehr freuen :bae:, da ich momentan nicht mehr weiterkomme.

 

[Flown]

So ich hab dir mal ein "kleines" KSKB gebastelt. Hier wird veranschaulicht wie man am besten mit MV(C) arbeitet. Wie die Listener angelegt werden sollen, usw.

Zur Verarbeitung der XML habe ich JAXB genommen (ist aber egal wie man das macht).

Spoiler: MainApp.java

package app;

import javax.swing.SwingUtilities;
import model.PersonManager;
import ui.PersonManagerUI;

public class MainApp {

  public static void main(String... args) {
    PersonManager pm = new PersonManager();
    SwingUtilities.invokeLater(new Runnable() {
      @Override
      public void run() {
        new PersonManagerUI(pm);
      }
    });
  }

}

Spoiler: Person.java

package model;

import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement(name = "person")
public class Person {

  private String firstName;
  private String lastName;

  public Person() {
  }

  public Person(String firstName, String lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
  }

  public String getFirstName() {
    return firstName;
  }

  public void setFirstName(String firstName) {
    this.firstName = firstName;
  }

  public String getLastName() {
    return lastName;
  }

  public void setLastName(String lastName) {
    this.lastName = lastName;
  }
}

Spoiler: PersonManager.java

package model;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import javax.xml.bind.JAXB;
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlElementWrapper;
import javax.xml.bind.annotation.XmlRootElement;
import model.listener.ModelListener;
import model.listener.event.ModelChangedEvent;

@XmlRootElement(namespace = "org.javaforum.xml")
@XmlAccessorType(XmlAccessType.NONE)
public class PersonManager {

  @XmlElementWrapper(name = "persons")
  @XmlElement(name = "person")
  private List<Person> persons;

  private List<ModelListener> listener;

  public PersonManager() {
    persons = new ArrayList<>();
    listener = new ArrayList<>();
  }

  public PersonManager(List<Person> persons) {
    this.persons = persons;
  }

  public List<Person> getPersons() {
    return persons;
  }

  public void setPersons(List<Person> persons) {
    this.persons = persons;
    fireModelChanged(persons);
  }

  public Person getPersonAt(int pos) {
    return persons.get(pos);
  }

  public Person removePersonAt(int pos) {
    Person p = persons.remove(pos);
    fireModelChanged(p, pos);
    return p;
  }

  public void addPerson(Person p) {
    persons.add(p);
    fireModelChanged(p);
  }

  public boolean removePerson(Person p) {
    if (persons.remove(p)) {
      fireModelChanged(p);
      return true;
    }
    return false;
  }

  protected <T> void fireModelChanged(T elem) {
    ModelChangedEvent<T> mce = new ModelChangedEvent<>(elem);
    for (ModelListener ml : listener) {
      ml.modelChanged(mce);
    }
  }

  protected <T> void fireModelChanged(T p, int pos) {
    ModelChangedEvent<T> mce = new ModelChangedEvent<>(p);
    for (ModelListener ml : listener) {
      ml.modelChangedAt(mce, pos);
    }
  }

  public static PersonManager loadFromFile(Path path) throws IOException {
    return JAXB.unmarshal(Files.newInputStream(path), PersonManager.class);
  }

  public static void saveToFile(Path path, PersonManager pm) throws IOException {
    JAXB.marshal(pm, Files.newOutputStream(path));
  }

  public void addModelListener(ModelListener ml) {
    listener.add(ml);
  }

  public boolean removeModelListener(ModelListener ml) {
    return listener.remove(ml);
  }
}

Spoiler: ModelListener.java

package model.listener;

import model.listener.event.ModelChangedEvent;

public interface ModelListener {

  <T> void modelChanged(ModelChangedEvent<T> evt);

  <T> void modelChangedAt(ModelChangedEvent<T> evt, int pos);
}

Spoiler: ModelChangedEvent.java

package model.listener.event;

public class ModelChangedEvent<T> {

  public final T obj;

  public ModelChangedEvent(T obj) {
    this.obj = obj;
  }
}

Spoiler: PersonManagerUI.java

package ui;

import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.File;
import java.io.IOException;
import javax.swing.Box;
import javax.swing.BoxLayout;
import javax.swing.JButton;
import javax.swing.JDialog;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.ListSelectionModel;
import javax.swing.filechooser.FileFilter;
import javax.swing.table.AbstractTableModel;
import model.Person;
import model.PersonManager;
import model.listener.ModelListener;
import model.listener.event.ModelChangedEvent;

public class PersonManagerUI implements ModelListener {

  private final PersonManager model;
  private MyTableModel tableModel;

  public PersonManagerUI(PersonManager model) {
    this.model = model;
    model.addModelListener(this);
    initUI();
  }

  private void initUI() {
    JFrame frame = new JFrame("Person Manager");
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setLocationByPlatform(true);

    JPanel mainPanel = new JPanel();
    mainPanel.setLayout(new BoxLayout(mainPanel, BoxLayout.Y_AXIS));

    tableModel = new MyTableModel();
    JTable table = new JTable(tableModel);
    table.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
    mainPanel.add(new JScrollPane(table));

    mainPanel.add(Box.createVerticalStrut(20));

    Box buttonBox = Box.createHorizontalBox();

    JButton addPersonBtn = new JButton("Add");
    addPersonBtn.addActionListener(new ActionListener() {

      @Override
      public void actionPerformed(ActionEvent e) {
        JDialog dialog = new JDialog(frame, "Add New Person");
        dialog.setLocationByPlatform(true);
        dialog.setResizable(false);
        JPanel dialogPanel = new JPanel();
        dialogPanel.setLayout(new BoxLayout(dialogPanel, BoxLayout.Y_AXIS));

        JPanel gridPanel = new JPanel(new GridBagLayout());
        GridBagConstraints gbc = new GridBagConstraints();
        JLabel firstNameLabel = new JLabel("First Name:");
        JTextField firstNameField = new JTextField(15);
        JLabel lastNameLabel = new JLabel("Last Name:");
        JTextField lastNameField = new JTextField(15);
        gbc.gridx = 0;
        gbc.gridy = 0;
        gbc.ipadx = 10;
        gbc.ipady = 5;
        gridPanel.add(firstNameLabel, gbc);
        gbc.gridx = 1;
        gbc.gridy = 0;
        gbc.ipadx = 0;
        gbc.ipady = 0;
        gridPanel.add(firstNameField, gbc);
        gbc.gridx = 0;
        gbc.gridy = 1;
        gbc.ipadx = 10;
        gbc.ipady = 5;
        gridPanel.add(lastNameLabel, gbc);
        gbc.gridx = 1;
        gbc.gridy = 1;
        gbc.ipadx = 0;
        gbc.ipady = 0;
        gridPanel.add(lastNameField, gbc);

        dialogPanel.add(Box.createVerticalStrut(20));
        dialogPanel.add(gridPanel);

        dialogPanel.add(Box.createVerticalStrut(20));

        Box dialogBtnPanel = Box.createHorizontalBox();

        JButton addBtn = new JButton("Add");
        addBtn.addActionListener(new ActionListener() {
          @Override
          public void actionPerformed(ActionEvent e) {
            model.addPerson(new Person(firstNameField.getText(), lastNameField.getText()));
            dialog.dispose();
          }
        });

        JButton cancelBtn = new JButton("Cancel");
        cancelBtn.addActionListener(new ActionListener() {

          @Override
          public void actionPerformed(ActionEvent e) {
            dialog.dispose();
          }
        });

        dialogBtnPanel.add(addBtn);
        dialogBtnPanel.add(Box.createHorizontalStrut(20));
        dialogBtnPanel.add(cancelBtn);

        dialogPanel.add(dialogBtnPanel);
        dialogPanel.add(Box.createVerticalStrut(20));

        dialog.add(dialogPanel);
        dialog.pack();
        dialog.setVisible(true);
      }
    });

    JButton removeBtn = new JButton("Remove");
    removeBtn.addActionListener(new ActionListener() {
      @Override
      public void actionPerformed(ActionEvent e) {
        if (!table.getSelectionModel().isSelectionEmpty()) {
          model.removePersonAt(table.getSelectedRow());
        }
      }
    });

    JButton saveBtn = new JButton("Save");
    saveBtn.addActionListener(new ActionListener() {

      @Override
      public void actionPerformed(ActionEvent e) {
        JFileChooser jfc = new JFileChooser();
        jfc.setFileSelectionMode(JFileChooser.FILES_ONLY);
        jfc.setAcceptAllFileFilterUsed(false);
        jfc.setFileFilter(new FileFilter() {

          @Override
          public boolean accept(File f) {
            return f.isDirectory() || f.getAbsolutePath().endsWith(".xml");
          }

          @Override
          public String getDescription() {
            return "xml";
          }
        });
        if (jfc.showSaveDialog(frame) == JFileChooser.APPROVE_OPTION) {
          try {
            File selected = jfc.getSelectedFile();
            if (!selected.getAbsolutePath().endsWith(".xml")) {
              selected = new File(selected.getAbsolutePath() + ".xml");
            }
            PersonManager.saveToFile(selected.toPath(), model);
          } catch (IOException ex) {
            JOptionPane.showMessageDialog(frame, ex.getMessage(), "Error occured", JOptionPane.ERROR_MESSAGE);
          }
        }
      }
    });

    JButton loadBtn = new JButton("Load");
    loadBtn.addActionListener(new ActionListener() {

      @Override
      public void actionPerformed(ActionEvent e) {
        JFileChooser jfc = new JFileChooser();
        jfc.setFileSelectionMode(JFileChooser.FILES_ONLY);
        jfc.setAcceptAllFileFilterUsed(false);
        jfc.setFileFilter(new FileFilter() {

          @Override
          public boolean accept(File f) {
            return f.isDirectory() || f.getAbsolutePath().endsWith(".xml");
          }

          @Override
          public String getDescription() {
            return "xml";
          }
        });
        if (jfc.showSaveDialog(frame) == JFileChooser.APPROVE_OPTION) {
          try {
            PersonManager pm = PersonManager.loadFromFile(jfc.getSelectedFile().toPath());
            setModel(pm);
          } catch (IOException ex) {
            JOptionPane.showMessageDialog(frame, ex.getMessage(), "Error occured", JOptionPane.ERROR_MESSAGE);
          }
        }
      }
    });

    buttonBox.add(addPersonBtn);
    buttonBox.add(Box.createHorizontalStrut(20));
    buttonBox.add(removeBtn);
    buttonBox.add(Box.createHorizontalStrut(20));
    buttonBox.add(loadBtn);
    buttonBox.add(Box.createHorizontalStrut(20));
    buttonBox.add(saveBtn);

    mainPanel.add(buttonBox);
    mainPanel.add(Box.createVerticalStrut(20));

    frame.add(mainPanel);

    frame.pack();
    frame.setVisible(true);
  }

  private void setModel(PersonManager pm) {
    model.setPersons(pm.getPersons());
  }

  @Override
  public <T> void modelChanged(ModelChangedEvent<T> evt) {
    tableModel.fireTableDataChanged();
  }

  @Override
  public <T> void modelChangedAt(ModelChangedEvent<T> evt, int pos) {
    tableModel.fireTableRowsDeleted(pos, pos);
  }

  class MyTableModel extends AbstractTableModel {

    @Override
    public int getRowCount() {
      return model.getPersons().size();
    }

    @Override
    public int getColumnCount() {
      return 2;
    }

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
      Person p = model.getPersonAt(rowIndex);
      if (columnIndex == 0) {
        return p.getFirstName();
      } else {
        return p.getLastName();
      }
    }
  }
}