tablemodellistener - setvalueat jtable java

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

Question

Hola usuarios de stackoverflow.

Me gustaría hacer algunas preguntas.

Actualmente puedo obtener los datos de la base de datos y mostrarlos en JTable. Además, me gustaría actualizar los datos en la Base de Datos que ha sido modificada en la JTable pero no sé cómo hacerlo. Encontré algunos ejemplos de lo que otras personas hicieron pero no funcionaron para mí.

Entonces mi pregunta es esta: ¿Importa cómo obtener y almacenar datos de la base de datos? Actualmente uso Array of String

public String getDBUnits  [][]; 

para almacenar y pasar datos de la base de datos y convertir la matriz en el vector y mostrar los datos usando una

table.setModel(new DefaultTableModel(getDBGrades,gradeHeader));

para mi JTable.

Conozco los diferentes métodos que se pueden usar para hacerlo, pero no sé cuál es mejor para mi situación.

Seré muy apreciado por obtener algún consejo o tutorial.

Gracias.

Ducky :)

PD: si alguien necesita un código de los métodos que uso para obtener datos de la Base de Datos, estaré encantado de publicarlos.

Answer 1

Esta es una pregunta abierta.

Para mí, tienes algunas opciones ...

Tú podrías...

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

Esto requeriría extender el setValue para tener acceso al método setValue , lo 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 tuviera éxito) , actualice el modelo, pero ese soy yo) O adjunte un oyente al modelo y supervise los eventos apropiados de TableChanged y actualice la base de datos en consecuencia.

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

Tú podrías...

Crea una Class que represente los datos de la base de datos. Cuando se cambia un valor dentro de este objeto, simplemente se levanta una bandera que indica que la fila ha cambiado.

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

Esto tiene el potencial de permitir que los datos "obsoletos" se escriban 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 de nuevo en la base de datos. El usuario A guarda sus cambios, sobrescribiendo algunos de los cambios que el usuario B ya cometió)

Existen enfoques para resolver ambos, pero debe decidir qué enfoque es el más adecuado para su problema actual, actualizaciones en tiempo real o diferidas ...

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

Luego 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 maneras 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á esta lista y llamará a la declaración de actualización de la base de datos apropiada.