EasyDBO上對象關聯還是存在很大問題。

其中一個，添加對象時，沒能將被關聯對象的主鍵（由數據庫生成）插入到關聯對象的外鍵上。

注：

(1) EasyDBO的一對一關聯中，外鍵在關聯對象方。

Class A{

.....

B b ;

}

Class B{

}

對應于實體A的數據庫表有外鍵，如 fk_b

(2) EasyDBO的一對多關聯中，外鍵在被關聯對象方（多方）。

Class A{

.....

List<B> bList ;

}

Class B{

A a;

}

對應于實體B的數據庫表有外鍵，如 fk_a

在解決這個問題中，對源碼做一些的修改：

1、首先解決如果是數據庫生成的主鍵（如auto_increment類型），在DatabaseDAO添加getGeneratedKey()方法。

    public Serializable getGeneratedKey()
    {
        if(prepared==null){
            return null;
        }
        Serializable ret =null;
        ResultSet rs = null;
        try
        {
            rs = prepared.getGeneratedKeys();
            if(rs.next())
            {
                ret = (Serializable)rs.getObject(1);
                logger.info("get the GeneratedKey:" + ret);
            }
        }
        catch(SQLException e)
        {
            e.printStackTrace();
        }
        finally
        {
            if(rs != null)
                try
                {
                    rs.close();
                }
                catch(SQLException e)
                {
                    e.printStackTrace();
                }
        }
        return ret;
    }

2、在EasyJDBEngine中添加generatedKey字段和getter方法。

    private Serializable generatedKey;
    
    
    public Serializable getGeneratedKey()
    {
        return generatedKey;
    }

   在EasyJDBEngine的public boolean add(DBObject obj)方法中try的括號末尾添加

generatedKey  = dba.getGeneratedKey();

3、EasyJDB中添加以下方法：

    private Object setObjectGenIdValue(Object obj){
        BeanWrapper wrapper = new BeanWrapper(obj);
        DBTable dbTable = findTable(obj.getClass());
        String idFieldName = dbTable.getPoperty(dbTable.getId());
        if(wrapper.getPropertyValue(idFieldName)==null && StringUtils.isNotEmpty(dbEngine.getGeneratedKey())){
            Object javaPropertyValue = wrapper.convertIfNecessary(String.valueOf(dbEngine.getGeneratedKey()),
                                                                    dbTable.getType(idFieldName));
            wrapper.setPropertyValue(idFieldName, javaPropertyValue);
            System.out.println("setting id.");
            return javaPropertyValue;
        }
        return null;
    }

    private Object getObjectIdValue(Object obj){
        BeanWrapper wrapper = new BeanWrapper(obj);
        DBTable dbTable = findTable(obj.getClass());
        String idFieldName = dbTable.getPoperty(dbTable.getId());
        if(StringUtils.isNotEmpty(wrapper.getPropertyValue(idFieldName))){
            return wrapper.getPropertyValue(idFieldName);
        }
        return null;
    }

    private void setClassFieldValue(Object target,ClassField classField,Object value){
        BeanWrapper wi=new BeanWrapper(target);
        DBTable dbTable = findTable(target.getClass());
        wi.setPropertyValue(dbTable.getPoperty(classField.getColumn()),value);
    }

EasyJDB中的public boolean add(Object obj)方法改為：

    public boolean add(Object obj)
    {
        logger.debug("把對象obj保存到數據庫中");
         boolean ret = dbEngine.add(obj2dbo(obj));
         setObjectGenIdValue(obj);///如果是新添加的記錄，且主鍵為數據庫生成，那么將主鍵值返回賦給對象
         if(ret)ret = ret & addRelativeObject(obj);
        return ret;
    }

 EasyJDB中的private boolean addRelativeObject(Object obj)方法改為：

    private boolean addRelativeObject(Object obj)
    {
        boolean ret = true;
        DBTable table = findTable(obj.getClass());
        if(table != null)
        {
            BeanWrapper wrapper = new BeanWrapper(obj);
            java.util.Iterator it = table.getClassField().entrySet().iterator();
            while(it.hasNext())
            {
                // 嘗試處理其它字段
                Map.Entry en = (Map.Entry)it.next();
                String propertyName = (String)en.getKey();
                ClassField classField = (ClassField)en.getValue();
                // System.out.println(classField.getClass()+":"+propertyName);
                if(classField instanceof ManyToManyField && wrapper.isReadableProperty(propertyName))
                {
                    // 處理多對多
                    Object value = wrapper.getPropertyValue(propertyName);
                    // System.out.println("值內容"+value.getClass());
                    if(value != null && value instanceof Collection)
                    {
                        java.util.Iterator es = ((Collection)value).iterator();
                        while(es.hasNext())
                        {
                            Object element = es.next();
                            ret = ret & this.saveOrUpdate(element);
                            // 保存關聯的第三方表
                            ManyToManyField field = (ManyToManyField)classField;
                            /**//*
                             * DBTable table2=findTable(element.getClass());
                             * if(table2!=null) { ManyToManyField field2=null;
                             * java.util.Iterator
                             * inf2=table2.getClassField().values().iterator();
                             * while(inf2.hasNext()) { ClassField
                             * ff=(ClassField)inf2.next();
                             * if(ff.getTableName().equals(field.getTableName()) &&
                             * ff.getType()==obj.getClass()) {
                             * field2=(ManyToManyField)ff; } }
                             */
                            String sql = "insert into " + field.getTableName() + "(" + classField.getColumn() + ","
                                            + field.getTagColumn() + ") values(?,?)";
                            java.util.Collection paras = new java.util.ArrayList();
                            paras.add(wrapper.getPropertyValue(classField.getKey()));
                            BeanWrapper wrapper2 = new BeanWrapper(element);
                            paras.add(wrapper2.getPropertyValue(field.getTagKey()));
                            try
                            {
                                this.execute(sql, paras);
                            }
                            catch(Exception e)
                            {
                                logger.error("插入多對多關系時出錯！");
                                e.printStackTrace();
                            }
                            // }
                        }
                    }
                }
                else if((classField instanceof ManyToOneField) && wrapper.isReadableProperty(propertyName))
                {
                    // 處理一對多
                    Object value = wrapper.getPropertyValue(propertyName);
                    if(value != null && value instanceof Collection)
                    {
                        java.util.Iterator es = ((Collection)value).iterator();
                        while(es.hasNext())
                        {
                            Object item = es.next();
                            setClassFieldValue(item,classField,obj);//設置關聯值
                            ret = ret & this.saveOrUpdate(item);
                        }
                    }
                }
                else if((classField instanceof OneToOneField) && wrapper.isReadableProperty(propertyName))
                {
                    // 處理一對一
                    Object value = wrapper.getPropertyValue(propertyName);
                    if(value != null)
                    {
                        ret = ret & this.saveOrUpdate(value);
                        if(StringUtils.isNotEmpty(getObjectIdValue(value)))
                        {
                            setClassFieldValue(obj, classField, value);//設置關聯值
                            update(obj);//更新一下數據，將關聯的對象主鍵作為外鍵
                        }
                    }
                }
            }
        }
        return ret;
    }

EasyJDB中的public boolean update(Object obj)方法改為：

    public boolean update(Object obj)
    {
        logger.info("更新持久層中的數據表對象");
        boolean ret = dbEngine.update(obj2dbo(obj));
//        ret = ret & this.addRelativeObject(obj);//這句很容易會導致死循環，先不要了
        return ret;
    }

EasyJDB中的public boolean saveOrUpdate(Object obj)方法改為：

    public boolean saveOrUpdate(Object obj)
    {
        // logger.info("把對象持久化到數據庫中，先償試添加，若無法保存則執行修改操作");
        boolean ret = false;
        try
        {
            Object id = getObjectIdValue(obj);
            
            if(id == null)
            {
                ret = add(obj);
            }

            else
            {
                if(get(obj.getClass(), id) != null)
                    ret = update(obj);
                else
                    ret = add(obj);
            }
        }
        catch(Exception e)
        {
            //這里的也先不要的，很容易導致死循環
            // 出錯，進一步嘗試使用原始的方法進行更改
//            if(add(obj))
//            {
//                return true;
//            }
//            return update(obj);
            e.printStackTrace();
        }
        return ret;
    }

解釋一下：

這里處理的不包括多對多的關系，很少用到，暫時不管。

解決的思路是，如果是自增（數據庫生成的id），那么獲取這個id，并回賦給對象，對象有了主鍵值（每個這樣的對象都回賦主鍵值），關聯就有了導航。

在一對一關系處理中，因為是先插入關聯對象數據，然后在插入被關聯對象數據。但是關聯對象需要知道被關聯的主鍵值，而被關聯的主鍵值是在最后插入數據后回賦的，所以，采取從新將對象關聯，并更新數據。

       setClassFieldValue(obj, classField, value);//設置關聯值
       update(obj);//更新一下數據，將關聯的對象主鍵作為外鍵

在處理一對多(也即多對一)關系中，如一開就提到的“EasyDBO的一對多關聯中，外鍵在被關聯對象方（多方）”，數據插入順序同一對一的一樣，先關聯對象，后被關聯對象，所以，在這里只需要在被關聯對象插入前更新關聯就可以了

setClassFieldValue(item,classField,obj);//設置關聯值

比較明顯，將一對多的關系轉換成了多個一對一了。或許這樣不是很好，但是，在原有的架構上，比較難做更大修改。

EasyDBO有一些主鍵生成器的，不知對對象關聯上主鍵的處理上有沒有獨特的解決方法，待探索...

淺見，不當的地方歡迎指正~~~~~~~~