Java AbstractTableModel和实际SQL语句之间的正确关系是什么？

在代码中，表模型和实际数据库查询之间的正确关系是什么

在表模型的addRow（）方法中，我是否应该进一步调用我的数据库类，从而将行插入数据库？我在下面的代码片段中对此进行了说明

public class MainPanel extends JPanel
{
    ...

    public MainPanel()
    {

        personTableModel = new PersonTableModel();

        personTable = new JTable(personTableModel);
        ...

        insertButton = new JButton("Insert");
        insertButton.addActionListener(new ActionListener() {

            public void actionPerformed(ActionEvent e)
            {
                String name = nameTextBox.getText();
                String address = addressTextBox.getText();

                Object[] row = { name, address };

                personTableModel.addRow(row);  // <--- Add row to model
            }
        });    
    }
}

public class PersonTableModel extends AbstractTableModel
{
    private List<Object[]> data;
    private List<String> columnNames;

    PersonDB personDB = new PersonDB();
    ...

    public void addRow(Object[] row)
    {
        // insert row into 'data'

        personDB.addPerson(row);  // <---- Call the personDB database class
    }

    ...
}

public class PersonDB
{

    public PersonDB()
    {
        // establish database connection
    }

    public addPerson(Object[] row)
    {
        // code that creates a SQL statement based on row data
        // and inserts new row into database.
    }
    ...
}

public类主面板扩展了JPanel
{
...
公共主面板（）
{
personTableModel=新的personTableModel（）；
personTable=新的JTable（personTableModel）；
...
insertButton=新的JButton（“插入”）；
insertButton.addActionListener（新ActionListener（）{
已执行的公共无效操作（操作事件e）
{
String name=nameTextBox.getText（）；
字符串地址=addressTextBox.getText（）；
对象[]行={name，address}；
personTableModel.addRow（row）；//是否应直接进行插入调用取决于某些方面：


是否希望其他进程立即访问数据
您是否担心您的程序崩溃并丢失重要信息
您能否确保addRow期间保留的任何数据都是有意义的（程序可以在插入后直接终止）

当然，直接将数据插入备份数据库可能是个好主意

但是，您应该注意，
addRow
有两种变体，
insertRow
有两种变体，
DefaultTableModel
通过
insertRow（int，Vector）
在内部指导调用，如果您想立即持久化数据，这可能是唯一要覆盖的函数

如果您喜欢DTO的建议，下面的示例可能会对您有所帮助

其思想是在Java中将“实体”或表行表示为类。DTO是最简单的表示，通常只包含具有各自getter和setter的字段

实体通常可以通过ORM库（如或）进行持久化和加载。此外，对于该表应用程序，DTO的使用提供了一种存储数据的方法，该数据未以干净和类型化的方式显示给用户

DTO：

public class PersonDto{
私人长id；
私有字符串名称；
私家弦街;；
公众人物{
}
公共人物（长id、字符串名称、字符串街道）{
this.id=id；
this.name=名称；
这条街；
}
公共长getId（）{
返回id；
}
公共无效集合id（长id）{
this.id=id；
}
公共字符串getName（）{
返回名称；
}
公共void集合名（字符串名）{
this.name=名称；
}
公共字符串getStreet（）{
返回街;；
}
公共街道（字符串街）{
这条街；
}
公共静态类NameColumn扩展了DtoTableModel.ColumnProvider{
公共名称列（）{
super（“Name”，String.class）；
}
@凌驾
公共字符串getValue（PersonDto）{
返回dto.getName（）；
}
@凌驾
公共void设置值（PersonDto，对象值）{
dto.setName（（字符串）值）；
}
}
公共静态类StreetColumn扩展了DtoTableModel.ColumnProvider{
公共街柱（）{
超级（“Street”，String.class）；
}
@凌驾
公共字符串getValue（PersonDto）{
返回dto.getStreet（）；
}
@凌驾
公共void设置值（PersonDto，对象值）{
dto.setStreet（（字符串）值）；
}
}
}

基于DTO的表格模型：

import javax.swing.table.AbstractTableModel;
import java.util.ArrayList;

public class DtoTableModel<T> extends AbstractTableModel {

    private final ArrayList<T>                    rows;
    private final ArrayList<ColumnProvider<T, ?>> columns;

    protected DtoTableModel() {
        rows = new ArrayList<T>();
        columns = new ArrayList<ColumnProvider<T, ?>>();
    }

    @Override
    public int getRowCount() {
        return rows.size();
    }

    @Override
    public int getColumnCount() {
        return columns.size();
    }

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        return columns.get(columnIndex).getValue(rows.get(rowIndex));
    }

    @Override
    public boolean isCellEditable(int rowIndex, int columnIndex) {
        return true;
    }

    @Override
    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
        final ColumnProvider<T, ?> column = columns.get(columnIndex);
        column.setValue(rows.get(rowIndex), aValue);
        this.fireTableCellUpdated(rowIndex, columnIndex);
    }

    @Override
    public String getColumnName(int column) {
        return columns.get(column).getTitle();
    }

    public void addColumn(ColumnProvider<T, ?> column) {
        this.columns.add(column);
        this.fireTableStructureChanged();
    }

    public void addRow(T row) {
        this.rows.add(row);
        this.fireTableRowsInserted(this.rows.size() - 1, this.rows.size() - 1);
    }

    @Override
    public Class<?> getColumnClass(int columnIndex) {
        return this.columns.get(columnIndex).getValueClass();
    }

    public static abstract class ColumnProvider<T, V> {
        private       String   title;
        private final Class<V> valueClass;

        protected ColumnProvider(String title, Class<V> valueClass) {
            this.title = title;
            this.valueClass = valueClass;
        }

        public String getTitle() {
            return title;
        }

        public void setTitle(String title) {
            this.title = title;
        }

        public Class<V> getValueClass() {
            return valueClass;
        }

        public abstract V getValue(T dto);

        public abstract void setValue(T dto, Object value);
    }
}

import javax.swing.table.AbstractTableModel；
导入java.util.ArrayList；
公共类DtoTableModel扩展了AbstractTableModel{
私有最终数组列表行；
私有最终ArrayList列；
受保护的DtoTableModel（）{
行=新的ArrayList（）；
columns=newarraylist（）；
}
@凌驾
public int getRowCount（）{
返回rows.size（）；
}
@凌驾
public int getColumnCount（）{
返回columns.size（）；
}
@凌驾
公共对象getValueAt（int行索引、int列索引）{
返回columns.get（columnIndex）.getValue（rows.get（rowIndex））；
}
@凌驾
公共布尔值isCellEditable（int-rowIndex、int-columnIndex）{
返回true；
}
@凌驾
public void setValueAt（对象有效、int行索引、int列索引）{
final ColumnProvider column=columns.get（columnIndex）；
column.setValue（rows.get（rowIndex），aValue）；
此.firetablecell已更新（行索引、列索引）；
}
@凌驾
公共字符串getColumnName（int列）{
返回columns.get（column.getTitle（）；
}
公共void addColumn（ColumnProvider列）{
this.columns.add（column）；
此.firetablestructure（）已更改；
}
公共无效添加行（T行）{
this.rows.add（row）；
this.fireTableRowsInserted（this.rows.size（）-1，this.rows.size（）-1）；
}
@凌驾
公共类getColumnClass（int columnIndex）{
返回此.columns.get（columnIndex.getValueClass（）；
}
公共静态抽象类提供程序{
私有字符串标题；
私有最终类valueClass；
受保护的ColumnProvider（字符串标题，类valueClass）{
this.title=标题；
this.valueClass=valueClass；
}
公共字符串getTitle（）{
返回标题；
}
公共无效集合标题（字符串标题）{
this.title=标题；
}
公共类getValueClass（）{
返回值类；
}
公开摘要V getValue（T dto）；
公共抽象无效设置值（T dto，对象值）；
}
}

例
import javax.swing.table.AbstractTableModel;
import java.util.ArrayList;

public class DtoTableModel<T> extends AbstractTableModel {

    private final ArrayList<T>                    rows;
    private final ArrayList<ColumnProvider<T, ?>> columns;

    protected DtoTableModel() {
        rows = new ArrayList<T>();
        columns = new ArrayList<ColumnProvider<T, ?>>();
    }

    @Override
    public int getRowCount() {
        return rows.size();
    }

    @Override
    public int getColumnCount() {
        return columns.size();
    }

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        return columns.get(columnIndex).getValue(rows.get(rowIndex));
    }

    @Override
    public boolean isCellEditable(int rowIndex, int columnIndex) {
        return true;
    }

    @Override
    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
        final ColumnProvider<T, ?> column = columns.get(columnIndex);
        column.setValue(rows.get(rowIndex), aValue);
        this.fireTableCellUpdated(rowIndex, columnIndex);
    }

    @Override
    public String getColumnName(int column) {
        return columns.get(column).getTitle();
    }

    public void addColumn(ColumnProvider<T, ?> column) {
        this.columns.add(column);
        this.fireTableStructureChanged();
    }

    public void addRow(T row) {
        this.rows.add(row);
        this.fireTableRowsInserted(this.rows.size() - 1, this.rows.size() - 1);
    }

    @Override
    public Class<?> getColumnClass(int columnIndex) {
        return this.columns.get(columnIndex).getValueClass();
    }

    public static abstract class ColumnProvider<T, V> {
        private       String   title;
        private final Class<V> valueClass;

        protected ColumnProvider(String title, Class<V> valueClass) {
            this.title = title;
            this.valueClass = valueClass;
        }

        public String getTitle() {
            return title;
        }

        public void setTitle(String title) {
            this.title = title;
        }

        public Class<V> getValueClass() {
            return valueClass;
        }

        public abstract V getValue(T dto);

        public abstract void setValue(T dto, Object value);
    }
}

import javax.swing.*;
import java.awt.*;

public class JTableTest extends JFrame {

    private final JTable jTable;

    public JTableTest() throws HeadlessException {
        super("JFrame test");
        this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);

        final GridBagLayout layout = new GridBagLayout();
        final Container contentPane = this.getContentPane();
        contentPane.setLayout(layout);

        final GridBagConstraints gridBagConstraints = new GridBagConstraints();
        gridBagConstraints.fill = GridBagConstraints.BOTH;
        gridBagConstraints.weightx = 1.0;
        gridBagConstraints.weighty = 1.0;

        final DtoTableModel<PersonDto> dm = new DtoTableModel<PersonDto>();
        jTable = new JTable(dm);
        dm.addColumn(new PersonDto.NameColumn());
        dm.addColumn(new PersonDto.StreetColumn());
        dm.addRow(new PersonDto(1L, "Paul", "Mayfairy Street"));
        dm.addRow(new PersonDto(2L, "Peter", "Ferdinand Street"));
        JScrollPane scrollpane = new JScrollPane(jTable);
        contentPane.add(scrollpane, gridBagConstraints);

        this.pack();
    }

    public static void main(String[] args) {
        final JTableTest jTableTest = new JTableTest();
        jTableTest.setVisible(true);
    }

}