greenDao3.x 详解-简单、明了

于 2017-05-19 14:00:37 发布
阅读量1.7k 收藏 4
点赞数 2
分类专栏： GreeDao 文章标签： 数据库 android greenDao ##特点-1-一
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010296640/article/details/72528515
版权

特点

1.一个精简的库
2.性能最大化
3.内存开销最小化
4.易于使用的 APIs
5.对 Android 进行高度优化
6.支持数据库加密

配置


  2. 在project的gradle文件中引入greenDAO插件

buildscript {
repositories {
jcenter()
}
dependencies {
classpath ‘com.android.tools.build:gradle:2.3.2’
classpath ‘org.greenrobot:greendao-gradle-plugin:3.2.1’
}
}
allprojects {
repositories {
jcenter()
}
}
task clean(type: Delete) {
delete rootProject.buildDir
}

2.在module的gradle文件中添加greenDAO的插件，并引入相关类库

apply plugin: ‘com.android.application’
apply plugin: ‘org.greenrobot.greendao’
android {
…
…
//greendao 相关配置
greendao {
//版本号-升级使用
schemaVersion 1
//greendao输出dao的数据库操作实体类文件夹（相对路径 包名+自定义路径名称，包将创建于包名的直接路径下）
daoPackage ‘com.xxx.greendao’
//greenDao实体类包文件夹
targetGenDir ‘src/main/java’
buildTypes {
…
…
}
dependencies {
…
…
//GreenDao
compile ‘org.greenrobot:greendao:3.2.0’
compile ‘net.zetetic:android-database-sqlcipher:3.5.7’//加密必须库
compile project(‘:mylibrary’)
}
}

注意：
在配置时若没有指定GreenDao自动生成实体包文件夹 targetGenDir ‘src/main/java’时，会有默认路径。默认路径为：project->app->build->generated->source->greendao->com.xxx.entity->…

初始化

1.创建一个实体类

/*@Entity注解标注,id列为必须字段，且类型必须为Long类型
@keep替代@Generated，表效益不MarkProject后字段仍可修改*/
@Entity
public class PersonBean {
@Id
@NotNull
private long id;
private String name;
private String age;
@Keep
public PersonBean(long id, String name, String age) {
this.id = id;
this.name = name;
this.age = age;
}
@Keep
public PersonBean() {
}
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;
}
public String getAge() {
return this.age;
}
public void setAge(String age) {
this.age = age;
}
}

2.MarkProject

点击Build–>MarkProject或者AS顶部工具栏小锤子或者Ctrl+F9完成GreenDao初始化，将会在配置的路径（ targetGenDir ‘src/main/java’）下生成DaoMaster，DaoSession和（实体对应Dao）PersonBeanDao。

3.新建Application（MyAPP）类全局初始化
注意：
1.此类需要在项目清单文件中配置；
2.如要使用自带加密功能，还需要引入加密库包：
compile ‘net.zetetic:android-database-sqlcipher:3.5.7

public class MyAPP extends Application {
private static DaoSession daoSession;
public static final boolean ENCRYPTED = true;//是否加密
public static final String DATA_PWD = “xxx”;//自定义加密秘钥
@Override
public void onCreate() {
super.onCreate();
initData();
}
//配置greenDao
private void initData() {
// 创建数据库
DaoMaster.DevOpenHelper daoHelper = new
DaoMaster.DevOpenHelper(this, ENCRYPTED ? “notes-db-encrypted” : “notes-db”);
// 获取可写数据库
Database db = ENCRYPTED ?
daoHelper.getEncryptedWritableDb(DATA_PWD) : daoHelper.getWritableDb();
// 获取数据库对象
DaoMaster daoMaster = new DaoMaster(db);
// 获取dao管理者
daoSession = daoMaster.newSession();
}
public static DaoSession getDaoInstant() {
return daoSession;
}
}

使用

1.新建实体操作类PersonDao
注意：此类非必须，仅仅是为封装自动生成PersonBeanDao的方法。也可以直接使用MakeProject时自动生成的Dao类（PersonBeanDao）调用相关方法。

public class PersonDao {
//插入数据
public static void insertPerson(PersonBean personBean) {
MyAPP.getDaoInstant().getPersonBeanDao().insertOrReplace(personBean);
}
// 删除数据通过id
public static void deletePerson(long id) {
APP.getDaoInstant().getPersonBeanDao().deleteByKey(id);
}
public static void updatePerson(PersonBean personBean) {
APP.getDaoInstant().getPersonBeanDao().update(personBean);
}
// 查询全部
public static List queryAll() {
return APP.getDaoInstant().getPersonBeanDao().loadAll();
}
// 条件查询
public static List queryPerson(String name) {
return APP.getDaoInstant().getPersonBeanDao().queryBuilder().where(PersonBeanDao.Properties.Name.eq(name)).list();
}
}
2.在项目中根据业务需求CRUD
…
…
PersonBean personBean = new PersonBean(1,name, password);
PersonDao.insertPerson(personBean);
…
…

升级

注意：默认升级（改变实体属性（表结构））会清空已有数据，解决思路：
1.创建临时表
2.删除原表
3.创建新表
4.复制临时表数据到新表并删除临时表
1.修改gradle中GreenDao的版本号文件

greendao {
schemaVersion 2 //比如之前是1
…
}
2.新建DaoMaster.OpenHelper子类（DBHelper）
public class DBHelper extends DaoMaster.OpenHelper {
public DBHelper(Context context, String name, SQLiteDatabase.CursorFactory factory) {
super(context, name, factory);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// super.onUpgrade(db, oldVersion, newVersion);
//操作数据库的更新，有几个表升级都作为参数可以传入，PersonBean.class是要升级的表
MigrationHelper.getInstance().migrate(db,PersonBean.class);
}
}

3.自定义数据迁移类（MigrationHelper）

package com.xxx;
import android.database.Cursor;
import android.text.TextUtils;
import android.util.Log;
import org.greenrobot.greendao.AbstractDao;
import org.greenrobot.greendao.database.Database;
import org.greenrobot.greendao.internal.DaoConfig;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import com.xxx.greendao.DaoMaster;
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);
    }

    /**
     * 生成临时列表
     *
     * @param db
     * @param 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();
                    }

                    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());

        }
    }

    /**
     * 存储新的数据库表 以及数据
     *
     * @param db
     * @param daoClasses
     */
    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()));
        exception.printStackTrace();
        throw exception;
    }

    private 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;
    }
}

4.更改配置
在MyAPP中

//配置greenDao
private void initData() {
DBHelper devOpenHelper = new DBHelper(this);
获取可写数据库
Database db = ENCRYPTED ?
daoHelper.getEncryptedWritableDb(DATA_PWD) : daoHelper.getWritableDb();
// 获取数据库对象
DaoMaster daoMaster = new DaoMaster(db);
// 获取dao管理者
daoSession = daoMaster.newSession();
}

爱喝白酒的啤酒猫
关注
  • 2
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值