手撸一个简易Android数据库框架

原创 2017年11月27日 11:55:26

一、简述

众所周知,移动端(不管是Android还是iOS)使用的数据库是Sqlite,这种小型的数据库很适合移动端存储大量的数据,使用上也跟mysql基本无差,但官方提供的API在操作性方面真不咋的,你必须掌握一定程度的sql语句,否则将很难驾驭。所以,有很多第三方的数据库框架就开始流行,如:GreenDao、Litepal等。这些ORM数据库框架,可以帮助开发者节省大量编写数据库操作代码的时间,只需对对象进行赋值操作,便能作用到数据库上,方便我们开发更加复杂的业务逻辑。本篇的主题就是做一个简易的数据库框架,使用设计模式、泛型、注解、反射这些高级技巧来实现。

二、数据库常用操作

数据库操作无非就是增删改查(CRUD),而且一般操作数据库表的类称为Dao类,所以可以为这些Dao类抽取一个共同的接口:

public interface IBaseDao<M> {

    Long insert(M entity);

    Integer delete(M where);

    Integer update(M entitiy, M where);

    List<M> query(M where);

    List<M> query(M where, String orderBy);

    List<M> query(M where, String orderBy, Integer page, Integer pageCount);

}

我们要做的数据库框架也是一个ORM框架,表现层不涉及任何sql语句,直接操作的是数据对象,但具体的数据类型在这个接口中并不清楚,所以使用泛型来表示。

三、Dao类工厂

一个程序,一般只有一个数据库,一个数据库中会包含多张表,例如用户表,权限表等,这就意味着,项目中,Dao类会有多个,因为数据库操作无非是CRUD,所以可以确定它们的结构相同,只是具体操作的表与字段不同(即数据类型不同),所以,使用“泛型+工厂”来生产这些Dao类最合适不过。下面先贴出Dao类工厂代码,再一一分析:

public class BaseDaoFactory {

    private static String mDbPath;
    private SQLiteDatabase mDatabase;

    private static class Instance {
        public static BaseDaoFactory INSTANCE = new BaseDaoFactory();
    }

    public static BaseDaoFactory getInstance() {
        return Instance.INSTANCE;
    }

    // 初始化数据库位置
    public static void init(String dbPath) {
        mDbPath = dbPath;
    }

    public BaseDaoFactory() {
        if (TextUtils.isEmpty(mDbPath)) {
            throw new RuntimeException("在使用BaseDaoFactory之前,请调用BaseDaoFactory.init()初始化好数据库路径。");
        }
        // 打开数据库,得到数据库对象
        mDatabase = SQLiteDatabase.openOrCreateDatabase(mDbPath, null);
    }

    public <T extends BaseDao<M>, M> T getDataHelper(Class<T> clazz, Class<M> entity) {
        T baseDao = null;
        try {
            baseDao = clazz.newInstance();
            baseDao.init(mDatabase, entity);
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return baseDao;
    }
}

1、数据库位置

使用SQLiteDatabase,可以在任意位置创建或打开一个数据库,这样的好处是:如果,用SQLiteOpenHelper来创建数据库,默认会将数据库文件创建到/data/data/包名/databases目录下,当应用被删除时,数据库也将同应用一起被删除,有时我们会有这样的需求,在用户重装安装App时,可以使用之前的数据库信息,例如:UC浏览器的书签本地恢复功能。

// 初始化数据库位置
public static void init(String dbPath) {
    mDbPath = dbPath;
}

public BaseDaoFactory() {
    if (TextUtils.isEmpty(mDbPath)) {
        throw new RuntimeException("在使用BaseDaoFactory之前,请调用BaseDaoFactory.init()初始化好数据库路径。");
    }
    // 打开数据库,得到数据库对象
    mDatabase = SQLiteDatabase.openOrCreateDatabase(mDbPath, null);
}

本框架可以让开发者自定义数据库的存放位置,因为在构造函数中会使用到该路径对数据库进行创建,所以这里使用静态方法的方式,在Dao工厂实例化之前先对其(mDbPath)进行赋值。这种方式在很多第三方框架的源码中很是常见,一般在自定义的Application中对通过调用框架的init()方法对框架中必需的变量进行赋值。

2、工厂单例

该框架中的Dao类工厂只要一个就够了,所以需要用到单例模式,常见的单例模式有饿汉式和懒汉式,这里选用静态内部类单例模式,原因是什么呢?

1)饿汉式

饿汉式在类加载时就已经初始化好了,不管项目中是否使用,都会占用内存,虽然效率高,但开发中一般不用。

public class BaseDaoFactory {
    private static BaseDaoFactory Instance = new BaseDaoFactory();
    public static BaseDaoFactory getInstance() {
        return Instance;
    }
}

2)懒汉式

懒汉式虽然解决了饿汉式的弊端,实现调用时创建单例,但线程不安全,当然我们可以使用双重检测机制来解决,但这样也降低了效率(至少第一次初始化时需要同步,降低了效率),是开发中最常见的单例实现方式。

public class BaseDaoFactory {
    private static BaseDaoFactory mInstance;
    public static BaseDaoFactory getInstance() {
        if (mInstance == null) {
            synchronized (BaseDaoFactory.class) {
                if (mInstance == null) {
                    mInstance = new BaseDaoFactory();
                }
            }
        }
        return mInstance;
    }
}

3)静态内部类单例

静态内部类单例综合了前面两者的优点,即调用时创建单例,效率高且没有线程安全问题。当在调用getInstance()方法创建工厂单例时,静态内部类Instance才会被加载,同时初始化内部类属性INSTANCE,即初始化外部类BaseDaoFactory对象(Dao工厂),因为该静态内部类只会加载一次,所以该INSTANCE对象也只会被创建一次。

private static class Instance {
    public static BaseDaoFactory INSTANCE = new BaseDaoFactory();
}

public static BaseDaoFactory getInstance() {
    return Instance.INSTANCE;
}

// 单例模式,一般会将构造函数私有化,以保证不会被外界初始化。
private BaseDaoFactory() {
   ...
}

3、生产Dao类

Dao工厂会提供一个public方法来供外界获取需要的Dao类,而外界只需要传入具体Dao类和数据实体类对应的class即可。

public <T extends BaseDao<M>, M> T getDataHelper(Class<T> clazz, Class<M> entity) {
    T baseDao = null;
    try {
        baseDao = clazz.newInstance();
        baseDao.init(mDatabase, entity);
    } catch (InstantiationException e) {
        e.printStackTrace();
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return baseDao;
}

可能这部分代码比较迷的地方就是

四、数据库操作封装

前面一开始的时候就已经为Dao类抽取了一个共同的接口,规范了Dao类的基本操作,而且,我们不想在具体的Dao类中直接操作数据库,所以,在这两者中间必须有一层来完成数据库操作,并对各操作方法进行封装,它就是BaseDao,以下是该类中可供外界调用的方法:

public abstract class BaseDao<M> implements IBaseDao<M> {
    protected boolean init(SQLiteDatabase database, Class<M> entity) {
        ...
    }
    @Override
    public Long insert(M entity) {
        ...
    }
    @Override
    public Integer delete(M where) {
        ...
    }

    @Override
    public Integer update(M entitiy, M where) {
        ...
    }

    @Override
    public List<M> query(M where) {
        ...
    }

    @Override
    public List<M> query(M where, String orderBy) {
        ...
    }

    @Override
    public List<M> query(M where, String orderBy, Integer page, Integer pageCount) {
        ...
    }
}

在框架设计中,要切记,不需要被外界(表现层)所知的方法或属性请尽量私有化,一来对框架安全,二来避免团队开发中不必要的冲突。因为BaseDao的init()方法只被DaoFactory调用,且两者均在同包下,故使用protected修饰。

1、自定义注解:TbName和TbField

在对BaseDao进行解析前,先来说说两个十分重要的注解——TbName和TbField。几乎市面上所有的ORM数据库框架,都会用到自定义注解来对一个数据实体进行描述,比如User类的类名对应表的表名,有可能是user,也有可能是t_user,那开发者就可以使用框架提供的注解(TbName)来进行自定义表名了,同理,类中的属性名对应表的字段名也是如此,不过对于表的初始化还需要知道表字段的长度,所以表字段注解(TbField)还多了一个length属性。

/**
 * 表名注解
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface TbName {
    String value();
}

/**
 * 表字段注解
 */
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
public @interface TbField {
    String value();
    int length();
}

一方面,BaseDao对TbName和TbField的解析是处于程序运行阶段,所以这2个注解必须是运行时可见,即Retention的值必须是RetentionPolicy.RUNTIME。
另一方面,TbName是要注解在类上的,所以其Target的值是ElementType.TYPE;而TbField则是注解在类属性上的,所以其Target的值是ElementType.FIELD。

2、Dao类初始化

在Dao工厂中就已经使用了这个BaseDao的init()方法,来对Dao类进行一些通用的初始化工作,下面就来看看它都初始化了什么:

/**
 * 初始化表操作对象,一般包括:创建表、获取表字段与类字段的映射关系
 */
protected boolean init(SQLiteDatabase database, Class<M> entity) {
    mDatabase = database;
    mEntityClass = entity;

    // 往后的操作必须是基于数据库已经打开的前提下
    if (!database.isOpen()) {
        return false;
    }

    // 获取表名
    TbName tbName = entity.getAnnotation(TbName.class);
    mTbName = tbName == null ? entity.getSimpleName() : tbName.value();

    // 获取表映射字段
    if (!genFieldMap()) {
        return false;
    }

    // 创建数据库
    if (!createTable(database)) {
        return false;
    }

    return true;
}

在这个init()方法中,可以看到,注解TbName率先被该框架使用到了,当开发者有使用该注解时,表名以TbName注解中的值为表名,否则以类名作为表名。

注解是“静态的”,在类加载时就已经固定了,也就是说运行时无法修改其值(javassist方式除外),所以,可以利用类的class对象,通过 getAnnotation(注解.class).注解属性() 这种方法也获取注解的属性值。

1)获取表字段与类字段的映射关系

我们知道,类的属性名可能会与表的字段名不同,而BaseDao中的很多后续操作都会跟这两者打交道,所以,在BaseDao的初始化过程中将这两者的关系使用Map进行保存,方便后续的各种操作。

private boolean genFieldMap() {
    mFieldMap = new HashMap<>();
    Field[] fields = mEntityClass.getFields();
    if (fields == null || fields.length == 0) {
        Log.e(TAG, "获取不到类中字段");
        return false;
    }
    for (Field field : fields) {
        field.setAccessible(true);
        TbField tbField = field.getAnnotation(TbField.class);
        mFieldMap.put(tbField == null ? field.getName() : tbField.value(), field);
    }
    return true;
}    

反射中的几个小知识点:

  • Field[] fields = mEntityClass.getFields();// 得到类中的public字段,包括父类。
  • Field[] fields = mEntityClass.getDeclaredFields();// 得到类中声明的字段(不管是public、protected、private),不包括父类。
  • field.setAccessible(true);// 将私有属性或final属性可以被访问

考虑到数据实体类可能会使用继承的方式来拓展父类,即会用到父类的属性值,所以使用getFields()方法,但代价就是实体类中的属性必须是public的。

2)创建表

Dao类的初始化工作也包括了表的创建。一方面,因为不能在每次创建并初始化Dao类时都去重新创建一次表,所以这里就用到了sql语句中的 if not exists 关键字来避免重复创建表的问题。另一方面,其实创建表的sql语句是一种模板,两个不同的表在使用sql创建时,无非就是表名、字段名、字段类型和字段长度不同,而恰好,这些不同的元素可以使用反射+TbField注解来获取,从而实现sql语句的动态拼接,结合上一步得到的表字段与类字段的映射关系(mFieldMap),代码可以这么写:

/**
 * 创建表(可以被子类重写,方便灵活扩展)
 */
protected boolean createTable(SQLiteDatabase database) {
    StringBuilder sb = new StringBuilder();
    for (Map.Entry<String, Field> entry : mFieldMap.entrySet()) {
        String columnName = entry.getKey();
        Field field = entry.getValue();
        TbField tbField = field.getAnnotation(TbField.class);
        int length = tbField == null ? 255 : tbField.length();
        String type = "";
        Class<?> fieldType = field.getType();
        if (fieldType == String.class) {
            type = "varchar";
        } else if (fieldType == int.class || fieldType == Integer.class) {
            type = "int";
        } else if (fieldType == double.class || fieldType == Double.class) {
            type = "double";
        } else if (fieldType == float.class || fieldType == Float.class) {
            type = "float";
        }
        if (TextUtils.isEmpty(type)) {
            Log.e(TAG, type.getClass().getName() + "是不支持的字段");
        } else {
            sb.append(columnName + " " + type + "(" + length + "),");
        }
    }
    sb.deleteCharAt(sb.lastIndexOf(","));
    String s = sb.toString();
    if (TextUtils.isEmpty(s)) {
        Log.e(TAG, "获取不到表字段信息");
        return false;
    }
    String sql = "create table if not exists " + mTbName + " (" + s + ") ";
    Log.e(TAG, sql);
    database.execSQL(sql);
    return true;
}

到这里,Dao类的初始化工作就完了,下面进行CRUD的封装。

3、增

我们知道,若使用原生的SQLiteDatabase将数据插入到表中,需要将数据先封装成ContentValues对象,再调用其insert()方法来执行数据插入操作。那么,现在我们拥有了一个数据实体,要做的,就是将这个数据实体转成ContentValues对象,再使用SQLiteDatabase的insert()方法来执行插入,可以说我们就是对SQLiteDatabase进行封装,总结上面的理论,代码分如下三步:

  1. 将对象中的属性转成键值对values。
  2. 将键值对values转成ContentValues对象。
  3. 使用SQLiteDatabase的insert()方法进行数据插入。

结合mFieldMap,实现表数据插入的代码可以这么写:

@Override
public Long insert(M entity) {
    try {
        Map<String, String> values = getValues(entity);
        ContentValues cv = getContentValues(values);
        return mDatabase.insert(mTbName, null, cv);
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return 0L;
}

/**
 * 将对象中的属性转成键值对(列名--值)
 */
private Map<String, String> getValues(M entity) throws IllegalAccessException {
    Map<String, String> result = new HashMap<>();
    for (Map.Entry<String, Field> entry : mFieldMap.entrySet()) {
        Object value = entry.getValue().get(entity);
        result.put(entry.getKey(), value == null ? "" : value.toString());
    }
    return result;
}

/**
 * 将键值对转成ContentValues
 */
private ContentValues getContentValues(Map<String, String> values) {
    ContentValues cv = new ContentValues();
    for (Map.Entry<String, String> val : values.entrySet()) {
        cv.put(val.getKey(), val.getValue());
    }
    return cv;
}

4、删

要实现删除表数据功能,需要使用到SQLiteDatabase的delete()方法,其中whereClause和whereArgs是关键。又因为该框架是一个ORM框架,在表现层需要将删除条件使用数据实体进行封装,而框架内部则是对传入的数据实体进行解析,将对象中属性值不为null的属性拿出来作为删除的条件(这也意味着常见的数据类型不能用了,如int,但可以使用Integer来替换),可分为两步:

  1. 将对象中的属性转成键值对whereMap。
  2. 使用Condition类的构造函数对whereMap中value不为null的键值对取出来拼接。

综上所述,BaseDao的表数据删除实现代码如下:

@Override
public Integer delete(M where) {
    try {
        Map<String, String> whereMap = getValues(where);
        Condition condition = new Condition(whereMap);
        return mDatabase.delete(mTbName, condition.whereClause, condition.whereArgs);
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return 0;
}

class Condition {
    public Condition(Map<String, String> whereMap) {

        StringBuilder sb = new StringBuilder();
        List<String> list = new ArrayList<>();

        for (Map.Entry<String, String> entry : whereMap.entrySet()) {
            if (!TextUtils.isEmpty(entry.getValue())) {
                sb.append("and " + entry.getKey() + "=? ");
                list.add(entry.getValue());
            }
        }
        this.whereClause = sb.delete(0, 4).toString();
        this.whereArgs = list.toArray(new String[list.size()]);
    }

    String whereClause;
    String[] whereArgs;
}

whereClause是删除条件,是个字符串,需要使用?来作为占位符,多个条件需要使用and关键字连接,如:name=? and password=?
whereArgs则是对whereClause中占位符进行数值替换的字体串数组,如:new String[]{“LQR”,”123456”}

5、改

通过前面对表数据增和删的代码实现,更新数据部分就比较好理解了,因为SQLiteDatabase的update()方法需要用到的参数有ContentValues对象,whereClause和whereArgs,其实就是将增和删的代码实现相加起来而已,这就不多废话,实现的代码如下:

@Override
public Integer update(M entitiy, M where) {
    try {
        Map<String, String> values = getValues(entitiy);
        ContentValues cv = getContentValues(values);

        Map<String, String> whereMap = getValues(where);
        Condition condition = new Condition(whereMap);

        return mDatabase.update(mTbName, cv, condition.whereClause, condition.whereArgs);
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    }
    return 0;
}

6、查

终于到了CRUD的最后一步:数据查询(Retrieve)。可以说这是数据库操作中最重要且使用频率最高的一部分了,同样的,表数据查询还是用到了SQLiteDatabase,使用其query()方法来进行表数据查询,它的参数也比较多,这里就只封装三种查询:

  1. 将符合条件的表数据全部查询出来。
  2. 将符合条件的表数据查询出来,并可以排序。
  3. 将符合条件的表数据查询出来,除了可以排序,还可以分页查询。

需要注意的就是分页查询,因为SQLiteDatabase的第一页是从0开始的,而我希望的是表现层从1开始,所以框架代码中会对其进行自减处理。这三个方法的代码具体实现如下:

@Override
public List<M> query(M where) {
    return query(where, null);
}

@Override
public List<M> query(M where, String orderBy) {
    return query(where, orderBy, null, null);
}

@Override
public List<M> query(M where, String orderBy, Integer page, Integer pageCount) {
    List<M> list = null;
    Cursor cursor = null;
    try {
        String limit = null;
        if (page != null && pageCount != null) {
            int startIndex = --page;
            limit = (startIndex < 0 ? 0 : startIndex) + "," + pageCount;
        }

        if (where != null) {
            Map<String, String> whereMap = getValues(where);
            Condition condition = new Condition(whereMap);
            cursor = mDatabase.query(mTbName, null, condition.whereClause, condition.whereArgs, null, null, orderBy, limit);
        } else {
            cursor = mDatabase.query(mTbName, null, null, null, null, null, orderBy, limit);
        }

        // 将查询出来的表数据转成对象集合
        list = getDataList(cursor);
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    } finally {
        if (cursor != null) {
            cursor.close();
            cursor = null;
        }
    }
    return list;
}

/**
 * 通过游标,将表中数据转成对象集合
 */
private List<M> getDataList(Cursor cursor) throws IllegalAccessException, InstantiationException {
    if (cursor != null) {
        List<M> result = new ArrayList<>();
        // 遍历游标,获取表中一行行的数据
        while (cursor.moveToNext()) {

            // 创建对象
            ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass();// 获取当前new的对象的 泛型的父类 类型
            Class<M> clazz = (Class<M>) pt.getActualTypeArguments()[0];// 获取第一个类型参数的真实类型
            M item = clazz.newInstance();

            // 遍历表字段,使用游标一个个取值,赋值给新创建的对象。
            Iterator<String> iterator = mFieldMap.keySet().iterator();
            while (iterator.hasNext()) {
                // 找到表字段
                String columnName = iterator.next();
                // 找到表字段对应的类属性
                Field field = mFieldMap.get(columnName);

                // 根据类属性类型,使用游标获取表中的值
                Object val = null;
                Class<?> fieldType = field.getType();
                if (fieldType == String.class) {
                    val = cursor.getString(cursor.getColumnIndex(columnName));
                } else if (fieldType == int.class || fieldType == Integer.class) {
                    val = cursor.getInt(cursor.getColumnIndex(columnName));
                } else if (fieldType == double.class || fieldType == Double.class) {
                    val = cursor.getDouble(cursor.getColumnIndex(columnName));
                } else if (fieldType == float.class || fieldType == Float.class) {
                    val = cursor.getFloat(cursor.getColumnIndex(columnName));
                }

                // 反射给对象属性赋值
                field.set(item, val);
            }
            // 将对象添加到集合中
            result.add(item);
        }
        return result;
    }
    return null;
}

至此,这个简易的数据库框架就写好了,下面来测试一下。

五、测试

Activity的布局很简单,我就不贴了,就是几个简单的按钮而已。

1、测试前准备

1)User

一个简单的数据实体类,没什么好说的,看代码。

@TbName("tb_user")
public class User {

    @TbField(value = "tb_name", length = 30)
    public String username;

    @TbField(value = "tb_password", length = 20)
    public String password;

    @TbField(value = "tb_age", length = 11)
    public Integer age;

    public User() {
    }

    public User(String username, String password) {
        this.username = username;
        this.password = password;
    }

    public User(String username, String password, int age) {
        this.username = username;
        this.password = password;
        this.age = age;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "[username:" + this.username + ", password:" + this.getPassword() + ", age:" + this.getAge() + "]";
    }
}

2)UserDao

可以看到这个UserDao中其实没什么代码,但它可以通过重写父类createTable()方法来更灵活的创建表,或自定义一些其它的方法来扩展其父类的功能。

public class UserDao extends BaseDao<User> {
    // @Override
    // protected boolean createTable(SQLiteDatabase database) {
    // database.execSQL("create table if not exists t_user(tb_name varchar(30),tb_password varchar(10))");
    // return super.createTable(database);
    // }
}

2、功能测试

1)初始化

这个框架需要指定一个数据库位置,我们在Activity的onCreate()方法中调用框架的init()方法来指定,建议最好放到自定义的Application中。

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_customer_db_frame);
    BaseDaoFactory.init(new File(getFilesDir(), "csdn_lqr.db").getAbsolutePath());
    mUserDao = BaseDaoFactory.getInstance().getDataHelper(UserDao.class, User.class);
    mUser = new User("CSDN_LQR", "123456", 10);
}

2)增

往user表中插入一条username为”CSDN_LQR”,password为”123456”的数据:

public void insert(View view) {
    Long insert = mUserDao.insert(mUser);
    Toast.makeText(getApplicationContext(), "添加了" + (insert != -1 ? 1 : 0) + "条数据", Toast.LENGTH_SHORT).show();
}

3)删

从user表中删除一条username为”CSDN_LQR”的数据:

public void delete(View view) {
    User where = new User();
    where.setUsername("CSDN_LQR");
    Integer delete = mUserDao.delete(where);
    Toast.makeText(getApplicationContext(), "删除了" + delete + "条数据", Toast.LENGTH_SHORT).show();
}

4)改

将user表中username为”CSDN_LQR”的数据进行修改:

public void update(View view) {
    User user = new User("LQR_CSDN", "654321", 9);

    User where = new User();
    where.setUsername("CSDN_LQR");

    Integer update = mUserDao.update(user, where);
    Toast.makeText(getApplicationContext(), "修改了" + update + "条数据", Toast.LENGTH_SHORT).show();
}

5)查

a. 将符合条件的表数据全部查询出来

将user表中所有username为”CSDN_LQR”的数据全部查询出来:

public void query1(View view) {
    User where = new User();
    where.setUsername("CSDN_LQR");

    List<User> list = mUserDao.query(where);
    int query = list == null ? 0 : list.size();
    Toast.makeText(getApplicationContext(), "查出了" + query + "条数据", Toast.LENGTH_SHORT).show();
    for (User user : list) {
        System.out.println(user);
    }
}

b. 将符合条件的表数据查询出来,并排序

将user表中的数据按age的正反序分别查询出来:

public void query2(View view) {
    List<User> list = mUserDao.query(null, "tb_age asc");
    int query = list == null ? 0 : list.size();
    Toast.makeText(getApplicationContext(), "查出了" + query + "条数据", Toast.LENGTH_SHORT).show();
    for (User user : list) {
        System.out.println(user);
    }
}

public void query3(View view) {
    List<User> list = mUserDao.query(null, "tb_age desc");
    int query = list == null ? 0 : list.size();
    Toast.makeText(getApplicationContext(), "查出了" + query + "条数据", Toast.LENGTH_SHORT).show();
    for (User user : list) {
        System.out.println(user);
    }
}

c. 将符合条件的表数据查询出来,并分页。

只查询user表中的前2条数据:

public void query4(View view) {
    User where = new User();

    List<User> list = mUserDao.query(where, null, 1, 2);
    int query = list == null ? 0 : list.size();
    Toast.makeText(getApplicationContext(), "查出了" + query + "条数据", Toast.LENGTH_SHORT).show();
    for (User user : list) {
        System.out.println(user);
    }
}

大成功,撒花。

最后贴下Demo地址:

https://github.com/GitLqr/SimpleDbFrame

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/CSDN_LQR/article/details/78643552

SQLiteDatabase的openOrCreateDatabase方法的返回类型为null

db = openOrCreateDatabase("sign.db",MODE_PRIVATE,null); db.execSQL("create table if not exists sign...
  • sinat_37892592
  • sinat_37892592
  • 2017-03-18 23:58:13
  • 214

【Android 数据库框架总结,总有一个适合你!】

一:OrmLite 简述: 优点: 1.轻量级;2.使用简单,易上手;3.封装完善;4.文档全面。缺点:1.基于反射,效率较低(本人还没有觉得效率低);2.缺少中文翻译文档 jar包 地址:ht...
  • da_caoyuan
  • da_caoyuan
  • 2017-03-11 11:34:37
  • 24518

android不在坑系列一:数据库框架的选择

android不在坑系列一:数据库框架的选择前言: 之前用过的litepal数据库框架,郭大婶的维护的,还记得以前拿着帮同学做过几个毕业设计呢,没办法团支书当的苦逼了,同学一餐饭,喝顿酒,我心一软就帮...
  • Jack_King007
  • Jack_King007
  • 2017-04-18 14:07:15
  • 2378

Android数据库框架——GreenDao轻量级的对象关系映射框架,永久告别sqlite

Android数据库框架——GreenDao轻量级的对象关系映射框架,永久告别sqlite 前不久,我在写了ORMLite这个框架的博文Android数据库框架——ORMLite轻量级的对象关系映...
  • qq_26787115
  • qq_26787115
  • 2016-07-03 14:51:33
  • 16476

android数据库框架

  • 2016年02月05日 18:26
  • 118KB
  • 下载

Android 中数据库框架GreenDao与LitePal对比、集成、使用详解,greendao与原生SQLite性能对比

1.性能对比:参考这篇文章http://blog.csdn.net/aggies/article/details/45200627 2.LitePal框架详解。【操作非常简单,适合于数据库操作较少的项...
  • yingtian648
  • yingtian648
  • 2017-02-23 15:09:12
  • 3311

Android 数据库框架LitePal使用详解

以前一直觉得Android对SQLite数据库的操作非常简单,封装的很完善了。当我看到了郭神的LitePal框架之后我就在心理暗笑了,原来数据库还可以这样玩,真是大开眼界了。甚至你都不用写一句SQL语...
  • chengliang0315
  • chengliang0315
  • 2016-11-22 17:12:05
  • 6242

自主研发Android sqlite数据库操作通用框架AHibernate(一)-1.0发布和使用说明

AHibernate简介 一句话描述,使用AHibernate框架进行sqlite数据库操作您将从重复性劳动中解脱出来. (一)支持功能: 1.自动建表,支持属性来自继承类:可根据注解自动完成建表,...
  • lk_blog
  • lk_blog
  • 2012-04-13 00:09:03
  • 36576

android数据库框架SugarORM的简单使用

原文地址:http://satyan.github.io/sugar/getting-started.html 步骤1:下载 Gradle:  compile 'com.github.satyan:...
  • cheng9981
  • cheng9981
  • 2016-11-30 22:53:28
  • 2679

2017Android通用框架

http://mp.weixin.qq.com/s?__biz=MzA3Njg4NTI1NQ==&mid=2649860050&idx=1&sn=5356f17c124e51f5b3dece961e3...
  • u012758803
  • u012758803
  • 2017-02-08 18:25:41
  • 455
收藏助手
不良信息举报
您举报文章:手撸一个简易Android数据库框架
举报原因:
原因补充:

(最多只允许输入30个字)