JTable का उपयोग करके परिवर्तित डेटा को डेटाबेस में कैसे अपडेट करें?

यह एक खुला प्रश्न है।

मेरे लिए, आपके पास कुछ विकल्प हैं...

आप कर सकते हैं...

डेटाबेस को वास्तविक समय में अपडेट करें क्योंकि तालिका के भीतर डेटा बदल जाता है।

इसके लिए आपको या तो TableModel का विस्तार करना होगा इसलिए आपके पास setValue . तक पहुंच है विधि, जो आपको न केवल मॉडल की स्थिति को अपडेट करने की अनुमति देगी, बल्कि डेटाबेस की स्थिति को भी अपडेट करेगी (मैं डेटाबेस को अपडेट करूंगा और सफल होने पर, मॉडल को अपडेट करूंगा, लेकिन वह मैं हूं) या एक श्रोता को मॉडल में संलग्न करें और उपयुक्त के लिए मॉनिटर करें TableChanged घटनाओं और तदनुसार डेटाबेस को अद्यतन करें।

हालांकि यह एक अच्छी विधि की तरह दिखता है, जब डेटाबेस अपडेट किया जाता है या मॉडल में क्या है और डेटाबेस में क्या है, इसके साथ सिंक से बाहर होने पर आप UI को "हैंगिंग" करने का जोखिम उठाते हैं...

आप कर सकते हैं...

एक Class बनाएं जो डेटाबेस से डेटा का प्रतिनिधित्व करता है। जब इस ऑब्जेक्ट में कोई मान बदल दिया जाता है, तो आप केवल यह बताते हुए एक झंडा उठाएंगे कि पंक्ति बदल गई है।

जब उपयोगकर्ता तालिका डेटा में परिवर्तन करना समाप्त कर लेता है, तो वे "सहेजें" पर क्लिक करेंगे। फिर आप सभी वस्तुओं के माध्यम से चलेंगे और निर्धारित करेंगे कि किन वस्तुओं को अद्यतन करने की आवश्यकता है और उन्हें डेटाबेस में वापस "सहेजें"।

इसमें "पुराने" डेटा को डेटाबेस में वापस लिखने की अनुमति देने की क्षमता है (यानी उपयोगकर्ता ए डेटा लोड करता है और परिवर्तन करना शुरू करता है। इस बीच उपयोगकर्ता बी डेटा लोड करता है, परिवर्तन करता है और इसे डेटाबेस में वापस सहेजता है। उपयोगकर्ता A तब अपने परिवर्तनों को सहेजता है, उपयोगकर्ता B द्वारा किए गए कुछ परिवर्तनों को अधिलेखित कर देता है)

दोनों को हल करने के लिए दृष्टिकोण हैं, लेकिन आपको यह तय करने की आवश्यकता है कि आप अपनी वर्तमान समस्या, रीयल-टाइम या विलंबित अपडेट के लिए कौन सा दृष्टिकोण सबसे उपयुक्त हैं...

बुनियादी उदाहरण के साथ अपडेट किया गया

पहली बात यह है कि एक वर्ग बनाकर शुरू करें जो आपके डेटाबेस से डेटा का प्रतिनिधित्व करता है। आम तौर पर, मैं एक Interface से शुरू करता हूँ और वास्तविक कार्यान्वयन उत्पन्न करने के लिए किसी प्रकार के कारखाने का उपयोग करें, लेकिन छोटे कदम...

इसका एक बहुत ही महत्वपूर्ण चर है, hasChanged . इसका उपयोग उस वस्तु को चिह्नित करने के लिए किया जाता है जिसे अद्यतन करने की आवश्यकता है...

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

आगे हमने एक टेबल मॉडल बनाया जो वस्तुओं की सूची को मॉडलिंग करने में सक्षम है...

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

एक ही चीज़ को प्राप्त करने के कई तरीके हैं, लेकिन मूल रूप से यहाँ मैंने getChangedPeople नामक विधि प्रदान की है। जो सभी People . को वापस कर देगा जो बदल गए हैं। फिर आप बस इस सूची में लूप करेंगे और उपयुक्त डेटाबेस अपडेट स्टेटमेंट को कॉल करेंगे।