打造android ORM框架opendroid(六)——级联查询

在上一篇博客《打造android ORM框架opendroid(五)——数据更新的实现》  我们介绍了opendroid数据更新的流程,也就在上次,我们OpenDroid类中的所有操作都介绍完了, 那查询操作呢?不是在OpenDroid中?查询操作是在OpenDroid中,不过是以内部类的形式呈现的。
还是来看看如果使用opendroid查询数据吧。

OpenDroid.query.find(Student.class)

OpenDroid.query.columns("stuName").where("_id>?", "1").limit(1, 4).order("_id DESC").find(Student.class);  

这是opendroid提供的查询方法,也是最常见的级联查询,了解其他ORM框架的朋友们肯定对此不陌生吧,但是,看第二段代码,我们比传统的级联操作多了一个方法columns(),该方法是设置要查询的字段。
好了, 进入我们今天的重点,通过上面代码,我们发现是通过调用了OpenDroid的一个静态字段query的各个方法去组合查询的。我们来看看query。

public static Query query = new Query();

在OpenDroid中这个Query类型的字段,并且在定义的时候就去实例化了。我们再来看看Query这个内部类。

 /** 
 * 查询 
 * @author qibin 
 */  
public static class Query {  
    private String[] mCocumns = null;  // 要查询的字段  
    private String mWhere = null;   // 查询的条件  
    private String[] mWhereArgs = null; // 查询的条件的参数  
    private String mOrder = null; // order语句  
    private String mLimit; // limit语句  
          
    /** 
     * 设置查询的字段 
     * @param columns 要查询的字段 
     * @return Query对象 
     */  
    public Query columns(String... columns) {  
        mCocumns = columns;  
        return this;  
    }  
          
    /** 
     * 设置查询的where条件 
     * @param where where条件 
     * @param whereArgs where参数 
     * @return Query对象 
     */  
    public Query where(String where, String... whereArgs) {  
        mWhere = where;  
        mWhereArgs = whereArgs;  
        return this;  
    }  
      
    /** 
     * 设置查询的order 
     * @param order order语句 
     * @return Query对象 
     */  
    public Query order(String order) {  
        mOrder = order;  
        return this;  
    }  
          
    /** 
     * 设置查询的limit 
     * @param limit limit语句 
     * @return Query对象 
     */  
    public Query limit(int... limit) {  
        StringBuilder builder = new StringBuilder();  
        builder.append(limit[0]);  
              
        if(limit.length == 2) {  
            builder.append(",").append(limit[1]);  
        }  
              
        mLimit = builder.toString();  
              
        return this;  
    }  
          
    /** 
     * 查询 
     * @param klass 映射的bean 
     * @return 查询结果 
     */  
    public <T extends OpenDroid> List<T> find(Class<T> klass) {  
        return CRUD.query(klass, mCocumns, mWhere, mWhereArgs,   
                mOrder, mLimit, sSqliteDatabase);  
    }  
          
    /** 
     * 根据id查询数据 
     * @param klass klass 映射的bean 
     * @param id 要查询数据的id 
     * @return  查询结果 
     */  
    public <T extends OpenDroid> T find(Class<T> klass, int id) {  
        List<T> result = CRUD.query(klass, mCocumns, "_id=?",   
                new String[] { String.valueOf(id) }, null, "1",  
                sSqliteDatabase);  
        return result.size() > 0 ? result.get(0) : null;  
    }  
          
    public <T extends OpenDroid> List<T> find(Class<T> klass, int... ids) {  
        StringBuilder builder = new StringBuilder("_id in (");  
        String[] whereArgs = new String[ids.length];  
        buildIn(builder, whereArgs, ids);  
              
        return CRUD.query(klass, mCocumns, builder.toString(), whereArgs,   
                mOrder, mLimit, sSqliteDatabase);  
    }  
          
    /** 
     * 使用sql语句查询 
     * @param sql sql语句 
     * @param selectionArgs 预编译参数 
     * @return 
     */  
    public Cursor queryBySql(String sql, String[] selectionArgs) {  
    	return sSqliteDatabase.rawQuery(sql, selectionArgs);  
    }  
}



这个内部类中,上来咔咔咔列出了5个字段,注释已经说的很清楚了,其实就是组合查询语句用的。
往下看,我们看到了熟悉的方法,这些都是在上面介绍的时候用到的,并且一些方法的返回值都是this,大家应该很清楚,我们要级联操作嘛,就必须要返回当前对象。
好吧,第一个方法

/** 
 * 设置查询的字段 
 * @param columns 要查询的字段 
 * @return Query对象 
 */  
public Query columns(String... columns) {  
    mCocumns = columns;  
    return this;  
}  

很简单,就是把要查询的字段保存起来,然后返回当前对象。

/** 
 * 设置查询的where条件 
 * @param where where条件 
 * @param whereArgs where参数 
 * @return Query对象 
 */  
public Query where(String where, String... whereArgs) {  
    mWhere = where;  
    mWhereArgs = whereArgs;  
    return this;  
} 

where方法也很简单,保存了where条件和where条件的参数。

/** 
 * 设置查询的order 
 * @param order order语句 
 * @return Query对象 
 */  
public Query order(String order) {  
    mOrder = order;  
    return this;  
} 

好吧,一样的逻辑(哪里有逻辑!!!)

/** 
 * 设置查询的limit 
 * @param limit limit语句 
 * @return Query对象 
 */  
public Query limit(int... limit) {  
    StringBuilder builder = new StringBuilder();  
    builder.append(limit[0]);  
              
    if(limit.length == 2) {  
        builder.append(",").append(limit[1]);  
    }  
              
    mLimit = builder.toString();  
              
    return this;  
} 

设置limit, 这个方法还算长一点,但是一点内容也没有,就是组合一个limit语句,不过这里做了一个数组长度的判断,主要是为了适配limit 1和limit 1,2这两种方式。

/** 
 * 查询 
 * @param klass 映射的bean 
 * @return 查询结果 
 */  
public <T extends OpenDroid> List<T> find(Class<T> klass) {  
    return CRUD.query(klass, mCocumns, mWhere, mWhereArgs, mOrder, mLimit, sSqliteDatabase);  
}

这个查询方法直接调用了CRUD.query并返回它的返回值,相信大家看到CRUD肯定很熟悉了,我们定位到CRUD中query这个方法看看吧。

/** 
 * 查询数据 
 * @param klass 要映射的类 
 * @param columns 查询的字段, null 取所有 
 * @param where where条件, null 忽略条件 
 * @param whereArgs where的参数, null无参数 
 * @param order order语句, null忽略order by 
 * @param limit limit语句, null忽略limit 
 * @param db    数据库句柄 
 * @return 查询后的数据 
 */  
protected static <T extends OpenDroid> List<T> query(Class<T> klass, String[] columns,   
        String where, String[] whereArgs, String order, String limit, SQLiteDatabase db) {  
    List<T> resultList = new ArrayList<T>(); // 存放结果  
    String tableName = klass.getSimpleName(); // 获取类名(表名)  
    Cursor cursor = null;  
          
    try {  
        cursor = db.query(tableName, columns, where, whereArgs, null, null, order, limit);  
        foreachCursor(klass, cursor, resultList);  
    } catch (Exception e) {  
        e.printStackTrace();  
    } finally {  
        if(cursor != null) {  
            cursor.close();  
        }  
    }  
          
    return resultList;  
}

参数有点多,那么我们就从参数说起。
第一个参数是一个Class,应该很清晰了,我们要根据它来获取要查询的表明,接下来的一系列就是要查询的字段,条件,order语句,limit语句,最后一个是我们操作的数据库句柄。
继续看代码,首先new类一个ArrayList,并且获取了要操作的表名,接下来在try中,直接调用了android原生api的query返回一个Cursor对象,这就是我们查询的结果。接下来调用foreachCursor方法,将结果遍历到刚开new的那个ArrayList中,查询操作完毕!
那么我们来看看foreachCursor方法。

/** 
 * 遍历数据库游标 
 * @param klass 要映射的类 
 * @param cursor 要遍历的游标 
 * @param resultList 存放返回的结果 
 * @throws InstantiationException 
 * @throws IllegalAccessException 
 */  
private static <T extends OpenDroid> void foreachCursor(Class<T> klass,  
        Cursor cursor, List<T> resultList) throws InstantiationException,  
        IllegalAccessException {  
    T t; // 反射出的实例  
    String columnName; // 数据库字段名  
    String methodName; // 方法名  
    Method m; // 反射出的方法  
          
    for(cursor.moveToFirst();!cursor.isAfterLast();cursor.moveToNext()) {  
        t = klass.newInstance();  // 通过反射进行实例化  
        for(int i=0;i<cursor.getColumnCount();i++) {  
            columnName = cursor.getColumnName(i); // 获取数据库字段名  
            try {  
                switch (cursor.getType(i)) {  
                case Cursor.FIELD_TYPE_INTEGER:  
                    // 如果字段名是_id的话, 对应的方法是setId  
                    methodName = columnName.equals("_id") ? "setId" :   
                        getMethodName(cursor.getColumnName(i));  
                    m = klass.getMethod(methodName, int.class); // 反射出方法  
                    m.invoke(t, cursor.getInt(i)); // 执行方法  
                    break;  
                case Cursor.FIELD_TYPE_FLOAT:  
                    methodName = getMethodName(cursor.getColumnName(i));  
                    m = klass.getMethod(methodName, float.class);  
                    m.invoke(t, cursor.getFloat(i));  
                    break;  
                default:  
                    methodName = getMethodName(cursor.getColumnName(i));  
                    m = klass.getMethod(methodName, String.class);  
                    m.invoke(t, cursor.getString(i));  
                    break;  
                }  
            }catch(Exception e) {  
                e.printStackTrace();  
            }  
        }  
        resultList.add(t);  
    }  
}

又是一个巨长的...
我们来一点点分析吧。首先看参数,前两个不用说,最后一个参数是要存放我们遍历的结果的,这种方式在以前的博客中也有介绍过。
大体看一下这个方法,虽然很长,但是不难,switch case中的语句只需要了解一个剩下的就都了解了。
首先定义了4个变量,先有点印象。接着一个for循环,for循环也是做android的很熟悉的,就是去遍历游标,如果你还不清楚这里,建议去看看android原生api。
18行,我们获取Class的实例,实例化主要是为将表中的数据查询保存到我们的java bean中。
接下来19行,又是一个for循环,这个循环是循环的什么呢? 恩,这里是循环的该行的所有字段。
20行,获取当前index的字段名。
接下来一个switch case,这里我们只去观察第一个case语句中的代码。
25行是去拼凑一个setter,不过这个有点特殊,有一个二目运算符,我先解释一下这是为什么,还记得我曾经提到过id是opendroid默认添加的,而不需要我们去定义bean字段吗? 而且我们在分析创建数据库的源码中也看到了自动创建_id字段的代码,但是现在就有一个问题了。 我们没有id字段,id怎么放bean中呢? 所以在OpenDroid类中我强制定义了一个id字段,而且在使用的过程中,你也应该发现你的bean实例会有一个getId和setId的方法。看源码来证明一下吧:

private int id;  
public int getId() {  
    return id;  
}  
  
public void setId(int id) {  
    this.id = id;  
}

知道了这一点,我们再来理解这句话,如果查询的是_id字段,那么我们就去调用setId这个方法,否则就去调用getMethodName()根据当前数据库中的字段名拼凑出一个setter方法。
好吧,接着分析代码,27~28行,反射出我们拼凑的这个方法,并通过invoke去执行该方法,到这里,比如我们要获取stuName字段,那么Student.stuName就有值了。
在获取完当前行数据后,46行将生成的这个对象添加到ArrayList中保存起来。
总之,该方法的作用就是通过反射去实例化对应的类,并通过类中的setter方法设置值。
这里面还用到了一个getMethodName()方法,这个方法很简单,就是根据数据库字段名拼凑一个setXXX方法。

/** 
 * 根据字段名构建方法名 
 * @param columnName 
 * @return 
 */  
public static String getMethodName(String columnName) {  
    String methodName = columnName;  
    methodName = Character.toUpperCase(methodName.charAt(0)) + methodName.substring(1);  
    methodName = "set" + methodName;  
          
    return methodName;  
} 

很简单,不多说了,唯一需要注意的是第8行,意思是将字段名的首字母大写。

至此,一个find方法的流程就分析完了,其实剩下的find方法都是调用了同一个CRUD.query方法去查询的。

/** 
 * 根据id查询数据 
 * @param klass klass 映射的bean 
 * @param id 要查询数据的id 
 * @return  查询结果 
 */  
public <T extends OpenDroid> T find(Class<T> klass, int id) {  
    List<T> result = CRUD.query(klass, mCocumns, "_id=?",   
            new String[] { String.valueOf(id) }, null, "1",  
            sSqliteDatabase);  
    return result.size() > 0 ? result.get(0) : null;  
} 

这个方法调用了CRUD.query方法去查询的,只是我们确定了条件。

public <T extends OpenDroid> List<T> find(Class<T> klass, int... ids) {  
    StringBuilder builder = new StringBuilder("_id in (");  
    String[] whereArgs = new String[ids.length];  
    buildIn(builder, whereArgs, ids);  
              
    return CRUD.query(klass, mCocumns, builder.toString(), whereArgs,   
            mOrder, mLimit, sSqliteDatabase);  
} 

这个方法同样的原理,只需要是多个id,只要是多个id的,我们都是通过in语句去实现的,所以调用了buildIn方法去拼凑了一个in语句,剩下的和其他的find方法一样。


好啦,至此为止,opendroid的查询操作我们也介绍完了,也就是opendroid的所有CRUD操作有顺了一遍,那是不是opendroid所有功能都完了呢? 当然不是,还有我们的数据库升级方案呢! 所以下篇博客将会介绍opendroid的数据库升级方案!


最后是opendroid的开源地址:http://git.oschina.net/qibin/OpenDroid

郑重声明:本站内容如果来自互联网及其他传播媒体,其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享,并不代表本站赞同其观点和对其真实性负责,也不构成任何其他建议。