¿Cómo actualizar los datos modificados en la base de datos usando JTable?

Esta es una pregunta abierta.

Para mí, tienes algunas opciones...

Podrías...

Actualice la base de datos en tiempo real a medida que se modifican los datos dentro de la tabla.

Esto requeriría que extiendas el TableModel para que tenga acceso a setValue método, que le permitiría no solo actualizar el estado del modelo, sino también actualizar el estado de la base de datos (actualizaría la base de datos y, cuando tenga éxito, actualizaría el modelo, pero ese soy yo) O adjuntar un oyente al modelo y monitoree los TableChanged apropiados eventos y actualice la base de datos en consecuencia.

Si bien parece un buen método, corre el riesgo de "colgar" la interfaz de usuario mientras se actualiza la base de datos o perder la sincronización con lo que hay en el modelo y lo que hay en la base de datos...

Podrías...

Crear una Class que representa los datos de la base de datos. Cuando se cambia un valor dentro de este objeto, simplemente levantaría una bandera que indica que la fila ha cambiado.

Cuando el usuario haya terminado de realizar cambios en los datos de la tabla, hará clic en "guardar". Luego recorrería todos los objetos y determinaría cuáles necesitan actualizarse y "guardarlos" de nuevo en la base de datos.

Esto tiene el potencial de permitir que los datos "obsoletos" se vuelvan a escribir en la base de datos (es decir, el usuario A carga los datos y comienza a realizar cambios. Mientras tanto, el usuario B carga los datos, realiza cambios y los guarda en la base de datos. El usuario A luego guarda sus cambios, sobrescribiendo algunos de los cambios que el usuario B ya ha realizado)

Existen enfoques para resolver ambos, pero debe decidir cuál se adapta mejor a su problema actual, actualizaciones en tiempo real o retrasadas...

Actualizado con un ejemplo básico

Lo primero que debe hacer es comenzar creando una clase que represente los datos de su base de datos. Normalmente, comenzaría con una Interface y usar algún tipo de fábrica para generar la implementación real, pero pequeños pasos...

Esto tiene una variable muy importante, hasChanged . Esto se usa para marcar que el objeto necesita ser actualizado...

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

A continuación, construimos un modelo de tabla capaz de modelar una lista de objetos...

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

Hay varias formas de lograr lo mismo, pero básicamente aquí proporcioné un método llamado getChangedPeople que devolverá todas las People que han cambiado. Luego, simplemente recorrería esta lista y llamaría a la declaración de actualización de la base de datos adecuada.