Come aggiornare i dati modificati nel database utilizzando JTable?

Questa è una domanda aperta.

Per me, hai alcune opzioni...

Potresti...

Aggiorna il database in tempo reale man mano che i dati vengono modificati all'interno della tabella.

Ciò richiederebbe di estendere il TableModel quindi hai accesso a setValue metodo, che ti consentirebbe non solo di aggiornare lo stato del modello, ma anche di aggiornare lo stato del database (aggiornerei il database e, in caso di successo, aggiornerei il modello, ma sono io) OPPURE allegare un listener al modello e monitorare il TableChanged appropriato eventi e aggiornare il database di conseguenza.

Anche se questo sembra un bel metodo, corri il rischio di "bloccare" l'interfaccia utente mentre il database è stato aggiornato o di perdere la sincronizzazione con ciò che è nel modello e ciò che è nel database...

Potresti...

Crea un Class che rappresenta i dati del database. Quando un valore viene modificato all'interno di questo oggetto, devi semplicemente alzare un flag che indica che la riga è cambiata.

Quando l'utente ha finito di apportare modifiche ai dati della tabella, fa clic su "salva". Dovresti quindi esaminare tutti gli oggetti e determinare quali devono essere aggiornati e "salvarli" nel database.

Ciò ha il potenziale per consentire la riscrittura di dati "non aggiornati" nel database (cioè l'utente A carica i dati e inizia a apportare modifiche. L'utente B nel frattempo carica i dati, apporta modifiche e li salva di nuovo nel database. L'utente A salva quindi le modifiche, sovrascrivendo alcune delle modifiche già salvate dall'utente B)

Esistono approcci per risolverli entrambi, ma è necessario decidere quale approccio si adatta meglio al problema attuale, aggiornamenti in tempo reale o ritardati...

Aggiornato con un esempio di base

La prima cosa da fare è iniziare creando una classe che rappresenti i dati del tuo database. Normalmente, inizierei con un'Interface e utilizzare una sorta di fabbrica per generare l'implementazione effettiva, ma piccoli passi...

Questo ha una variabile molto importante, hasChanged . Viene utilizzato per segnalare che l'oggetto deve essere aggiornato...

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;
        }
    }
}

Successivamente abbiamo costruito un modello di tabella in grado di modellare un elenco di oggetti...

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);
        }
    }
}

Esistono molti modi per ottenere la stessa cosa, ma in pratica qui ho fornito un metodo chiamato getChangedPeople che restituirà tutte le People che sono cambiati. Dovresti quindi scorrere semplicemente questo elenco e chiamare l'istruzione di aggiornamento del database appropriata.