Wie aktualisiere ich geänderte Daten in der Datenbank mithilfe von JTable?

Dies ist eine offene Frage.

Für mich haben Sie ein paar Möglichkeiten...

Du könntest...

Aktualisieren Sie die Datenbank in Echtzeit, wenn sich die Daten in der Tabelle ändern.

Dazu müssten Sie entweder das TableModel erweitern Sie haben also Zugriff auf setValue -Methode, mit der Sie nicht nur den Status des Modells, sondern auch den Status der Datenbank aktualisieren können (ich würde die Datenbank aktualisieren und bei Erfolg das Modell aktualisieren, aber das bin ich) ODER einen Listener an das Modell anhängen und auf entsprechende TableChanged überwachen Ereignisse und aktualisieren Sie die Datenbank entsprechend.

Obwohl dies nach einer netten Methode aussieht, laufen Sie Gefahr, dass die Benutzeroberfläche "hängt", während die Datenbank aktualisiert wird, oder dass sie nicht mehr mit dem übereinstimmt, was im Modell und was in der Datenbank ist ...

Du könntest...

Erstellen Sie eine Class die die Daten aus der Datenbank darstellt. Wenn ein Wert innerhalb dieses Objekts geändert wird, würden Sie einfach ein Flag setzen, das besagt, dass sich die Zeile geändert hat.

Wenn der Benutzer die Änderungen an den Tabellendaten abgeschlossen hat, klickt er auf „Speichern“. Sie würden dann alle Objekte durchgehen und bestimmen, welche aktualisiert werden müssen, und sie wieder in der Datenbank "speichern".

Dies kann dazu führen, dass "veraltete" Daten in die Datenbank zurückgeschrieben werden (dh Benutzer A lädt die Daten und beginnt mit der Änderung. Benutzer B lädt in der Zwischenzeit die Daten, nimmt Änderungen vor und speichert sie wieder in der Datenbank. Benutzer A speichert dann seine Änderungen und überschreibt einige der Änderungen, die Benutzer B bereits festgeschrieben hat)

Es gibt Lösungsansätze für beides, aber Sie müssen entscheiden, welcher Ansatz für Ihr aktuelles Problem am besten geeignet ist, Echtzeit- oder verzögerte Updates...

Aktualisiert mit grundlegendem Beispiel

Als Erstes erstellen Sie zunächst eine Klasse, die die Daten aus Ihrer Datenbank darstellt. Normalerweise würde ich mit einem Interface beginnen und verwenden Sie eine Art Factory, um die eigentliche Implementierung zu generieren, aber kleine Schritte ...

Dies hat eine sehr wichtige Variable, hasChanged . Dies wird verwendet, um zu kennzeichnen, dass das Objekt aktualisiert werden muss...

public class Person {

    private boolean hasChanged = false;

    private String firstName;
    private String lastName;

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

    public boolean hasChanged() {
        return hasChanged;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setFirstName(String value) {
        if (value == null ? firstName != null : !value.equals(firstName)) {
            firstName = value;
            hasChanged = true;
        }
    }

    public void setLastName(String value) {
        if (value == null ? lastName != null : !value.equals(lastName)) {
            lastName = value;
            hasChanged = true;
        }
    }
}

Als nächstes bauten wir ein Tabellenmodell, das in der Lage ist, eine Liste von Objekten zu modellieren...

public class PeopleTableModel extends AbstractTableModel {

    private List<Person> people;

    public PeopleTableModel() {
        people = new ArrayList<>(20);
    }

    public void addPerson(Person person) {
        people.add(person);
        fireTableRowsInserted(people.size() - 1, people.size() - 1);
    }

    public Person getPersonAt(int row) {
        return people.get(row);
    }

    public List<Person> getChangedPeople() {
        List<Person> changed = new ArrayList<>(people.size());

        for (Person p : people) {
            if (p.hasChanged()) {
                changed.add(p);
            }
        }

        return changed;    
    }

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

    @Override
    public String getColumnName(int column) {
        String name = null;
        switch (column) {
            case 0:
                name = "First name";
                break;
            case 1:
                name = "First name";
                break;
        }
        return name;
    }

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

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        Person p = people.get(rowIndex);
        Object value = null;
        switch (columnIndex) {
            case 0:
                value = p.getFirstName();
                break;
            case 1:
                value = p.getLastName();
                break;
        }
        return value;
    }

    @Override
    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
        if (aValue instanceof String) {
            Person p = people.get(rowIndex);
            switch (columnIndex) {
                case 0:
                    p.setFirstName(aValue.toString());
                    break;
                case 1:
                    p.setLastName(aValue.toString());
                    break;
            }
            fireTableRowsUpdated(rowIndex, rowIndex);
        }
    }
}

Es gibt eine Reihe von Möglichkeiten, dasselbe zu erreichen, aber im Grunde habe ich hier eine Methode namens getChangedPeople bereitgestellt was alle People zurückgibt die sich geändert haben. Sie würden dann einfach diese Liste durchlaufen und die entsprechende Datenbankaktualisierungsanweisung aufrufen.