Android白银篇-GreenDao3

发表于 | 分类于 | | 热度 ℃

GreenDao

GreenDao 是一个将对象映射到 SQLite 数据库中的轻量且快速的 ORM 解决方案。它的本质就是提供一个面向对象的接口，使得开发者更加方便地将数据存储到数据库SQLite之中。我们只需要定义数据模型，GreenDao就会为我们生成实体类以及DAOs(data access objects)，（在3.0之后不需要我们编写generator而是编写实体类并添加注解，GreenDao会为我们生成schema，以及DAOs）从而避免了开发者编写较多枯燥的数据存储和加载的代码。

GreenDao传送门


GreenDao介绍

在GreenDao中，默认会为每一个实体类建立一张数据表，实体类的每一个属性对应数据表中的一列。

优点

  • Android精简的依赖库，方便集成
  • 性能最大化
  • 内存开销最小化
  • 易于使用的APIs
  • 对Android进行高度优化

性能比较

配置

GreenDao3 采用注解方式来定义实体类，通过gradle插件生成相应的代码。

配置插件

在工程根目录下的build.gradle文件里，添加代码：

1
2
3
4
5
dependencies {
	classpath 'com.android.tools.build:gradle:2.3.3'
	// 添加GreenDao插件	
	classpath 'org.greenrobot:greendao-gradle-plugin:3.2.0'
}

配置依赖

在Module下的build.gradle文件里，添加代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
apply plugin: 'com.android.application'
// 添加
apply plugin: 'org.greenrobot.greendao'

dependencies {
	// 添加
	compile 'org.greenrobot:greendao:3.2.0'
}

// 添加
greendao {
    schemaVersion 1
    daoPackage 'com.excellence.medical.greendao'
    targetGenDir 'src/main/java'
}

  • schemaVersion： 数据库版本号，默认为1
  • daoPackage： 生成的DAOs、DaoMaster、DaoSession包名；默认为entities（数据库实体类）所在的包名
  • targetGenDir: 生成的DAOs、DaoMaster、DaoSession的目录，默认为build/generated/source/greendao
  • generateTests: 设置true自动生成单元测试。
  • targetGenDirTests: 设置生成单元测试目录。默认为src/androidTest/java

基本用法

实体

创建带注解@Entity的实体类，实体类即数据表；通常（除开带@Transient注解的成员）实体类中成员就是数据库中对应的字段。然后make project编译项目，实体类会自动生成get、set方法，并且在targetGenDir目录下的daoPackage包里，如src/main/java/com/excellence/medical/greendao，生成DaoMaster、DaoSession、以及AccountDao。

如果想增加或减少数据库字段，删除实体类中自动生成的代码，然后进行增加或减少实体类中的成员。

1
2
3
4
5
6
7
8
9
10
@Entity(nameInDb = "account")
public class Account {

	@Id(autoincrement = true)
	private Long			id;
	@Unique
	private String			accountId;
	private String			accountName;
	private String			accountPwd;
}

注解

  • @Entity
    修饰实体类名

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    @Entity(
        // schema 名，多个 schema 时设置关联实体。插件产生不支持，需使用产生器
        // schema = "myschema",

        // 标记一个实体是否处于活动状态，活动实体有 update、delete、refresh 方法。默认为 false
        active = false,

        // 表名，默认为类名
        nameInDb = "Account",

        // 定义多列索引
        indexes = {
                @Index(value = "name DESC", unique = true)
        },

        // 标记是否创建表，默认 true。多实体对应一个表或者表已创建，不需要 greenDAO 创建时设置 false
        createInDb = true,

        // 是否产生所有参数构造器。默认为 true。无参构造器必定产生
        generateConstructors = true,

        // 如果没有 get/set 方法，是否生成。默认为 true
        generateGettersSetters = true
    )

  • 修饰实体类成员

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    // 主键，autoincrement设置自增，注意类型是Long，而不是long
    @Id(autoincrement = true)

    // 唯一，默认索引
    @Unique

    // 列名-字段名，默认使用变量名。变化：customName --> CUSTOM_NAME
    @Property(nameInDb = "USERNAME")

    // 索引，unique设置唯一，name设置索引别名
    @Index(unique = true)

    // 非空
    @NotNull

    // 忽略，不持久化，即数据表不创建该字段，可用关键字transient替代
    @Transient

    // 对一，实体属性 joinProperty 对应外联实体ID
    @ToOne(joinProperty = "fk_dogId")

    // 对多。实体ID对应外联实体属性 referencedJoinProperty
    @ToMany(referencedJoinProperty = "fk_userId")

    // 对多。@JoinProperty：name 实体属性对应外联实体属性 referencedName
    @ToMany(joinProperties = {@JoinProperty(name = "horseName", referencedName = "name")})

    // 对多。@JoinEntity：entity 中间表；中间表属性 sourceProperty 对应实体ID；中间表属性 targetProperty 对应外联实体ID
    @ToMany
    @JoinEntity(entity = JoinUserWithSheep.class, sourceProperty = "uId", targetProperty = "sId")

初始化

在Application中进行初始化，GreenDao打开数据库两种方式：①打开内部（/data/data/xxxpackageNamexxx/）数据库，②打开外部（其他目录下）数据库

  • 内部数据库

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    // 注意
    DaoMaster.OpenHelper helper = new DaoMaster.DevOpenHelper(this, VOD_DB, null);
    mDaoMaster = new DaoMaster(helper.getWritableDatabase());

    // 如果想使用Dao，直接用mDaoSession获取对应的Dao来操作
    mDaoSession = mDaoMaster.newSession();
    // Dao，执行增删改查操作
    AccountDao dao = mDaoSession.getAccountDao();

    // 如果想使用Sql语句，就使用mDaoDatabase操作
    mDaoDatabase = mDaoSession.getDatabase();

    // GreenDao有特殊的线程来处理数据库的耗时操作
    mAsyncSession = mDaoSession.startAsyncSession();

  • 外部数据库

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    public class DatabaseContext extends ContextWrapper {
    	
    	private String mDBPath = null;
    	
    	private DatabaseContext(Context base) {
    		super(base);
    	}
    	
    	public DatabaseContext(Context base, String dbPath) {
    		super(base);
    		mDBPath = dbPath;
    	}
    	
    	@Override
    	public File getDatabasePath(String name) {
    		String dbPath = mDBPath + name;
    		if (FileUtils.isFileExists(dbPath)) {
    			return new File(dbPath);
    		} else {
    			return null;
    		}
    	}
    	
    	@Override
    	public SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory) {
    		int flags = SQLiteDatabase.CREATE_IF_NECESSARY | SQLiteDatabase.NO_LOCALIZED_COLLATORS;
    		return SQLiteDatabase.openDatabase(getDatabasePath(name).getAbsolutePath(), factory, flags, null);
    	}
    	
    	@Override
    	public SQLiteDatabase openOrCreateDatabase(String name, int mode, SQLiteDatabase.CursorFactory factory, DatabaseErrorHandler errorHandler) {
    		int flags = SQLiteDatabase.CREATE_IF_NECESSARY | SQLiteDatabase.NO_LOCALIZED_COLLATORS;
    		return SQLiteDatabase.openDatabase(getDatabasePath(name).getAbsolutePath(), factory, flags, errorHandler);
    	}
    }
1
2
3
4
// 重写传入DaoMaster.DevOpenHelper的Context，即改变数据库的路径
DatabaseContext databaseContext = new DatabaseContext(this, DB_PATH);
DaoMaster.OpenHelper helper = new DaoMaster.DevOpenHelper(databaseContext, VOD_DB, null);
其他类似打开内部数据库

  • 注意：

    • DaoMaster.DevOpenHelper在数据库升级的时候，会删除所有的表，只能用于Debug调试，正式项目需要封装处理，GreenDao升级请参考：GreenDaoUpgradeHelper
    • 如果GreenDao想使用打开多个数据库，可以创建多个DaoMaster.OpenHelper和DaoSession；同时重写onCreate方法，否则每个数据库的表是一样的。例如：
      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      DaoMaster.OpenHelper helper = new DaoMaster.OpenHelper(this, DB_NAME) {
      		@Override
      		public void onCreate(Database db) {
      			ConfigDao.createTable(db, false);
      			MemberDao.createTable(db, false);
      		}
      	};
      	mDaoSession = new DaoMaster(helper.getWritableDatabase()).newSession();
      	
      	DaoMaster.OpenHelper encryptedHelper = new DaoMaster.OpenHelper(this, ENCRYPTED_DB_NAME) {
      		@Override
      		public void onCreate(Database db) {
      			AccountDao.createTable(db, false);
      		}
      	};
      	mEncryptedDaoSession = new DaoMaster(encryptedHelper.getEncryptedWritableDb(getUniquePseudoID())).newSession();

增删改查

  • 使用Dao操作时，数据库里必须有主键，操作才会成功；否则操作无效或达不到预期的结果

  • GreenDao有一个缓存机制，即把用户插入，更改或查找的实体保存在内存中，当用户下一次查找时先从内存中查找，如果不存在再从数据库中查找，清除缓存使用：DaoSession.clear()

  • 如果没有主键，则只能使用Sql语句操作数据库，可以参考：Android黄金篇-SQLite数据库

Dao增加

1
2
3
4
5
6
7
8
9
10
11
12
long     insert(T entity)  // 插入指定实体
void     insertInTx(T... entities)
void     insertInTx(java.lang.Iterable<T> entities)
void     insertInTx(java.lang.Iterable<T> entities, boolean setPrimaryKey)
long     insertWithoutSettingPk(T entity)  // 插入指定实体，无主键
long     insertOrReplace(T entity)  // 插入或替换指定实体
void     insertOrReplaceInTx(T... entities)
void     insertOrReplaceInTx(java.lang.Iterable<T> entities)
void     insertOrReplaceInTx(java.lang.Iterable<T> entities, boolean setPrimaryKey)
void     save(T entity)  // 依赖指定的主键插入或修改实体
void     saveInTx(T... entities)
void     saveInTx(java.lang.Iterable<T> entities)

Dao删除

1
2
3
4
5
6
7
void     deleteAll()  // 删除所有
void     delete(T entity)  // 删除指定的实体
void     deleteInTx(T... entities)
void     deleteInTx(java.lang.Iterable<T> entities)
void     deleteByKey(K key)  // 删除指定主键对应的实体
void     deleteByKeyInTx(K... keys)
void     deleteByKeyInTx(java.lang.Iterable<K> keys)

Dao修改

1
2
3
void     update(T entity)
void     updateInTx(T... entities)
void     updateInTx(java.lang.Iterable<T> entities)

Dao查询

1
2
3
java.util.List<T>     loadAll()
T     load(K key)
T     loadByRowId(long rowId)

QueryBuilder查询

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
QueryBuilder<T>     queryBuilder()  // Dao

// QueryBuilder
QueryBuilder<T>     where(WhereCondition cond, WhereCondition... condMore)  // 条件，AND 连接
QueryBuilder<T>     whereOr(WhereCondition cond1, WhereCondition cond2, WhereCondition... condMore)  // 条件，OR 连接
QueryBuilder<T>     distinct()  // 去重，例如使用联合查询时
QueryBuilder<T>     limit(int limit)  // 限制返回数
QueryBuilder<T>     offset(int offset)  // 偏移结果起始位，配合limit(int)使用
QueryBuilder<T>     orderAsc(Property... properties)  // 排序，升序
QueryBuilder<T>     orderDesc(Property... properties)  // 排序，降序
QueryBuilder<T>     orderCustom(Property property, java.lang.String customOrderForProperty)  // 排序，自定义
QueryBuilder<T>     orderRaw(java.lang.String rawOrder)  // 排序，SQL 语句
QueryBuilder<T>     preferLocalizedStringOrder()  // 本地化字符串排序，用于加密数据库无效
QueryBuilder<T>     stringOrderCollation(java.lang.String stringOrderCollation)  // 自定义字符串排序，默认不区分大小写

WhereCondition     and(WhereCondition cond1, WhereCondition cond2, WhereCondition... condMore)  // 条件，AND 连接
WhereCondition     or(WhereCondition cond1, WhereCondition cond2, WhereCondition... condMore)  // 条件，OR 连接

示例

1
mAccountDao.queryBuilder().orderDesc(Properties.Date).limit(1).unique()

DaoSession异步操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
DaoSession().startAsyncSession().runInTx(new Runnable() {

    @Override
    public void run() {
        // insert
        // delete
        // update
		// query
    }
});
DaoSession.startAsyncSession().insertInTx
DaoSession.startAsyncSession().deleteInTx
DaoSession.startAsyncSession().updateInTx
DaoSession.startAsyncSession().insertInTx
DaoSession.startAsyncSession().insertOrReplaceInTx

DaoSession增删改查

1
2
3
4
5
6
7
8
9
10
11
// DaoSession 的方法转换成 Dao 的对应方法执行
<T> long     insert(T entity)
<T> long     insertOrReplace(T entity)
<T> void     delete(T entity)
<T> void     deleteAll(java.lang.Class<T> entityClass)
<T> void     update(T entity)
<T,K> T     load(java.lang.Class<T> entityClass, K key)
<T,K> java.util.List<T>     loadAll(java.lang.Class<T> entityClass)
<T> QueryBuilder<T>     queryBuilder(java.lang.Class<T> entityClass)
<T,K> java.util.List<T>     queryRaw(java.lang.Class<T> entityClass, java.lang.String where, java.lang.String... selectionArgs)
<T> void     refresh(T entity)

Query重复查询

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// QueryBuilder
Query<T>     build()
CursorQuery     buildCursor()
CountQuery<T>     buildCount()
DeleteQuery<T>     buildDelete()

// Query
// 设置查询参数，从 0 开始
Query<T>     setParameter(int index, java.lang.Object parameter)
Query<T>     setParameter(int index, java.lang.Boolean parameter)
Query<T>     setParameter(int index, java.util.Date parameter)
void     setLimit(int limit)  // 限制返回数
void     setOffset(int offset)  // 偏移结果起始位，配合limit(int)使用

// Query 绑定线程，执行非本线程的 Query 抛异常，调用获取本线程 Query
Query<T>     forCurrentThread()  // 获取本线程 Query

查询结果

1
2
3
4
5
6
7
8
9
10
11
// QueryBuilder、Query
T     unique()  // 返回唯一结果或者 null
T     uniqueOrThrow()  // 返回唯一非空结果，如果 null 则抛异常
java.util.List<T>     list()  // 返回结果集进内存
// 懒加载，须在 try/finally 代码中关闭。
LazyList<T>     listLazy()  // 第一次使用返回结果集，所有数据使用后会自动关闭
LazyList<T>     listLazyUncached()  // 返回虚拟结果集，数据库读取不缓存
CloseableListIterator<T>     listIterator()  // 懒加载数据迭代器，不缓存，所有数据使用后会自动关闭

// QueryBuilder、CountQuery
long     count()  // 获取结果数量

混淆

在混淆文件proguard-rules.pro中添加

1
2
3
4
5
6
7
8
9
10
### greenDAO 3
-keepclassmembers class * extends org.greenrobot.greendao.AbstractDao {
public static java.lang.String TABLENAME;
}
-keep class **$Properties

# If you do not use SQLCipher:
-dontwarn org.greenrobot.greendao.database.**
# If you do not use RxJava:
-dontwarn rx.**

@ToOne、@ToMany，1：1、1：n、n：m等多张表关联待续^_^

谢谢老板，请尽情用红包来蹂躏我吧！！！
0%