GreenDao3.2.2

作者: ForeverValid | 来源:发表于2017-10-30 16:33 被阅读0次

GreenDao 简介

greenDAO是一个开源的Android ORM，使SQLite数据库的开发再次有趣。
它减轻开发人员处理低级数据库需求，同时节省开发时间。

SQLite是一个令人敬畏的嵌入式关系数据库。
然而，编写SQL和解析查询结果是相当乏味和耗时的任务。

通过将Java对象映射到数据库表（称为ORM，“对象/关系映射”），
greenDAO可以将它们从这些映射中释放出来。
这样，您可以使用简单的面向对象的API来存储，更新，删除和查询Java对象。

GreenDao 优势

1.最高性能（可能是Android最快的ORM）; 我们的基准也是开源的
2.易于使用的功能强大的API涵盖关系和联接
3.内存消耗最小
4.GreenDAO核心库（<100KB），不会影响Apk的大小。
5.数据库加密：greenDAO支持SQLCipher，以保护用户的数据安全
6.强大的社区：超过5.000 GitHub明星表明有一个强大和积极的社区

GreenDao 的项目配置

在项目的Android的build.gradle(Module:app) 文件中的dependencies标签下添加

dependencies {
compile'org.greenrobot:greendao:3.2.2'
compile'org.greenrobot:greendao-generator:3.2.2'
}

在项目的Android的build.gradle(Module:app) 文件中的顶部添加插件代码

apply plugin: 'org.greenrobot.greendao'

在项目的Android的build.gradle(Module:app) 文件中的android标签下添加

//自定义路径
    greendao {
        schemaVersion 1//当前版本的数据库模式。这被OpenHelpers类用于在模式版本之间迁移。如果更改了实体/数据库模式，则必须增加该值。默认为1。
        daoPackage 'com.anye.greendao.gen'//生成的Dao，DaoMaster和DaoSession的包名称。 默认为源实体的包名称。
        targetGenDir 'src/main/java'//生成源码存储的位置。 默认为构建目录（ build/generated/source/greendao）中生成的源文件夹。
        generateTest true //设置为true以自动生成单元测试。
        targetGenDirTests 'src/androidTest/java'//应存储生成的单元测试的基本目录。默认为src/androidTest/java。
    }

build.gradle(Module:app)具体位置如下：

//GreenDao
apply plugin: 'org.greenrobot.greendao'
android {
    compileSdkVersion 26
    defaultConfig {
        applicationId "com.example.administrator.greendao"
        minSdkVersion 15
        targetSdkVersion 26
        versionCode 1
        versionName "1.0"
        testInstrumentationRunner "android.support.test.runner.AndroidJUnitRunner"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
    //GreenDao
    greendao {
        schemaVersion 1
        daoPackage 'com.anye.greendao.gen'//注意根据自己的包名路径.gen
        targetGenDir 'src/main/java'
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.android.support:appcompat-v7:26.1.0'
    implementation 'com.android.support.constraint:constraint-layout:1.0.2'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test:runner:1.0.1'
    androidTestImplementation 
   'com.android.support.test.espresso:espresso-core:3.0.1'
    //GreenDao
    compile'org.greenrobot:greendao:3.2.2'
    compile'org.greenrobot:greendao-generator:3.2.2'
}

在项目的Android的build.gradle(Project:appName)文件中的dependencies标签下添加

classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2'

build.gradle(Project:appName)具体位置如下：

buildscript { 
    repositories { 
          jcenter()
}    
dependencies {
    classpath 'com.android.tools.build:gradle:2.3.3'
    //GreenDao
    classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2'    
    }
}

GreenDao使用

public class MyApplication extends Application {
 private DaoMaster.DevOpenHelper mHelper;
 private SQLiteDatabase db;
 private DaoMaster mDaoMaster;
 private DaoSession mDaoSession;
 public static MyApplication instances;
 @Override   
 public void onCreate() {
     super.onCreate();
     instances = this;
     setDatabase();
 }
 public static MyApplication getInstances(){
     return instances;
 }

/**
 * 设置greenDao
 */
private void setDatabase() {
    // 通过 DaoMaster 的内部类 DevOpenHelper，你可以得到一个便利的 SQLiteOpenHelper 对象。
    // 可能你已经注意到了，你并不需要去编写「CREATE TABLE」这样的 SQL 语句，因为 greenDAO 已经帮你做了。
    // 注意：默认的 DaoMaster.DevOpenHelper 会在数据库升级时，删除所有的表，意味着这将导致数据的丢失。
    // 所以，在正式的项目中，你还应该做一层封装，来实现数据库的安全升级。
    mHelper = new DaoMaster.DevOpenHelper(this, "notes-db", null);
    db = mHelper.getWritableDatabase();
    // 注意：该数据库连接属于 DaoMaster，所以多个 Session 指的是相同的数据库连接。 
    mDaoMaster = new DaoMaster(db); 
    mDaoSession = mDaoMaster.newSession();
}
public DaoSession getDaoSession() {
      return mDaoSession;
}
public SQLiteDatabase getDb() {
      return db;
  }
}

创建一个User的实体类

@Entity
public class User {
    @Id(autoincrement = true)
    private Long id; 
    @Transient 
    private int tempUsageCount; // not persisted  
}

注释说明

@Entity  
实体注解
@Id
主键 Long型，可以通过@Id(autoincrement = true)设置自增长。
通过这个注解标记的字段必须是Long，数据库中表示它就是主键，并且默认是自增的。
@transient 
就是在给某个javabean上需要添加个属性，但是这个属性你又不希望给存到数据库中去。
仅仅是做个临时变量，用一下。
不修改已经存在数据库的数据的数据结构。
那么这个注解就可以一用。
只要在你准备添加的临时属性上添加这个注解，然后getter和setter自动完成一下，就可以啦。

MakeProject

按压F9编译项目，User实体类会自动编译，生成get、set方法并且会在com.anye.greendao.gen目录下生成三个文件；

GreenDao自动生成目录.png

获取UserDao对象：

  mUserDao = MyApplication.getInstances().getDaoSession().getUserDao();

具体位置如下：

pravite UserDao mUserDao;
public class MainActivity extends Activity{
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
 mUserDao=MyApplication.getInstances().getDaoSession().getUserDao();
    }
}

简单的增删改查实现：

增
注意：Long型id，如果传入null，则GreenDao会默认设置自增长的值。

插入单条数据

 insert(User entity)：插入一条记录
 insertOrReplace(User entity):插入或替换一条记录

插入多条数据

insertInTx(userList)：插入多条记录
insertOrReplaceInTx(userList):插入多条记录或替换一条记录

增.png

2.删

deleteBykey(Long key) ：根据主键删除一条记录。
deleteInTx(userList)：删除多条记录 
delete(User entity) ：根据实体类删除一条记录，一般结合查询方法，查询出一条记录之后删除。
deleteAll()： 删除所有记录。

删.png

3.改

update(User entity)：更新一条记录
updateInTx(userList)：更新多条记录

改.png

loadAll()或queryBuilder().list()：查询所有记录
load(Long key)：根据主键查询一条记录
queryBuilder().list()：返回：List
queryBuilder().where(UserDao.Properties.Name.eq("")).list()：返回：List
queryRaw(String where,String selectionArg)：返回：List

单个条件

where() 
whereOr()

多个条件

where(,,) 
whereOr(,,)

降序

orderDesc()

升序

orderAsc()

当页限制个数

limit()

根据key查询

load(key)

更多的操作就不一一介绍了，大家可以根据需要去查找资料；

数据库升级

实现思路

1、创建临时表temporary，将原先表数据迁移过去
2、删除所有原表
3、创建新表
4、将temporary表数据复制到新表，最后将temporary表删除

创建一个类MigrationHelper：

public final class MigrationHelper {

    public static boolean DEBUG = false;
    private static String TAG = "MigrationHelper";
    private static final String SQLITE_MASTER = "sqlite_master";
    private static final String SQLITE_TEMP_MASTER = "sqlite_temp_master";

    public static void migrate(SQLiteDatabase db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
        Database database = new StandardDatabase(db);

        printLog("【The Old Database Version】" + db.getVersion());
        printLog("【Generate temp table】start");
        generateTempTables(database, daoClasses);
        printLog("【Generate temp table】complete");

        dropAllTables(database, true, daoClasses);
        createAllTables(database, false, daoClasses);

        printLog("【Restore data】start");
        restoreData(database, daoClasses);
        printLog("【Restore data】complete");
    }

    private static void generateTempTables(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
        for (int i = 0; i < daoClasses.length; i++) {
            String tempTableName = null;

            DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);
            String tableName = daoConfig.tablename;
            if (!isTableExists(db, false, tableName)) {
                printLog("【New Table】" + tableName);
                continue;
            }
            try {
                tempTableName = daoConfig.tablename.concat("_TEMP");
                StringBuilder dropTableStringBuilder = new StringBuilder();
                dropTableStringBuilder.append("DROP TABLE IF EXISTS ").append(tempTableName).append(";");
                db.execSQL(dropTableStringBuilder.toString());

                StringBuilder insertTableStringBuilder = new StringBuilder();
                insertTableStringBuilder.append("CREATE TEMPORARY TABLE ").append(tempTableName);
                insertTableStringBuilder.append(" AS SELECT * FROM ").append(tableName).append(";");
                db.execSQL(insertTableStringBuilder.toString());
                printLog("【Table】" + tableName +"\n ---Columns-->"+getColumnsStr(daoConfig));
                printLog("【Generate temp table】" + tempTableName);
            } catch (SQLException e) {
                Log.e(TAG, "【Failed to generate temp table】" + tempTableName, e);
            }
        }
    }

    private static boolean isTableExists(Database db, boolean isTemp, String tableName) {
        if (db == null || TextUtils.isEmpty(tableName)) {
            return false;
        }
        String dbName = isTemp ? SQLITE_TEMP_MASTER : SQLITE_MASTER;
        String sql = "SELECT COUNT(*) FROM " + dbName + " WHERE type = ? AND name = ?";
        Cursor cursor=null;
        int count = 0;
        try {
            cursor = db.rawQuery(sql, new String[]{"table", tableName});
            if (cursor == null || !cursor.moveToFirst()) {
                return false;
            }
            count = cursor.getInt(0);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (cursor != null)
                cursor.close();
        }
        return count > 0;
    }


    private static String getColumnsStr(DaoConfig daoConfig) {
        if (daoConfig == null) {
            return "no columns";
        }
        StringBuilder builder = new StringBuilder();
        for (int i = 0; i < daoConfig.allColumns.length; i++) {
            builder.append(daoConfig.allColumns[i]);
            builder.append(",");
        }
        if (builder.length() > 0) {
            builder.deleteCharAt(builder.length() - 1);
        }
        return builder.toString();
    }


    private static void dropAllTables(Database db, boolean ifExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) {
        reflectMethod(db, "dropTable", ifExists, daoClasses);
        printLog("【Drop all table】");
    }

    private static void createAllTables(Database db, boolean ifNotExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) {
        reflectMethod(db, "createTable", ifNotExists, daoClasses);
        printLog("【Create all table】");
    }

    /**
     * dao class already define the sql exec method, so just invoke it
     */
    private static void reflectMethod(Database db, String methodName, boolean isExists, @NonNull Class<? extends AbstractDao<?, ?>>... daoClasses) {
        if (daoClasses.length < 1) {
            return;
        }
        try {
            for (Class cls : daoClasses) {
                Method method = cls.getDeclaredMethod(methodName, Database.class, boolean.class);
                method.invoke(null, db, isExists);
            }
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    private static 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");

            if (!isTableExists(db, true, tempTableName)) {
                continue;
            }

            try {
                // get all columns from tempTable, take careful to use the columns list
                List<String> columns = getColumns(db, tempTableName);
                ArrayList<String> properties = new ArrayList<>(columns.size());
                for (int j = 0; j < daoConfig.properties.length; j++) {
                    String columnName = daoConfig.properties[j].columnName;
                    if (columns.contains(columnName)) {
                        properties.add(columnName);
                    }
                }
                if (properties.size() > 0) {
                    final String columnSQL = TextUtils.join(",", properties);

                    StringBuilder insertTableStringBuilder = new StringBuilder();
                    insertTableStringBuilder.append("INSERT INTO ").append(tableName).append(" (");
                    insertTableStringBuilder.append(columnSQL);
                    insertTableStringBuilder.append(") SELECT ");
                    insertTableStringBuilder.append(columnSQL);
                    insertTableStringBuilder.append(" FROM ").append(tempTableName).append(";");
                    db.execSQL(insertTableStringBuilder.toString());
                    printLog("【Restore data】 to " + tableName);
                }
                StringBuilder dropTableStringBuilder = new StringBuilder();
                dropTableStringBuilder.append("DROP TABLE ").append(tempTableName);
                db.execSQL(dropTableStringBuilder.toString());
                printLog("【Drop temp table】" + tempTableName);
            } catch (SQLException e) {
                Log.e(TAG, "【Failed to restore data from temp table 】" + tempTableName, e);
            }
        }
    }

    private static List<String> getColumns(Database db, String tableName) {
        List<String> columns = null;
        Cursor cursor = null;
        try {
            cursor = db.rawQuery("SELECT * FROM " + tableName + " limit 0", null);
            if (null != cursor && cursor.getColumnCount() > 0) {
                columns = Arrays.asList(cursor.getColumnNames());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            if (cursor != null)
                cursor.close();
            if (null == columns)
                columns = new ArrayList<>();
        }
        return columns;
    }

    private static void printLog(String info){
        if(DEBUG){
            Log.d(TAG, info);
        }
    }

}

自定义一个OpentHelper类继承于DaoMaster.OpenHelper类：

public class MySQLiteOpenHelper extends DaoMaster.OpenHelper {

    public MySQLiteOpenHelper(Context context, String name) {
        super(context, name);
    }

    public MySQLiteOpenHelper(Context context, String name,
                            SQLiteDatabase.CursorFactory factory) {
        super(context, name, factory);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        MigrationHelper.migrate(db,
                ProjectListDao.classUserListDao.class);//数据版本变更才会执行
    }

}

在DaoMaster类的onUpgrade方法添加如下代码即可，参数为所有的Dao类：

 @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        MigrationHelper.migrate(db,“所有的Dao类”);//数据版本变更才会执行
    }

这样数据库升级后以前的数据就不会丢失了，当然如果数据库升级后数据初始化，重新获取，不影响项目功能，可以不用考虑此方法。

GreenDao的代码混淆

-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.**

greendao打包混淆
版本greendao3.2.2
android GreenDao
Android框架之路——GreenDao3.2.2的使用 - CSDN博客 GreenDAO 完美解决数据库升级...
GreenDao3.2.2
官网： http://greenrobot.org/greendao API文档：http://greenrobo...
GreenDao的初步探索
GreenDao的初步探索开发环境：AS3.1.4，GreenDao3.2.2 1，配置项目的build.gr...
GreenDao3.2.2集成和基本使用
GreenDao3.2.2集成和基本使用官方git网址：greenrobot/greenDAO 优点：一个精简的...
GreenDao3.2.2使用
一.前言官方文档是这样解释的：greenDAO是一款开放源代码的Android ORM，使SQLite数据库的开...
GreenDao3.2.2配置
GreenDao配置GreenDao不同版本配置方法可以有所不同，我测试配置org.greenrobot:gree...
greenDAO3.2.2简单教程
一、关于greenDAO greenDAO应该算是当前最火的数据库开源框架了，它是一个将对象映射到SQLite数据...
GreenDao3.2.2简单使用
一:将GreenDao引入项目中需要在两个地方添加配置：1:在Project–>budld.gradle中配置如...
GreenDao3.2.2使用详解
由于项目优化，将项目使用的数据库GreenDao从2.0升级到3.0，两者在配置及使用上均有很大的不同，关于Gre...

GreenDao3.2.2

GreenDao 简介

GreenDao 优势

GreenDao 的项目配置

GreenDao使用

数据库升级

GreenDao的代码混淆

相关文章

greendao打包混淆

android GreenDao

GreenDao3.2.2

GreenDao的初步探索

GreenDao3.2.2集成和基本使用

GreenDao3.2.2使用

GreenDao3.2.2配置

greenDAO3.2.2简单教程

GreenDao3.2.2简单使用

GreenDao3.2.2使用详解

网友评论

延伸阅读

深度阅读

栏目导航

热点阅读