Codenameone 代码名绑定到属性对象列表的一个表，用于显示和修改数据库表_Codenameone

Codenameone 代码名绑定到属性对象列表的一个表，用于显示和修改数据库表

codenameone

Codenameone 代码名绑定到属性对象列表的一个表，用于显示和修改数据库表,codenameone,Codenameone,这个问题是针对Codename One的，它是关于我下面的代码是好代码还是有更好的策略这是我的用例：通过一个REST请求，我得到一个数据库表，作为由JSON序列化的DAO列表（每个DAO都是行）客户端有一个ServerAPI类，该类具有一个方法，该方法将服务器响应返回为List 每个SportTypeDAO都实现为PropertyBusinessObject 我想显示一个表单，其中包含一个表格对象，该对象允许用户查看所有表格并修改一些字段（以及添加行，但我还没有实现）表将被序列化为JS

这个问题是针对Codename One的，它是关于我下面的代码是好代码还是有更好的策略

这是我的用例：

通过一个REST请求，我得到一个数据库表，作为由JSON序列化的DAO列表（每个DAO都是行）
客户端有一个ServerAPI类，该类具有一个方法，该方法将服务器响应返回为
```
List
```
每个
```
SportTypeDAO
```
都实现为
```
PropertyBusinessObject
```
我想显示一个
```
表单
```
，其中包含一个
```
表格
```
对象，该对象允许用户查看所有表格并修改一些字段（以及添加行，但我还没有实现）
```
表
```
将被序列化为JSON，以将修改后的表发送到服务器

问题是：

```
属性
```
可以很容易地绑定到
```
文本字段
```
或
```
输入组件
```
，但我不知道有什么默认的简单方法可以将
```
属性业务对象
```
绑定到
```
表的行
```
。。。甚至可以将
```
列表
```
绑定到
```
表
```
```
Table
```
在内部使用一个
```
createCell
```
方法，该方法使用传递到
```
TableModel
```
的数据将每个单元格创建为
```
标签
```
或
```
文本字段
```
（根据单元格是否可编辑的事实），因此，我无法直接在绑定到
```
属性的表文本字段中插入
```


我试着用下面的方法解决这个问题。。。但是对于一个简单的概念性任务，有很多代码（将列表
绑定到表
）。。。有没有更好的办法？我必须对许多表执行相同的任务，我担心找到一个可以尽可能普遍化的好解决方案
public class FormSportType extends BaseForm {

    private static List<SportTypeDAO> listToShow = null;

    public FormSportType() {
        super("FormSportType", BoxLayout.y());
        fillForm();
    }

    public FormSportType(Form backForm) {
        super("FormSportType", BoxLayout.y());
        addBackCommand(backForm);
        fillForm();
    }

    private void fillForm() {

        add(new Label("FormSportType"));
        UiBinding uib = new UiBinding();

        if (listToShow == null) {
            listToShow = serverAPI.readSportType();
        }

        int rows = listToShow.size();
        int colums = 5;
        Object[][] dataArray = new Object[rows][colums];
        for (int row = 0; row < rows; row++) {
            for (int column = 0; column < colums; column++) {
                String cell = "";
                switch (column) {
                    case 0:
                        cell = listToShow.get(row).keyword.get();
                        break;
                    case 1:
                        cell = listToShow.get(row).text_IT.get();
                        break;
                    case 2:
                        cell = listToShow.get(row).text_EN.get();
                        break;
                    case 3:
                        cell = listToShow.get(row).position.get().toString();
                        break;
                    case 4:
                        cell = listToShow.get(row).dbAction.get().toString();
                        break;
                }

                dataArray[row][column] = cell;
            }
        }

        TableModel model = new DefaultTableModel(new String[]{"Keyword", "Text_IT", "Text_EN", "Position", "DbAction"}, dataArray) {

            @Override
            public boolean isCellEditable(int row, int col) {
                return (row > -1 && col != 0 && col != 4);
            }

            @Override
            public void setValueAt(int row, int column, Object o) {
                if (DEBUG) {
                    Log.p("Executing setValueAt \"" + o + "\" at row " + row + ", column " + column);
                }
                super.setValueAt(row, column, o);
                try {
                    String value;
                    if (o instanceof String) {
                        value = (String) o;
                    } else if (o instanceof Integer) {
                        Integer num = (Integer) o;
                        value = num.toString();
                    } else {
                        if (DEBUG) {
                            Log.p("ERROR in setValueAt row " + row + ", column " + column + " because wrong object class");
                        }
                        throw new IllegalArgumentException("Object o is not a String or an Integer");
                    }
                    switch (column) {
                        case 0:
                            listToShow.get(row).keyword.set(value);
                            break;
                        case 1:
                            listToShow.get(row).text_IT.set(value);
                            break;
                        case 2:
                            listToShow.get(row).text_EN.set(value);
                            break;
                        case 3:
                            listToShow.get(row).position.set(Integer.valueOf(value));
                            break;
                        case 4:
                            listToShow.get(row).dbAction.set(Integer.valueOf(value));
                            break;
                        default:
                            if (DEBUG) {
                                Log.p("ERROR in setValueAt row " + row + ", column " + column + ", because wrong column number");
                            }
                    }
                } catch (Exception ex) {
                    if (DEBUG) {
                        Log.p("ERROR in setValueAt row " + row + ", column " + column);
                        Log.e(ex);
                    }
                }
                if (DEBUG) {
                    List<Map<String, Object>> listMaps = new LinkedList<>();
                    for (SportTypeDAO dao : listToShow) {
                        listMaps.add(dao.getPropertyIndex().toMapRepresentation());
                    }
                    Map<String, List<Map<String, Object>>> toConvert = new HashMap<>();
                    toConvert.put("root", listMaps);
                    Log.p("--- New JSON content:\n" + JSONParser.mapToJson(toConvert));
                }
            }

            @Override
            public Object getValueAt(int row, int column) {
                // if(DEBUG) Log.p("Executing getValueAt row " + row + ", column " + column);
                try {
                    switch (column) {
                        case 0:
                            return listToShow.get(row).keyword.get();
                        case 1:
                            return listToShow.get(row).text_IT.get();
                        case 2:
                            return listToShow.get(row).text_EN.get();
                        case 3:
                            return listToShow.get(row).position.get();
                        case 4:
                            return listToShow.get(row).dbAction.get();
                        default:
                            if (DEBUG) {
                                Log.p("ERROR: cannot get value at row " + row + ", column: " + column);
                            }
                            return "";
                    }
                } catch (Exception err) {
                    if (DEBUG) {
                        Log.p("ERROR: cannot get value at row " + row + ", column: " + column);
                        Log.e(err);
                    }
                    return "";
                }
            }

        };

        Table table = new Table(model) {
            @Override
            protected Component createCell(Object value, int row, int column, boolean editable) {
                Component cell = super.createCell(value, row, column, editable);
                if (row > -1) {
                    cell.setUIID("TableCell");
                }
                if (row > -1 && row % 2 == 0) {
                    // pinstripe effect 
                    cell.getAllStyles().setBgColor(0xeeeeee);
                    cell.getAllStyles().setBgTransparency(255);
                }

                return cell;
            }

            @Override
            protected TableLayout.Constraint createCellConstraint(Object value, int row, int column) {
                TableLayout.Constraint con = super.createCellConstraint(value, row, column);
                con.setWidthPercentage(100 / model.getColumnCount());
                return con;
            }

        };

        table.setSortSupported(true);

        try {
            table.sort(3, false); // order by position
            if (DEBUG) {
                Log.p("table.sort executed successfully");
            }
        } catch (Exception ex) {
            if (DEBUG) {
                Log.p("ERROR: cannot order table, maybe there are null values");
                Log.e(ex);
            }
        }

        add(table);

    }
}

公共类FormSportType扩展了BaseForm{
私有静态列表listToShow=null；
public FormSportType（）{
超级（“FormSportType”，BoxLayout.y（））；
fillForm（）；
}
公共窗体SportType（窗体背面）{
超级（“FormSportType”，BoxLayout.y（））；
addback命令（backForm）；
fillForm（）；
}
私有无效填充表单（）{
添加（新标签（“FormSportType”）；
UiBinding uib=新的UiBinding（）；
if（listToShow==null）{
listToShow=serverAPI.readSportType（）；
}
int rows=listToShow.size（）；
整列=5；
对象[][]数据数组=新对象[行][列]；
对于（int row=0；row-1&&col！=0&&col！=4）；
}
@凌驾
public void setValueAt（int行、int列、对象o）{
如果（调试）{
Log.p（“在行+行+列+列处执行setValueAt\”+o+“\”）；
}
super.setValueAt（行、列、o）；
试一试{
字符串值；
如果（字符串的o实例）{
值=（字符串）o；
}else if（o整数实例）{
整数num=（整数）o；
value=num.toString（）；
}否则{
如果（调试）{
Log.p（“setValueAt行“+行+”，列“+列+”中的错误，因为对象类错误”）；
}
抛出新的IllegalArgumentException（“对象o不是字符串或整数”）；
}
开关（列）{
案例0：
listToShow.get（row.keyword.set（value）；
打破
案例1：
listToShow.get（行）.text\u IT.set（值）；
打破
案例2：
listToShow.get（行）.text_EN.set（值）；
打破
案例3：
listToShow.get（row.position.set（Integer.valueOf（value））；
打破
案例4：
listToShow.get（row.dbAction.set（Integer.valueOf（value））；
打破
违约：
如果（调试）{
Log.p（“行“+行+”，列“+列+”，因为列号错误，setValueAt中出现错误”）；
}
}
}捕获（例外情况除外）{
如果（调试）{
Log.p（“setValueAt行“+行+”，列“+列中的错误”）；
Log.e（ex）；
}
}
如果（调试）{
/**
 * Implements table model binding, this is implemented as a class to allow
 * additional features such as adding/removing rows
 */
public class BoundTableModel implements TableModel {
    private List<PropertyBusinessObject> objects;
    private PropertyBusinessObject prototype;
    private Set<String> exclude = new HashSet<String>();
    private PropertyBase[] columnOrder;
    private Set<String> uneditable = new HashSet<String>();
    private EventDispatcher listeners = new EventDispatcher();

    /**
     * Creates a table model with the business objects
     * @param objects the objects of the model
     * @param prototype the type by which we determine the structure of the table
     */
    public BoundTableModel(List<PropertyBusinessObject> objects, 
        PropertyBusinessObject prototype) {
        this.objects = objects;
    }

    /**
     * The properties that are ignored
     * @param b the property to ignore
     */
    public void excludeProperty(PropertyBase b) {
        exclude.add(b.getName());
    }

    /**
     * Sets the order of the columns explicitly
     * @param columnOrder the order of the columns based on the prototype
     */
    public void setColumnOrder(PropertyBase... columnOrder) {
        this.columnOrder = columnOrder;
    }

    /**
     * Makes the property editable or uneditable
     * @param pb the property base
     * @param editable true for editable (the default)
     */
    public void setEditable(PropertyBase pb, boolean editable) {
        if(editable) {
            uneditable.remove(pb.getName());
        } else {
            uneditable.add(pb.getName());
        }
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public int getRowCount() {
        return objects.size();
    }

    /**
     * Adds a new business object to the table
     * @param index the index of the addition
     * @param b the business object
     */
    public void addRow(int index, PropertyBusinessObject b) {
        objects.add(index, b);
        for(int col = 0 ; col < getColumnCount() ; col++) {
            listeners.fireDataChangeEvent(col, index);
        }
    }

    /**
     * Removes the row at the given index
     * @param index the position in the table
     */
    public void removeRow(int index) {
        objects.remove(index);
       listeners.fireDataChangeEvent(Integer.MIN_VALUE, Integer.MIN_VALUE);
    }

    /**
     * {@inheritDoc}
     */
    @Override
    public int getColumnCount() {
        if(columnOrder != null) {
            return columnOrder.length;
        }
        return prototype.getPropertyIndex().getSize() - exclude.size();
    }

    @Override
    public String getColumnName(int i) {
        if(columnOrder != null) {
            return columnOrder[i].getLabel();
        }
        return prototype.getPropertyIndex().get(i).getName();
    }

    @Override
    public boolean isCellEditable(int row, int column) {
        return !uneditable.contains(prototype.getPropertyIndex().get(column).getName());
    }

    @Override
    public Object getValueAt(int row, int column) {
        PropertyBusinessObject pb = objects.get(row);
        String n;
        if(columnOrder != null) {
            n = columnOrder[column].getName();
        } else {
            n = pb.getPropertyIndex().get(column).getName();
        }
        return pb.getPropertyIndex().get(n).get();
    }

    @Override
    public void setValueAt(int row, int column, Object o) {
        PropertyBusinessObject pb = objects.get(row);
        String n;
        if(columnOrder != null) {
            n = columnOrder[column].getName();
        } else {
            n = pb.getPropertyIndex().get(column).getName();
        }
        pb.getPropertyIndex().get(n).setImpl(o);
        listeners.fireDataChangeEvent(column, row);
    }

    @Override
    public void addDataChangeListener(DataChangedListener d) {
        listeners.addListener(d);
    }

    @Override
    public void removeDataChangeListener(DataChangedListener d) {
        listeners.removeListener(d);
    }
}