Hoe gewijzigde gegevens in de database bijwerken met behulp van JTable?

Dit is een open vraag.

Voor mij heb je een paar opties...

Je zou kunnen...

Werk de database in realtime bij als de gegevens in de tabel worden gewijzigd.

Hiervoor moet u ofwel het TableModel . uitbreiden zodat u toegang heeft tot de setValue methode, waarmee u niet alleen de status van het model kunt bijwerken, maar ook de status van de database (ik zou de database bijwerken en als dit lukt, het model bijwerken, maar dat ben ik) OF een luisteraar aan het model koppelen en controleer op geschikte TableChanged evenementen en werk de database dienovereenkomstig bij.

Hoewel dit een mooie methode lijkt, loopt u het risico dat de gebruikersinterface "vastloopt" terwijl de database wordt bijgewerkt of niet meer synchroon loopt met wat er in het model en in de database staat...

Je zou kunnen...

Maak een Class die de gegevens uit de database vertegenwoordigt. Wanneer een waarde binnen dit object wordt gewijzigd, zou u gewoon een vlag omhoog brengen om aan te geven dat de rij is gewijzigd.

Wanneer de gebruiker klaar is met het aanbrengen van wijzigingen in de tabelgegevens, klikt hij op "opslaan". U zou dan door alle objecten lopen en bepalen welke moeten worden bijgewerkt en deze weer in de database "opslaan".

Dit heeft het potentieel om "verouderde" gegevens terug te schrijven naar de database (dwz gebruiker A laadt de gegevens en begint wijzigingen aan te brengen. Gebruiker B laadt in de tussentijd de gegevens, brengt wijzigingen aan en slaat deze weer op in de database. Gebruiker A slaat vervolgens zijn wijzigingen op en overschrijft enkele van de wijzigingen die gebruiker B al heeft doorgevoerd)

Er zijn manieren om beide op te lossen, maar u moet beslissen welke aanpak het beste past bij uw huidige probleem, realtime of vertraagde updates...

Bijgewerkt met basisvoorbeeld

Het eerste dat u moet doen, is beginnen met het maken van een klasse die de gegevens uit uw database vertegenwoordigt. Normaal gesproken zou ik beginnen met een Interface en gebruik een soort fabriek om de daadwerkelijke implementatie te genereren, maar kleine stappen...

Dit heeft een zeer belangrijke variabele, hasChanged . Dit wordt gebruikt om aan te geven dat het object moet worden bijgewerkt...

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

Vervolgens hebben we een tafelmodel gebouwd waarmee een lijst met objecten kan worden gemodelleerd...

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

Er zijn een aantal manieren om hetzelfde te bereiken, maar in feite heb ik hier een methode gegeven met de naam getChangedPeople die alle People . teruggeeft die zijn veranderd. U kunt dan gewoon door deze lijst bladeren en de juiste database-update-instructie oproepen.