简介
greendao是一个开源的Android开发ORM使SQLite数据库，可以减轻和节省开发时间的同时处理低级别的数据库需求。SQLite是一个很好的嵌入式关系数据库，不过写SQL解析查询结果是相当繁琐和耗时的，greendao可以让你利用java对象来映射到数据库表便捷的使用Java面相对象的API来处理增、删、改、查的操作。
特点
- 性能大（貌似是Android最快的ORM）
- 易用性高
- 内存消耗极小
- 精简的库（小于100KB）
- 安全性高（支持SQLCipher来保持用户的数据安全）
- 支持RxJava
资料
配置环境
在build.gradle中配置
apply plugin: 'com.android.library'
//应用greendao插件
apply plugin: 'org.greenrobot.greendao'
android {
compileSdkVersion 25
buildToolsVersion "25.0.0"
defaultConfig {
minSdkVersion 15
targetSdkVersion 25
versionCode 1
versionName "1.0"
}
buildTypes {
release {
minifyEnabled false
proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
}
}
}
//greendao相关配置
greendao {
schemaVersion 1 //数据库版本号
daoPackage 'com.greendao.dao' //greendao自动生成的dao文件包名
targetGenDir 'src/main/java' //greendao自动生成的目标文件夹
}
//从maven中下载greendao插件
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath 'org.greenrobot:greendao-gradle-plugin:3.2.0'
}
}
//添加greendao需要的编译环境
dependencies {
compile fileTree(dir: 'libs', include: ['*.jar'])
compile 'com.android.support:appcompat-v7:25.0.0'
compile 'com.android.support:recyclerview-v7:25.0.0'
compile 'org.greenrobot:greendao:3.2.0'
compile 'org.greenrobot:greendao-generator:3.2.0'
compile 'io.reactivex:rxandroid:1.2.1'
compile 'io.reactivex:rxjava:1.1.6'
}
然后点击Sync Project with Gradle Files按钮下载编译环境，等待下载完成，环境配置就OK了。
开始
GreenDao3.0以后开始用注解配置数据表，使用起来非常快捷方便，下面代码简单的配置了User表，表里面有id和name两个字段
@Entity
public class User{
@Id
private Long id;
@NotNull
private String name;
}
然后用Build里面的Make Project或Make Module来自动生成相关DAO类和get set方法，完成之后，在我们定义好的com.greendao.dao包下也会多出DaoMaster、DaoSession、UserDao三个类，代码这里就不贴出来了，User实体会生成如下：
@Entity
public class User{
@Id
private Long id;
@NotNull
private String name;
@Generated(hash = 1709734220)
public User(Long id, @NotNull String name) {
this.id = id;
this.name = name;
}
@Generated(hash = 586692638)
public User() {
}
public Long getId() {
return this.id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
}
<b>数据表注解@Entity的详细配置</b>
@Entity(
// 目前还不是很清楚这个字段的功能和意义
schema = "myschema",
// 是否需要更新、删除属性和刷新方法，默认为true
active = true,
//指定数据库中的表的名称。默认是实体类的名称。
nameInDb = "AWESOME_USERS",
// 定义跨越多个列的索引。
indexes = {
@Index(value = "name DESC", unique = true)
},
// 默认为true,创建数据表，如果有多个实体映射到一个表或表创建在greenDao之外，则设置false
createInDb = false,
// 是否生成一个所有属性的构造函数，无参构造函数默认生成
generateConstructors = true,
// 是否自动生成get和set方法
generateGettersSetters = true
)
public class User {
...
}
注意：如果定义了 schema="myschema"，会报如下错误，具体解决方法暂时还没找到，有知道的小伙伴可以留言告知一下哦
* What went wrong:
Execution failed for task ':greendaolibrary:greendao'.
> Undefined schema \"myschema\" (referenced in entities: User).
Please, define non-default schemas explicitly inside build.gradle
<b>各个字段的详细注解</b>
@Id 主键ID注解，属性一般long或Long来定义，如果要设该字段为自增属性，那么可以定义为@Id(autoincrement = true)
@Property 字段名定义注解，@Property(nameInDb = "USER_NAME")，默认是驼峰法代替下划线，所有字母大写，如 customName 变成 CUSTOM_NAME
@NotNull 字段不能为空注解
@Transient 字段不添加到数据表注解
@Index 字段定义为索引注解，@Index(unique = true)索引添加唯一约束，@Index(name = "indexName")定义索引名
@Unique 字段定义唯一约束注解，并会创建索引
封装
定义DbCore.java类来获取全局唯一的DaoSession对象，代码如下：
public class DbCore {
private static final String DEFAULT_DB_NAME = "green_dao.db";
private static DaoMaster daoMaster;
private static DaoSession daoSession;
private static Context mContext;
private static String DB_NAME;
public static void init(Context context) {
init(context, DEFAULT_DB_NAME);
}
public static void init(Context context,String dbName) {
if (context == null) {
throw new IllegalArgumentException("context can't be null");
}
mContext = context.getApplicationContext();
DB_NAME = dbName;
}
public static DaoMaster getDaoMaster() {
if (daoMaster == null) {
OnlineOpenHelper helper = new OnlineOpenHelper(mContext, DB_NAME, null);
daoMaster = new DaoMaster(helper.getWritableDatabase());
}
return daoMaster;
}
public static DaoSession getDaoSession() {
if (daoSession == null) {
if (daoMaster == null) {
daoMaster = getDaoMaster();
}
daoSession = daoMaster.newSession();
}
return daoSession;
}
public static void enableQueryBuilderLog(){
QueryBuilder.LOG_SQL = true;
QueryBuilder.LOG_VALUES = true;
}
}
OnlineOpenHelper升级帮助类
public class OnlineOpenHelper extends DaoMaster.OpenHelper{
public OnlineOpenHelper(Context context,String name) {
super(context, name);
}
public OnlineOpenHelper(Context context,String name,SQLiteDatabase.CursorFactory factory) {
super(context, name, factory);
}
@Override
public void onUpgrade(Database db,int oldVersion,int newVersion) {
Log.i("greenDAO", "Upgrading schema from version " + oldVersion + " to " + newVersion );
}
}
需在在application中初始化
DbCore.init(this); //初始化GreenDao
DbCore.enableQueryBuilderLog(); //打印sql语句日志
封装所有的增删改查、获取Dao、获取RxDao、获取QueryBuilder等方法 到BaseService.java中
public class BaseService<T, K>{
private AbstractDao<T, K> mDao;
public BaseService(AbstractDao dao) {
mDao = dao;
}
public void save(T item) {
mDao.insert(item);
}
public void save(T... items) {
mDao.insertInTx(items);
}
public void save(List<T> items) {
mDao.insertInTx(items);
}
public void saveOrUpdate(T item) {
mDao.insertOrReplace(item);
}
public void saveOrUpdate(T... items) {
mDao.insertOrReplaceInTx(items);
}
public void saveOrUpdate(List<T> items) {
mDao.insertOrReplaceInTx(items);
}
public void deleteByKey(K key) {
mDao.deleteByKey(key);
}
public void delete(T item) {
mDao.delete(item);
}
public void delete(T... items) {
mDao.deleteInTx(items);
}
public void delete(List<T> items) {
mDao.deleteInTx(items);
}
public void deleteAll() {
mDao.deleteAll();
}
public void update(T item) {
mDao.update(item);
}
public void update(T... items) {
mDao.updateInTx(items);
}
public void update(List<T> items) {
mDao.updateInTx(items);
}
public T query(K key) {
return mDao.load(key);
}
public List<T> queryAll() {
return mDao.loadAll();
}
public List<T> query(String where,String... params) {
return mDao.queryRaw(where, params);
}
public QueryBuilder<T> queryBuilder() {
return mDao.queryBuilder();
}
public long count() {
return mDao.count();
}
public void refresh(T item) {
mDao.refresh(item);
}
public void detach(T item) {
mDao.detach(item);
}
public AbstractDao getDao(){
return mDao;
}
public RxDao<T,K> getRxDao(){
return mDao.rx();
}
public QueryBuilder<T> getQueryBuilder(){
return mDao.queryBuilder();
}
}
封装User表的所有操作到UserService.java类中，如后面有多个表，则只需简单继承BaseService如下即可，后面，所有相关User操作只需通过UserService.getInstance()来实现所有操作
public class UserService extends BaseService<User,Long>{
public UserService() {
super(DbCore.getDaoSession().getUserDao());
}
public static UserService getInstance(){
return SingleLoader.INSTANCE;
}
private static class SingleLoader{
final static UserService INSTANCE = new UserService();
}
}
使用
<b>增</b>
public void insert(){
String userName = user_name.getText().toString();
if(TextUtils.isEmpty(userName)){
return;
}
User user = new User(null,userName);
//UserService.getInstance().save(user); //方式一
//UserService.getInstance().getDao().save(user); //方式二
UserService.getInstance().getRxDao().insert(user) //方式三 Rx模式
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<User>() {
@Override
public void call(User note) {
search();
}
});
}
<b>删</b>
public void delete(){
if(mDatas.size()<=0){
return;
}
User user = mDatas.get(0);
//UserService.getInstance().delete(user);
//UserService.getInstance().getDao().delete(user);
UserService.getInstance().getRxDao().delete(user)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<Void>(){
@Override
public void call(Void aVoid){
search();
}
});
}
<b>改</b>
public void update(){
String userName = user_name.getText().toString();
if(TextUtils.isEmpty(userName)){
return;
}
User user = mDatas.get(0);
user.setName(userName);
//UserService.getInstance().update(user);
//UserService.getInstance().getDao().update(user);
UserService.getInstance().getRxDao().update(user)
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<User>(){
@Override
public void call(User user){
search();
}
});
}
<b>查</b>
ID降序查询所有数据
public void search() {
//List<User> users = UserService.getInstance().getQueryBuilder().orderDesc(UserDao.Properties.Id).build().list();
UserService.getInstance().getQueryBuilder().orderDesc(UserDao.Properties.Id).rx().list()
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<List<User>>(){
@Override
public void call(List<User> users){
mDatas.clear();
for(int i = 0;i<users.size();i++){
User user = users.get(i);
mDatas.add(user);
}
adapter.notifyDataSetChanged();
}
});
}
用Rx模式模糊查询
public void searchByName() {
String userName = user_name.getText().toString();
if(TextUtils.isEmpty(userName)){
return;
}
//方式一
//List<User> users = UserService.getInstance().getDao().queryBuilder().where(UserDao.Properties.Name.like("%"+userName+"%")).build().list();
//方式二
//List<User> users = UserService.getInstance().getDao().queryBuilder().where(new WhereCondition.PropertyCondition(UserDao.Properties.Name, " LIKE ?", "%"+userName+"%")).build().list();
//方式三
UserService.getInstance().getQueryBuilder().where(new WhereCondition.PropertyCondition(UserDao.Properties.Name, " LIKE ?", "%"+userName+"%")).rx().list()
.observeOn(AndroidSchedulers.mainThread())
.subscribe(new Action1<List<User>>(){
@Override
public void call(List<User> users){
mDatas.clear();
for(int i = 0;i<users.size();i++){
User user = users.get(i);
mDatas.add(user);
}
adapter.notifyDataSetChanged();
}
});
}
升级
<b>字段更新</b>
这里借鉴了国外大牛写的一个工具类，代码如下：
public class MigrationHelper{
private static final String CONVERSION_CLASS_NOT_FOUND_EXCEPTION = "MIGRATION HELPER - CLASS DOESN'T MATCH WITH THE CURRENT PARAMETERS";
private static MigrationHelper instance;
public static MigrationHelper getInstance() {
if(instance == null) {
instance = new MigrationHelper();
}
return instance;
}
public void migrate(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
generateTempTables(db, daoClasses);
DaoMaster.dropAllTables(db, true);
DaoMaster.createAllTables(db, false);
restoreData(db, daoClasses);
}
private void generateTempTables(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
for(int i = 0; i < daoClasses.length; i++) {
DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);
String divider = "";
String tableName = daoConfig.tablename;
String tempTableName = daoConfig.tablename.concat("_TEMP");
ArrayList<String> properties = new ArrayList<>();
StringBuilder createTableStringBuilder = new StringBuilder();
createTableStringBuilder.append("CREATE TABLE ").append(tempTableName).append(" (");
for(int j = 0; j < daoConfig.properties.length; j++) {
String columnName = daoConfig.properties[j].columnName;
if(getColumns(db, tableName).contains(columnName)) {
properties.add(columnName);
String type = null;
try {
type = getTypeByClass(daoConfig.properties[j].type);
} catch (Exception exception) {
exception.printStackTrace();
//Crashlytics.logException(exception);
}
createTableStringBuilder.append(divider).append(columnName).append(" ").append(type);
if(daoConfig.properties[j].primaryKey) {
createTableStringBuilder.append(" PRIMARY KEY");
}
divider = ",";
}
}
createTableStringBuilder.append(");");
db.execSQL(createTableStringBuilder.toString());
StringBuilder insertTableStringBuilder = new StringBuilder();
insertTableStringBuilder.append("INSERT INTO ").append(tempTableName).append(" (");
insertTableStringBuilder.append(TextUtils.join(",",properties));
insertTableStringBuilder.append(") SELECT ");
insertTableStringBuilder.append(TextUtils.join(",", properties));
insertTableStringBuilder.append(" FROM ").append(tableName).append(";");
db.execSQL(insertTableStringBuilder.toString());
}
}
private void restoreData(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
for(int i = 0; i < daoClasses.length; i++) {
DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);
String tableName = daoConfig.tablename;
String tempTableName = daoConfig.tablename.concat("_TEMP");
ArrayList<String> properties = new ArrayList<>();
for (int j = 0; j < daoConfig.properties.length; j++) {
String columnName = daoConfig.properties[j].columnName;
if(getColumns(db, tempTableName).contains(columnName)) {
properties.add(columnName);
}
}
StringBuilder insertTableStringBuilder = new StringBuilder();
insertTableStringBuilder.append("INSERT INTO ").append(tableName).append(" (");
insertTableStringBuilder.append(TextUtils.join(",", properties));
insertTableStringBuilder.append(") SELECT ");
insertTableStringBuilder.append(TextUtils.join(",", properties));
insertTableStringBuilder.append(" FROM ").append(tempTableName).append(";");
StringBuilder dropTableStringBuilder = new StringBuilder();
dropTableStringBuilder.append("DROP TABLE ").append(tempTableName);
db.execSQL(insertTableStringBuilder.toString());
db.execSQL(dropTableStringBuilder.toString());
}
}
private String getTypeByClass(Class<?> type) throws Exception{
if(type.equals(String.class)) {
return "TEXT";
}
if(type.equals(Long.class) || type.equals(Integer.class) || type.equals(long.class)) {
return "INTEGER";
}
if(type.equals(Boolean.class)) {
return "BOOLEAN";
}
Exception exception = new Exception(CONVERSION_CLASS_NOT_FOUND_EXCEPTION.concat(" - Class: ").concat(type.toString()));
//Crashlytics.logException(exception);
throw exception;
}
private static List<String> getColumns(Database db,String tableName) {
List<String> columns = new ArrayList<>();
Cursor cursor = null;
try {
cursor = db.rawQuery("SELECT * FROM " + tableName + " limit 1", null);
if (cursor != null) {
columns = new ArrayList<>(Arrays.asList(cursor.getColumnNames()));
}
} catch (Exception e) {
Log.v(tableName,e.getMessage(),e);
e.printStackTrace();
} finally {
if (cursor != null)
cursor.close();
}
return columns;
}
}
具体应用只需要在OnlineOpenHelper的onUpgrade方法中如下使用
switch(oldVersion){
//User表添加字段或删除字段更新
case 1: MigrationHelper.getInstance().migrate(db,UserDao.class);
}
<b>新增数据表</b>
@Entity
public class Role{
@Id
private Long id;
@NotNull
private String roleName;
}
在OnlineOpenHelper的onUpgrade方法添加RoleDao.createTable(db,false),如下：
switch(oldVersion){
//User表添加字段或删除字段更新
case 1: MigrationHelper.getInstance().migrate(db,UserDao.class);
//第二个参数true or false 是否需要检查是否存在该表
case 2: RoleDao.createTable(db,false);
}
到这里greenDao简单的操作处理都基本OK了！
写在最后的话：很多事情都从小事做起，坚持不懈，那么最终你也会从小牛变成大牛的。
