手撸一个简易Android数据库框架
# 一、简述
众所周知,移动端(不管是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;
}
可能这部分代码比较迷的地方就是<T extends BaseDao<M>, M>
了(先抛开方法体中的具体实现),其实这只是方法声明泛型的方式而已。我们知道,类上声明泛型很简单,只需要在类后面加上<T\>
(字母随意)即可,如:
// 类上泛型可以声明多个
public class Person<M,T> {
...
}
而方法上声明泛型跟类上声明泛型有些区别——泛型声明的位置不同,方法上的泛型需要在修饰符(public等)与返回值之间声明,如:
public <T> void eat(){
...
}
上面的代码不会报错,但一点意义都没有,因为泛型没被使用到,一般方法上声明的泛型可作为方法参数类型和返回值类型,如:
// 同样,方法泛型也可以声明多个
public <T,M> T eat(T t, M m){
...
}
可以这样认为,默认泛型表示的是Object(编码时),有时我们需要更加精确泛型的类型,这可以通过extends办到,如:
public <T extends Person> void doSomething(T t){
...
}
这时,传入doSomething()的参数必须是Person的子类(Boy或Girl),且在编码时,可以在方法体中使用t调用Person中声明的方法,如eat(),如果不使用extends来指定泛型T的具体类型,那么在编码时,t会被认为是Object类型,也就没法调用eat()这类自定义的方法了。到这里,回头再看上面的代码,应该就不会迷了。
# 四、数据库操作封装
前面一开始的时候就已经为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进行封装,总结上面的理论,代码分如下三步:
- 将对象中的属性转成键值对values。
- 将键值对values转成ContentValues对象。
- 使用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来替换),可分为两步:
- 将对象中的属性转成键值对whereMap。
- 使用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()方法来进行表数据查询,它的参数也比较多,这里就只封装三种查询:
- 将符合条件的表数据全部查询出来。
- 将符合条件的表数据查询出来,并可以排序。
- 将符合条件的表数据查询出来,除了可以排序,还可以分页查询。
需要注意的就是分页查询,因为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地址:
- 01
- Flutter - 轻松搞定炫酷视差(Parallax)效果09-21
- 02
- Flutter - 轻松实现PageView卡片偏移效果09-08
- 03
- Flutter - 升级到3.24后页面还会多次rebuild吗?🧐08-11