activerecordhelper.java

一个Java持久层类库

//        stmts.setDeleteStatement(bufDelete.toString());
//        objectInfo.setBasicSqlStatement(stmts);

        ActiveRecordHelper.activeLibrary.put(recordTypeName, objectInfo);
        return objectInfo;
    }

    static final ActiveRecord setupObjectByResultSet(ActiveRecord object, ResultSet resultSet) throws ObjectAnalysisException, SQLException
    {
        ObjectInfo recordType = null;
        try
        {
            recordType = ActiveRecordHelper.analizeObjectInfo(object.getClass());
            for(Accesstor accesstor : recordType.getIdentify())
            {
                Object value = resultSet.getObject(accesstor.getColumnName());//System.out.println(accesstors.length);
                if(value != null)
                    accesstor.invokeSetValue(object, value);
            }
            for(Accesstor accesstor : recordType.getAccesstor())
            {
                Object value = resultSet.getObject(accesstor.getColumnName());//System.out.println(accesstors.length);
                if(value != null)
                    accesstor.invokeSetValue(object, value);
            }
        }
        catch(SQLException err)
        {
            throw err;
        }
        catch(Exception err)
        {
            throw new ObjectAnalysisException(err.toString(), err);
        }
        object.isActive = true;
        return object;
    }
    static final ActiveRecord[] setupObjectByResultSet(ActiveRecord[] objects, ResultSet resultSet, Map<String,String> tableName) throws ObjectAnalysisException, SQLException
    {
        for(ActiveRecord object : objects)
        {
            String name = tableName.get(object.getClass().getSimpleName());
            name += ".";
            ObjectInfo recordType = null;
            try
            {
                recordType = ActiveRecordHelper.analizeObjectInfo(object.getClass());
                //Accesstor[] accesstors = ActiveRecordHelper.analizeObjectInfo(object.getClass()).getAccesstor();
                for(Accesstor accesstor : recordType.getIdentify())
                {//System.err.println(accesstor.getFieldName());
                    Object value = resultSet.getObject(name + accesstor.getColumnName());//System.out.println(accesstors.length);
                    if(value != null)
                        accesstor.invokeSetValue(object, value);
                }
                for(Accesstor accesstor : recordType.getAccesstor())
                {
                    Object value = resultSet.getObject(name + accesstor.getColumnName());//System.out.println(accesstors.length);
                    if(value != null)
                        accesstor.invokeSetValue(object, value);
                }
            }
            catch(SQLException err)
            {
                throw err;
            }
            catch(Exception err)
            {
                throw new ObjectAnalysisException(err.toString(), err);
            }
            object.isActive = true;
        }
        return objects;
    }
    static final ActiveRecord[] setupObjectByResultSet(Class<?extends ActiveRecord>[] recordTypes, ResultSet resultSet, Map<String,String> tableName) throws ObjectAnalysisException, SQLException
    {
        int length = recordTypes.length;
        ActiveRecord[] records = new ActiveRecord[length];
        for(int i=0;i<length;i++)
        {
            try
            {
                records[i] = recordTypes[i].newInstance();
            }
            catch(Exception err)
            {
                throw new ObjectAnalysisException(err.toString(), err);
            }
        }
        return setupObjectByResultSet(records, resultSet, tableName);
    }

    public static void main(String... s) throws Exception
    {
//        ObjectInfo info = analizeObjectInfo(User.class);
//        System.err.println(info.getBasicSqlStatement().getInsertStatement());
//        System.err.println(info.getBasicSqlStatement().getUpdateStatement());
//        System.err.println(info.getBasicSqlStatement().getSelectStatement());
//        System.err.println(info.getBasicSqlStatement().getDeleteStatement());

        ObjectInfo recordType = ActiveRecordHelper.analizeObjectInfo(Role.class);
        System.err.print(recordType.getIdentify()[0].getFieldName());
    }

    static Map<Field, Accesstor> analizeObjectAttributes_deleted(ActiveRecord object)
    {
        ObjectInfo objs = ActiveRecord.objectInformationBase.get(object.getClass().getName());
        Map<Field, Accesstor> objects = null;
        if(objs != null)
            objects = objs.getFieldAccesstorMapping();
        if(objects != null)
            return objects;

        //如果该持久化类的信息未被缓存，则开始分析
        objects = new HashMap<Field, Accesstor>();
        Class currentClass = object.getClass();

        List<Accesstor> tempAttr = new ArrayList<Accesstor>();
        /**开始读取所有符合规范的字段
         * 命名符合JavaBean的命名规范,存取器声明为公开
         */
        while(currentClass != null)
        {
            for(Field field : currentClass.getDeclaredFields())
            {
//                if(field.getModifiers() != Modifier.PRIVATE)
//                   continue;
                if(field.getName().equals("id"))
                    continue;
                try
                {
                    Method getter = currentClass.getMethod(ActiveRecordHelper.getGetterNameByField(field.getName()));
                    Method setter = currentClass.getMethod(ActiveRecordHelper.getSetterNameByField(field.getName()), field.getType());
                    if(getter.getModifiers() == Modifier.PUBLIC && setter.getModifiers() == Modifier.PUBLIC)
                        objects.put(field, new Accesstor(getter, setter));
                    tempAttr.add(new Accesstor(field.getName(), getter, setter));
                }
                catch(Exception err)
                {
                    //It means that it's not a valid field
                }
            }
            if(currentClass == ActiveRecord.class)
                break;
            else
                currentClass = currentClass.getSuperclass();
        }

        if(objs != null)
            objs.setFieldAccesstorMapping(objects);
        else
        {
            objs = new ObjectInfo();
            objs.setFieldAccesstorMapping(objects);
            ActiveRecord.objectInformationBase.put(object.getClass().getName(), objs);
        }
        return objects;
    }

    private static final String getGetterNameByField(String fieldName)
    {
        return "get" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
    }
    private static final String getSetterNameByField(String fieldName)
    {
        return "set" + fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
    }

    private static final LinkMap findFromList(List<LinkMap> srcs, Class type)
    {
        for(LinkMap item : srcs)
        {
            if(item.getRecordType().equals(type))
                return item;
        }
        return null;
    }

        /**
     *  将从数据库读出的值传递到一个 ActiveRecord 对象中,适用于读取单个表
     */
//     static final ActiveRecord setupObject_deleted (ActiveRecord object, ResultSet resultSet) throws java.sql.SQLException, ObjectAnalysisException
//    {
//        Map<Field, Accesstor> fields = ActiveRecordHelper.analizeObjectFields(object);
//        try
//        {
//            for(Field field : fields.keySet())
//            {
//                Object value = resultSet.getObject(field.getName());
//                if(value != null)
//                    fields.get(field).getSetter().invoke(object, value);
//            }
//        }
//        catch(SQLException err)
//        {
//            throw err;
//        }
//        catch(Exception err)
//        {
//            if(err instanceof IllegalAccessException || err instanceof IllegalArgumentException)
//                throw new ObjectAnalysisException(err.toString(), err);
//            else if(err instanceof InvocationTargetException)
//                throw new ObjectAnalysisException(err.toString(), err);
//        }
//        object.setId(resultSet.getObject("id"));
//        object.isActive = true;
//        return object;
//    }

    /**
     * 将从数据库读出的值传递到一个 ActiveRecord 对象中,适用于读取多个表
     * @param objects
     * @param tableName
     * @param resultSet
     * @return
     * @throws java.sql.SQLException
     * @throws activerecord.exception.ObjectAnalysisException
     */
//    static final ActiveRecord[] setupObject_deleted (ActiveRecord[] objects, Map<String,String> tableName, ResultSet resultSet) throws java.sql.SQLException, ObjectAnalysisException
//    {
//        for(ActiveRecord object : objects)
//        {
//            String name = tableName.get(object.getClass().getSimpleName());
//            name += ".";
//            Map<Field, Accesstor> fields = ActiveRecordHelper.analizeObjectFields(object);
//            try
//            {
//                for(Field field : fields.keySet())
//                {
//                    Object value = resultSet.getObject(name + field.getName());
//                    if(value != null)
//                        fields.get(field).getSetter().invoke(object, value);
//                }
//            }
//            catch(SQLException err)
//            {
//                throw err;
//            }
//            catch(Exception err)
//            {
//                throw new ObjectAnalysisException(err.toString(), err);
//            }
//            object.setId(resultSet.getObject("id"));
//            object.isActive = true;
//        }
//        return objects;
//    }

    //    protected static BasicSqlStatement analizeObjectSqlStatement(ActiveRecord object)
//    {
//        ObjectInfo objs = ActiveRecord.objectInformationBase.get(object.getClass().getName());
//        BasicSqlStatement sqlStatement = null;
//        if(objs != null)
//            sqlStatement = objs.getBasicSqlStatement();
//        if(sqlStatement != null)
//            return sqlStatement;
//
//        sqlStatement = new BasicSqlStatement();
//        Map<Field, Accesstor> objectInfo = ActiveRecordHelper.analizeObjectFields(object);
//        //开始构造SQL语句
//        StringBuffer bufInsert = new StringBuffer(200);
//        StringBuffer bufUpdate = new StringBuffer(200);
//        //insert语句
//        bufInsert.append("insert into ");
//        bufInsert.append(object.getClass().getSimpleName());
//        bufInsert.append("(");
//        //update语句
//        bufUpdate.append("update ");
//        bufUpdate.append(object.getClass().getSimpleName());
//        bufUpdate.append(" set ");
//
//        Set<Field> keys = objectInfo.keySet();
//        for(Field field : keys)
//        {
//            bufInsert.append(field.getName());
//            bufInsert.append(',');
//            bufUpdate.append(field.getName());
//            bufUpdate.append("=?,");
//        }
//        bufInsert.replace(bufInsert.length()-1, bufInsert.length(), ")values(");
//        bufUpdate.replace(bufUpdate.length()-1, bufUpdate.length(), " where id=?");
//        int size = keys.size();
//        for(int i=0; i<size; i++)
//        {
//            if(i != size-1)
//                bufInsert.append("?,");
//            else
//                bufInsert.append("?)");
//        }
//        sqlStatement.setInsertStatement(bufInsert.toString());
//        sqlStatement.setUpdateStatement(bufUpdate.toString());
//        if(objs != null)
//            objs.setBasicSqlStatement(sqlStatement);
//        else
//        {
//            objs = new ObjectInfo();
//            objs.setBasicSqlStatement(sqlStatement);
//            ActiveRecord.objectInformationBase.put(object.getClass().getName(), objs);
//        }
//
//        return sqlStatement;
//    }
}