GreenDao 3.0 的使用

1. 背景

我们在Android开发的时候，经常会牵涉到数据的保存，相比SharedPreferences，数据库可以让我们保存种类更多的数据，而且很多时候我们需要增删改查大量数据，这个时候数据库的优势就体现出来了。在与数据库打交道时，我们当然可以使用SQLiteDatabase和SQLiteOpenHelper进行数据库的操作，但是我们要记住大量的sql语句，显然是不方便的。目前封装比较好的数据库操作框架有Ormlite和GreenDao，而GreenDao使用起来配合注解，显然更加符合现在开发，也较Ormlite方便，下面我们就开启GreenDao之旅。

2. GreenDao 3.0 的配置

2.1 在project的build.gradle中添加classpath

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

allprojects {
    repositories {
        jcenter()
        mavenCentral()
    }
}

2.2 在module的build.gradle应用插件和依赖

apply plugin: 'org.greenrobot.greendao'

compile 'org.greenrobot:greendao:3.2.0'

应用插件

添加依赖

在make project/make module时，插件会扫描项目中所有的@Entity文件（greenDAO中数据库的实体类添加的注解），根据实体类生成DaoSession、DaoMaster以及所有实体类的dao类，生成的文件默认目录为：build/generated/source/greendao，如果你想自定义这个路径，可以在module的build.gradle添加如下配置：

        greendao {
            schemaVersion 1
            daoPackage 'com.zhang.greendaotest.greendao.gen'
            targetGenDir 'src/main/java'
        }

schemaVersion：指定数据库版本号
daoPackage：通过gradle插件生成的数据库相关文件的包名，默认为entity所在的包名
targetGenDir：自定义生成数据库文件的目录了，可以将生成的文件放到我们的Java目录中，而不是build中，这样就不用额外的设置资源目录了

3. GreenDao 3.0 开发之路

在实体类上添加注解@Entity，GreenDao的插件会找到它生成代码

@Entity
public class User {
    //注意：这里的id类型是Long/long
    @Id(autoincrement = true)
    private Long id;
    @Property(nameInDb = "user_name")
    private String name;
    @Property(nameInDb = "tel_phone")
    private String phone;
    private int age;
    @Transient
    private String address;
}

@Entity 实体类，GreenDao会映射成sqlite中的一个表
@Id 主键
@Property 属性在表中对应的列名称
@Transient 属性将不会映射到表中
更多注解：http://greenrobot.org/files/greendao-api/javadoc/current/
写好实体类，make project/make module后，会发现在“daoPackage”指定的目录下生成了如下代码文件：

这是自己写的实体类也会生成有参构造，set/get方法
下面就是数据库的最常见的增删改查，这里简单封装下工具类，实际开发时，可以利用Dagger2注入全局的DaoSession实例。

public class GreenDaoManager {
    private DaoMaster mDaoMaster;
    private DaoSession mDaoSession;


    private GreenDaoManager() {
        /**
         * 初始化GreenDao
         */
        DaoMaster.DevOpenHelper devOpenHelper =  new DaoMaster.DevOpenHelper(MyApp.getAppContext(), "user.db", null);
        mDaoMaster = new DaoMaster(devOpenHelper.getWritableDatabase());
        mDaoSession = mDaoMaster.newSession();
    }

    private static class SingleInstance {
        private static final GreenDaoManager INSTANCE = new GreenDaoManager();
    }


    public static GreenDaoManager getInstance() {
        return SingleInstance.INSTANCE;
    }

    /**
     * 得到DaoMaster实例
     * @return
     */
    public DaoMaster getmDaoMaster() {
        return mDaoMaster;
    }

    /**
     * 得到DaoSession实例
     * @return
     */
    public DaoSession getmDaoSession() {
        return mDaoSession;
    }

}

在MyApp中初始化：

    sDaoSession = GreenDaoManager.getInstance().getmDaoSession();

准备工作已经完成，下面就是增删改查了
在使用时可以先得到UserDao实例，方便操作，例在MainActivity中

mUserDao = MyApp.sDaoSession.getUserDao();

3.1 数据逐一添加：

      //数据逐一添加
      User user1 = new User(null, "greendao_1", "110", 20);
      mUserDao.insert(user1);
      User user2 = new User(null, "greendao_2", "111", 21);
      mUserDao.insert(user2);

3.2 查询数据
可以看出这里的代码风格是主流的响应式编程

       List userList = mUserDao.queryBuilder()
              //限定查询的条件
              .where(UserDao.Properties.Id.notEq(10))
              //设置按照排序方式
              .orderAsc(UserDao.Properties.Id)
              //限制查询个数
              .limit(10)
              .build().list();  

3.3 更新数据：先查后再改

         User oldUser = mUserDao.queryBuilder()
                 .where(UserDao.Properties.Name.eq("greendao_1")).build().unique();
         if (oldUser != null) {
             oldUser.setName("greendao_0");
             mUserDao.update(oldUser);
             Log.d(TAG, "update: 修改成功");
         } else {
             Log.d(TAG, "update: 修改失败");
         }

3.5 删除数据：按照条件删除

         User findUser = mUserDao.queryBuilder().where(UserDao.Properties.Name.eq("greendao_2")).build().unique();
         if (findUser != null) {
             mUserDao.deleteByKey(findUser.getId());
         }

3.6 GreenDao依然支持sql语句：
这里可以看出我们当初的表名和字段名

        String sql = "delete from user where user_name='greendao_1'";
        GreenDaoManager.getInstance().getmDaoSession().getDatabase().execSQL(sql);

3.7 批量添加数据

        users = Arrays.asList(new User(null, "greendao_100", "120", 20),
                new User(null, "greendao_101", "121", 21),
                new User(null, "greendao_102", "122", 22),
                new User(null, "greendao_103", "123", 23),
                new User(null, "greendao_104", "124", 24),
                new User(null, "greendao_105", "125", 25),
                new User(null, "greendao_106", "126", 26)
        );
        mUserDao.getSession().runInTx(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < users.size(); i++) {
                    User user = users.get(i);
                    mUserDao.insertOrReplace(user);
                }
            }
        });

3.8 删除全部数据

        mUserDao.deleteAll();

以上就是GreenDao的基本使用

4. GreenDao使用外部数据库文件

知晓了GreenDao 3.0 的基本使用，下面我们看下使用GreenDao 3.0 进行对外部数据库的操作。我们知道要使用外部数据库，例如city.db，需要把db文件放在AS的 res - >raw 目录下，如图

下面我们按照外部city.db文件中的字段编写javabean（注意这里类会映射成表名，所以我们需要打开db文件，查看表名）

@Entity
public class Tbl_province {
    @Id(autoincrement = true)
    private Long id;
    @Property(nameInDb = "codeid")
    private String code;
    @Property(nameInDb = "parentid")
    private String parent;
    @Property(nameInDb = "cityName")
    private String city;
 }

然后Make Module 一下，GreenDao会生成代码
下面我们查询一下

         List cityList = mTbl_provinceDao.queryBuilder()
                 //条件
                 .where(Tbl_provinceDao.Properties.Id.notEq(100))
                 //排序
                 .orderAsc(Tbl_provinceDao.Properties.Id)
                 //限制查询个数
                 .limit(100)
                 .build().list();
         mTv.setText(cityList.toString());

这是发现，查询不到结果。这是因为GreenDao在初始化的时候，默认是创建新表的。
具体看下GreenDao初始化过程

 DaoMaster.DevOpenHelper devOpenHelper =  new DaoMaster.DevOpenHelper(MyApp.getAppContext(), "city.db", null);

看下这个DevOpenHelper帮助类，是 extends OpenHelper的，而这个OpenHelper如下

    public static abstract class OpenHelper extends DatabaseOpenHelper {
        public OpenHelper(Context context, String name) {
            super(context, name, SCHEMA_VERSION);
        }

        public OpenHelper(Context context, String name, CursorFactory factory) {
            super(context, name, factory, SCHEMA_VERSION);
        }

        @Override
        public void onCreate(Database db) {
            Log.i("greenDAO", "Creating tables for schema version " + SCHEMA_VERSION);
            createAllTables(db, false);
        }
    }

也就是在创建的时候会走下面这句代码，传入的是false

createAllTables(db, false);

看下具体实现，这里的ifNotExists值时false

    public static void createAllTables(Database db, boolean ifNotExists) {
        Tbl_provinceDao.createTable(db, ifNotExists);
        UserDao.createTable(db, ifNotExists);
    }

再往下看

    public static void createTable(Database db, boolean ifNotExists) {
        String constraint = ifNotExists? "IF NOT EXISTS ": "";
        db.execSQL("CREATE TABLE " + constraint + "\"TBL_PROVINCE\" (" + //
                "\"_id\" INTEGER PRIMARY KEY AUTOINCREMENT ," + // 0: id
                "\"codeid\" TEXT," + // 1: code
                "\"parentid\" TEXT," + // 2: parent
                "\"cityName\" TEXT);"); // 3: city
    }

看到这里，大家就明白了，由于ifNotExists默认传入的是false，在这里就会创建新的表，同时在这里我们还可以看到具体表的字段，那么我们要使用外部的db数据库的话。那么我们要使用外部的数据库的时候，就不能用这个创建的新表，而是需要将外部数据库复制到应用包中，具体步骤如下：
①复制外部DB数据库：res -> raw 到 data ->data … ->databases目录下

   public static String sDBPath;   //数据库存入手机的路径
    public void writeDB() {
        FileOutputStream fout = null;
        InputStream inputStream = null;
        sDBPath = getFilesDir() + "\\databases\\" + "city.db";
        try {
            inputStream = getResources().openRawResource(city);
            fout = new FileOutputStream(new File(sDBPath));
            byte[] buffer = new byte[128];
            int len = 0;
            while ((len = inputStream.read(buffer)) != -1) {
                fout.write(buffer, 0, len);
            }
            buffer = null;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if (fout != null) {
                try {
                    fout.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }

注意 设置要复制的目录要写在GreenDao初始化前面，因为初始化的时候要用到这个路径，这里我把整个方法都写在了GreenDao初始化前面

       sDBPath = getFilesDir() + "\\databases\\" + "city.db";

② 将复制的数据库赋给DaoMaster，在GreenDaoManager中再设置个mNewDaoMaster和mNewDaoSession，具体如下：

        SQLiteDatabase database = SQLiteDatabase.openOrCreateDatabase(MyApp.sDBPath, null);
        mNewDaoMaster = new DaoMaster(database);
        mNewDaoSession = mNewDaoMaster.newSession();

这个可以看到，我们没有使用DevOpenHelper去得到SQLiteDatabase实例，而是通过SQLiteDatabase.openOrCreateDatabase()方法拿到复制的DB数据库实例，然后复制给mNewDaoMaster
另外提供得到mNewDaoSession的get方法

    public DaoSession getmNewDaoSession() {
        return mNewDaoSession;
    }

③ 在MyApp中初始化，得到全局的sNewDaoSession

 sNewDaoSession = GreenDaoManager.getInstance().getmNewDaoSession();

④ 在MainActivity中使用

mTbl_provinceDao = MyApp.sNewDaoSession.getTbl_provinceDao();

对数据库的操作和之前的一样

         List cityList = mTbl_provinceDao.queryBuilder()
                 //条件
                 .where(Tbl_provinceDao.Properties.Id.notEq(100))
                 //排序
                 .orderAsc(Tbl_provinceDao.Properties.Id)
                 //限制查询个数
                 .limit(100)
                 .build().list();
         mTv.setText(cityList.toString());

5. 数据库更新表

使用GreenDao进行数据库更新表，例如在User中增加一个字段pwd

@Entity
public class User {
    @Id(autoincrement = true)
    private Long id;
    @Property(nameInDb = "user_name")
    private String name;
    @Property(nameInDb = "tel_phone")
    private String phone;
    private int age;
    //注意添加的字段须是String，其他类型可能报错
    private String pwd;
    @Transient
    private String address;
}

make module之后，GreenDao为User生成代码之后，在User中添加之前的有参构造，防止之前的代码报错

    public User(Long id, String name, String phone, int age) {
        this.id = id;
        this.name = name;
        this.phone = phone;
        this.age = age;
    }

下面就是数据库表更新的操作，网上有一个很好用的类帮助我们进行数据库更新操作：MigrationHelper，实现的逻辑就是：创建临时表–>删除原表–>创建新表–>复制临时表数据到新表并删除临时表；这样数据库表的更新就完成了，下面看下具体代码：

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, Classextends 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, Classextends 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 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, Classextends 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 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 getColumns(Database db, String tableName) {
        List 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;
    }
}

数据库更新表的方法是DaoMaster.OpenHelper类中的onUpgrade方法，而DaoMaster是插件生成的，我们即使改了，编译一下还会还原的，我们这里采用的方法是写一个类MyOpenHelper继承DaoMaster.OpenHelper，重写onUpgrade方法，使用时也使用我们写的MyOpenHelper。

public class MyOpenHelper extends DaoMaster.OpenHelper {

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

    /**
     * 数据库升级
     * @param db
     * @param oldVersion
     * @param newVersion
     */
    @Override
    public void onUpgrade(Database db, int oldVersion, int newVersion) {
        MigrationHelper.getInstance().migrate(db,UserDao.class);
    }

}

这样就完成了数据库表的更新，现在我们要做的就是使用我们的MyOpenHelper代替DaoMaster.OpenHelper，我们还是在GreenDaoManager中进行操作：

    /**
     * 得到DaoMaster实例
     * @return
     */
    public DaoMaster getmDaoMaster(Context context) {
        MyOpenHelper helper = new MyOpenHelper(context,DB_NAME,null);
        mDaoMaster = new DaoMaster(helper.getWritableDatabase());
        return mDaoMaster;
    }

在MyApp中得到可以更新数据库表的DaoMaster：

 sDaoSession = GreenDaoManager.getInstance().getmDaoMaster(sContext).newSession();

我们在MainActivity中拿到UserDao就可以对新的表进行操作了，和之前的一样，这里就不在赘述了。
最后，在app的build.gradle中更新版本号

       greendao {
           schemaVersion 2
           daoPackage 'com.zhang.greendaotest.greendao.gen'
           targetGenDir 'src/main/java'
       }

这样就完成了数据库表的更新。

6. GreenDao的代码混淆配置

混淆打包时，我们需要在proguard-rules.pro文件下添加：

-keepclassmembersclass*extendsde.greenrobot.dao.AbstractDao {

publicstaticjava.lang.String TABLENAME;

}

-keepclass**$Properties
以上就是我对GreenDao 3.0 的使用
奉上demo地址：https://github.com/Mr-zhang0101/GreenDaoTest