实现通用的保存记录的方法

        在JadePool中， 为了方便用户录入，核心类ProcessVO提供了两个通用的保存记录的方法。
                1、public int save(String tableName, Map<String, Object> mapRecord) throws SQLException
                2、public Object saveOne(String tableName, Map<String, Object> mapRecord) throws SQLException
        save方法 返回标准JDBC插入或者更新操作的返回值，即：插入或更新成功返回1，失败，返回0；
        saveOne方法是从实际需要出发， 返回插入或者更新记录的主键值。
        这两个通用方法都调用底层的_preparedStatementInsert和_preparedStatementUpdate两个核心方法。

        基本构思是：

        如果该记录存在，则更新之，如果该记录不存在，则插入。如果第一个主键的值为null||""，则自动插入新的主键值，这个方法不适合对含多主键的表进行插入操作，但不影响对多主键的表进行更新。

        save方法的源代码如下：

    /**
     * 保存一条记录.
     * 如果该记录存在，则更新之，如果该记录不存在，则插入。如果第一个主键的值为null||""，则自动插入新的主键值，这个方法不适合对含多主键的表进行插入操作，但不影响对多主键的表进行更新
     *
     * @param tableName 是表名
     * @param mapRecord 是准备插入到表中的一条记录的数据,其键名与字段名相同,顺序无关;
     * @return 返回标准update方法返回的状态值
     * @throws SQLException
     */
    @Override
    public int save(String tableName, Map<String, Object> mapRecord) throws SQLException {
        int num = 0;
        String _w = "";
        String[] keys = db.getKeys(tableName);
        if (keys.length == 0) {
            return this.insert(tableName, mapRecord);//无主键的表可以直接插入
        } else {
            Object kv = mapRecord.get(keys[0].toString());
            if (kv == null || "".equals(kv)) {
                num = insert(tableName, mapRecord, true);//表有主键，但记录中不含主键记录||主键记录值是null||主键值是""，则插入，并自动插入主键
            } else {
                Object[] recordFields = mapRecord.keySet().toArray();
                Map _key_m = new LinkedHashMap();
                for (int i = 0; i < recordFields.length; i++) {
                    if (tool.isInFields(keys, recordFields[i].toString())) {
                        _key_m.put(recordFields[i].toString(), mapRecord.get(recordFields[i].toString()));//提取记录中的主键字段
                    }
                }
                if (!_key_m.isEmpty()) {
                    Object[] _k = _key_m.keySet().toArray();
                    if (_k.length != keys.length) {
                        return num;
                    } else {
                        Field f = db.getField(tableName, _k[0].toString());
                        if (f.getTypeClassName().equals("java.lang.String")) {
                            _w = " where " + _k[0] + " like '" + mapRecord.get(_k[0].toString()) + "'";
                        } else {
                            _w = " where " + _k[0] + " = " + mapRecord.get(_k[0].toString());
                        }
                        if (_k.length > 1) {
                            for (int i = 1; i < _k.length; i++) {
                                f = db.getField(tableName, _k[i].toString());
                                if (f.getTypeClassName().equals("java.lang.String")) {
                                    _w = _w + " and " + _k[i] + " like '" + mapRecord.get(_k[i].toString()) + "'";
                                } else {
                                    _w = _w + " and " + _k[i] + " = " + mapRecord.get(_k[i].toString());
                                }
                            }
                        }
                        Map rm = this.queryOne("select " + _k[0] + " from " + tableName + _w);
                        if (rm.isEmpty()) {
                            num = this.insert(tableName, mapRecord);//原原本本地插入
                        } else {
                            num = this.update(tableName, mapRecord, _w);//原原本本地更新
                        }
                    }
                }
            }
        }
        return num;
    }

        saveOne方法的源代码如下：

    /**
     * 保存一条记录.
     * 如果该记录存在，则更新之，如果该记录不存在，则插入。如果第一个主键的值为null||""，则自动插入新的主键值，这个方法不适合对含多主键的表进行插入操作，但不影响对多主键的表进行更新
     *
     * @param tableName 是表名
     * @param mapRecord 是准备插入到表中的一条记录的数据,其键名与字段名相同,顺序无关;
     * @return 返回第一个主键值。【注：原返回int型update返回值，更改为第一个主键值，将更方便应用】
     * @throws SQLException
     */
    @Override
    public Object saveOne(String tableName, Map<String, Object> mapRecord) throws SQLException {
        Object firstKeyValue = null;
        int n = 0;
        String _w = "";
        String[] keys = db.getKeys(tableName);
        String[] fields = db.getFields(tableName);
        if (keys.length == 0) {
            n = this.insert(tableName, mapRecord);//无主键的表可以直接插入
            if (n > 0) {
                firstKeyValue = mapRecord.get(fields[0]);
            }//没有主键，则返回第一个字段值
        } else {
            firstKeyValue = mapRecord.get(keys[0].toString());
            if (firstKeyValue != null & !"".equals(firstKeyValue)) {
                Object[] recordFields = mapRecord.keySet().toArray();
                Map _key_m = new LinkedHashMap();
                for (int i = 0; i < recordFields.length; i++) {
                    if (tool.isInFields(keys, recordFields[i].toString())) {
                        _key_m.put(recordFields[i].toString(), mapRecord.get(recordFields[i].toString()));//提取记录中的主键字段
                    }
                }
                if (!_key_m.isEmpty()) {
                    Object[] _k = _key_m.keySet().toArray();
                    if (_k.length != keys.length) {
                        return null;//如果有多个主键，而记录中缺少多个主键，则不保存
                    } else {
                        Field f = db.getField(tableName, _k[0].toString());
                        if (f.getTypeClassName().equals("java.lang.String")) {
                            _w = " where " + _k[0] + " like '" + mapRecord.get(_k[0].toString()) + "'";
                        } else {
                            _w = " where " + _k[0] + " = " + mapRecord.get(_k[0].toString());
                        }
                        if (_k.length > 1) {
                            for (int i = 1; i < _k.length; i++) {
                                f = db.getField(tableName, _k[i].toString());
                                if (f.getTypeClassName().equals("java.lang.String")) {
                                    _w = _w + " and " + _k[i] + " like '" + mapRecord.get(_k[i].toString()) + "'";
                                } else {
                                    _w = _w + " and " + _k[i] + " = " + mapRecord.get(_k[i].toString());
                                }
                            }
                        }
                        Map rm = this.queryOne("select " + _k[0] + " from " + tableName + _w);
                        if (rm.isEmpty()) {
                            n = this.insert(tableName, mapRecord);//原原本本地插入
                        } else {
                            n = this.update(tableName, mapRecord, _w);//原原本本地更新
                        }
                    }
                }
            } else {// if (firstKeyValue == null || "".equals(firstKeyValue))
                Field f = db.getField(tableName, keys[0]);
                String className = f.getTypeClassName();
                if (className.equals("java.lang.Long")) {
                    firstKeyValue = insertKey(tableName);
                    mapRecord.put(keys[0], firstKeyValue);
                    n = update(tableName, mapRecord);//表有主键，但记录中不含主键记录||主键记录值是null||主键值是""，则插入，并自动插入主键

                }
                if (className.equals("java.lang.Integer") || className.equals("java.lang.Short") || className.equals("java.lang.Float") || className.equals("java.lang.Double") || className.equals("java.lang.String")) {
                    firstKeyValue = insertAutoKey(tableName);
                    mapRecord.put(keys[0], firstKeyValue);
                    n = update(tableName, mapRecord);//表有主键，但记录中不含主键记录||主键记录值是null||主键值是""，则插入，并自动插入主键
                }
            }
        }
        return firstKeyValue;
    }

        应用：

Map m=...;//一条记录
Jade j = new Jade();
Object keyValue=j.saveOne(tableName, m);//或者int num=j.save(tableName, m);
j.commit();

        保存多条记录时，可以参照以下方式实现：

List<Map> list=...;//一组记录
Jade j = new Jade();
int num=0;
for(Map m:list){
    num=num+j.save(tableName, m);
}
j.commit();

        说明：目前没有提供保存多条记录的方法。使用这种方式保存多条记录的效率比较低，将来会提供一个高效的保存多条记录的方法。