Comment mettre à jour les données modifiées dans la base de données à l'aide de JTable ?

Ceci est une question ouverte.

Pour moi, vous avez quelques options...

Vous pourriez...

Mettez à jour la base de données en temps réel au fur et à mesure que les données sont modifiées dans le tableau.

Cela vous obligerait soit à étendre le TableModel vous avez donc accès à setValue méthode, qui vous permettrait non seulement de mettre à jour l'état du modèle, mais également de mettre à jour l'état de la base de données (je mettrais à jour la base de données et en cas de succès, mettrais à jour le modèle, mais c'est moi) OU attachez un écouteur au modèle et surveiller les TableChanged appropriés événements et mettre à jour la base de données en conséquence.

Bien que cela semble être une bonne méthode, vous courez le risque de "bloquer" l'interface utilisateur pendant que la base de données est mise à jour ou de ne pas être synchronisée avec ce qui se trouve dans le modèle et ce qui se trouve dans la base de données...

Vous pourriez...

Créer une Class qui représente les données de la base de données. Lorsqu'une valeur est modifiée dans cet objet, vous lèverez simplement un indicateur indiquant que la ligne a changé.

Lorsque l'utilisateur a terminé d'apporter des modifications aux données du tableau, il clique sur "enregistrer". Vous parcourez ensuite tous les objets et déterminez ceux qui doivent être mis à jour et les "enregistrez" dans la base de données.

Cela a le potentiel de permettre aux données "périmées" d'être réécrites dans la base de données (c'est-à-dire que l'utilisateur A charge les données et commence à apporter des modifications. L'utilisateur B entre-temps charge les données, apporte des modifications et les enregistre dans la base de données. L'utilisateur A enregistre ensuite ses modifications, en écrasant certaines des modifications que l'utilisateur B a déjà validées)

Il existe des approches pour résoudre les deux, mais vous devez décider quelle approche convient le mieux à votre problème actuel, mises à jour en temps réel ou différées...

Mise à jour avec un exemple de base

La première chose à faire est de commencer par créer une classe qui représente les données de votre base de données. Normalement, je commencerais par une Interface et utiliser une sorte d'usine pour générer l'implémentation réelle, mais par petites étapes...

Cela a une variable très importante, hasChanged . Ceci est utilisé pour signaler que l'objet doit être mis à jour...

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

Ensuite nous avons construit un modèle de table capable de modéliser une liste d'objets...

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

Il existe un certain nombre de façons d'obtenir la même chose, mais en gros, j'ai fourni ici une méthode appelée getChangedPeople qui renverra tous les People qui ont changé. Vous feriez alors simplement une boucle dans cette liste et appelleriez l'instruction de mise à jour de la base de données appropriée.