GreenDao3.2.2

官网： http://greenrobot.org/greendao

API文档：http://greenrobot.org/greendao/documentation

更新日志：http://greenrobot.org/greendao/changelog

GitHub源码地址：https://github.com/greenrobot/greendao

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

简单的增删改查实现：

1. 增
   注意：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

4. 查

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