GreenDao3.2.2使用

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/feibendexiaoma/article/details/73912660

转载请注明出处：http://blog.csdn.net/feibendexiaoma/article/details/73912660
一.前言
官方文档是这样解释的：
greenDAO是一款开放源代码的Android ORM，使SQLite数据库的开发变得有趣。 它减轻开发人员处理低级数据库需求，同时节省开发时间。 SQLite是一个令人敬畏的嵌入式关系数据库。 不过，编写SQL和解析查询结果是相当乏味和耗时的任务。 通过将Java对象映射到数据库表（称为ORM“对象/关系映射”），greenDAO可以将它们从这些映射释放出来。 这样，您可以使用简单的面向对象的API来存储，更新，删除和查询Java对象。
简单来说 GreenDAO 是一个将对象映射到 SQLite 数据库中的轻量且快速的 ORM解决方案。

二.优点
超简单：简洁直观的API
小：库<150K，它只是纯Java jar（没有CPU依赖的本机部分）
快速：可能是由智能代码生成驱动的Android中最快的ORM
安全和表达式的查询API：QueryBuilder使用属性常量来避免打字错误
强大的连接：跨实体查询，甚至链接复杂关系
灵活的属性类型：使用自定义类或枚举来表示实体中的数据
加密：支持SQLCipher加密数据库
代码自动生成
开源
支持缓存

GreenDao与其他数据库的速度对比：

三.配置

// In your root build.gradle file:
buildscript {
    repositories {
        jcenter()
        mavenCentral() // add repository 
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.3.1'
        classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2' // add plugin
    }

}
 allprojects {
    repositories {
        jcenter()
        //使用数据库升级辅助GreenDaoUpgradeHelper时添加
        maven { url "https://jitpack.io" }
    }
}

// In your app projects build.gradle file:
apply plugin: 'com.android.application'
apply plugin: 'org.greenrobot.greendao' // apply plugin

dependencies {
    compile 'org.greenrobot:greendao:3.2.2' // add library
    compile 'com.github.yuweiguocn:GreenDaoUpgradeHelper:v1.4.0'//数据库升级辅助
}

设置schema
在app的build.gradle 的android路径下配置

greendao {
        schemaVersion 1//<--数据库的版本，用于升级时候进行更改
        daoPackage 'com.fsp.greendao.gen'//这个是生成DAOs、DaoMaster、DaoSession代码保存的包名,默认为entities所在包名
        targetGenDir 'src/main/java'//生成DAOs、DaoMaster、DaoSession的目录。默认为build/generated/source/greendao
    }

混淆

### greenDAO 3
-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.**

四.实现
1.创建bean类

@Entity
public class UserInfo {
 @Id(autoincrement =true)
 private Long id;
 private String name;
 private int age;
 private int sex;
 //以下内容是自动产生的
 @Generated(hash = 1968140991)
 public UserInfo(Long id, String name, int age, int sex) {
     this.id = id;
     this.name = name;
     this.age = age;
     this.sex = sex;
 }
 @Generated(hash = 1279772520)
 public UserInfo() {
 }
 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 int getAge() {
     return this.age;
 }
 public void setAge(int age) {
     this.age = age;
 }
 public int getSex() {
     return this.sex;
 }
 public void setSex(int sex) {
     this.sex = sex;
 }
}

编写完变量之后，编译项目，（1）会自动构造方法，get,set方法。（2）会生成 DaoMaster、DaoSession、DAOS类，类的位置位于你在app的build.gradle的schema配置
@Entity：告诉GreenDao该对象为实体，只有被@Entity注释的Bean类才能被dao类操作
@Id：对象的Id，使用Long类型作为EntityId，否则会报错。(autoincrement = true)表示主键会自增，如果false就会使用旧值
@Property：可以自定义字段名，注意外键不能使用该属性
@NotNull：属性不能为空
@Unique：该属性值必须在数据库中是唯一值
@Generated：greenDao生产代码注解，手动修改报错

2.数据库的创建
在MyApplication的onCreate()方法中初始化

public class MyApplication extends Application {
 private static Context context;
 @Override
 public void onCreate() {
     super.onCreate();
     context = getApplicationContext();
     //初始化greendao
     GreenDaoManager.getInstance();
 }
 public static Context getContext(){
     return context;
 }
}

GreenDaoManager中创建数据库,并对其进行管理

public class GreenDaoManager {
 private static final String DB_NAME="greendao";
 private static GreenDaoManager mInstance;
 private DaoMaster daoMaster;
 private DaoSession daoSession;
public static GreenDaoManager getInstance(){
     if(mInstance==null){
         synchronized (GreenDaoManager.class){
             if(mInstance==null){
                 mInstance =new GreenDaoManager();
             }
         }
     }
     return mInstance;
 }
 private GreenDaoManager(){
     if(mInstance==null){
         MySQLiteOpenHelper helper =new MySQLiteOpenHelper(MyApplication.getContext(),DB_NAME,null);
         Database db = helper.getWritableDb();
         daoMaster = new DaoMaster(db);
         daoSession = daoMaster.newSession();
     }
 }
 public DaoSession getDaoSession(){
     return daoSession;
 }
 public DaoMaster getDaoMaster(){
     return daoMaster;
 }
}

MySQLiteOpenHelper类继承DaoMaster.OpenHelper，并重载onUpgrade方法，里面处理数据库升级的逻辑

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

 @Override
 public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
     super.onUpgrade(db, oldVersion, newVersion);
     //----------------------------使用sql实现升级逻辑
     if (oldVersion == newVersion) {
         Log.e("onUpgrade", "数据库是最新版本,无需升级" );
         return;
     }
     Log.e("onUpgrade", "数据库从版本" + oldVersion + "升级到版本" + newVersion);
     switch (oldVersion) {
         case 1:
             String sql = "";
             db.execSQL(sql);
         case 2:
         default:
             break;
     }
     //-----------------------------------
     //--------------------------或者使用GreenDaoUpgradeHelper辅助库实现逻辑
//        MigrationHelper.migrate(db,UserDao.class);
     //----------------------------
 }

这里建议使用DaoMaster.OpenHelper ,不要使用DaoMaster.DevOpenHelper,因为使用DaoMaster.DevOpenHelper每次升级数据库都会把表删除重建，推荐开发时用。正式使用时还是用DaoMaster.OpenHelper。
通过 MigrationHelper 在删表重建的过程中，使用临时表保存数据并还原。

DaoMaster.OpenHelper ：创建SQLite数据库的SQLiteOpenHelper的具体实现
DaoMaster ： GreenDao的顶级对象，用于创建和删除表
DaoSession ： 管理所有的Dao对象，Dao对象可以通过 daoSession.getUserInfoDao()获得
3.增删改查
创建一个Dao类，把增删改查的方法封装起来，提高代码的可复用性，简洁性

public class UserDao {

    private final GreenDaoManager daoManager;
    private static UserDao mUserDao;
    public UserDao(){
        daoManager = GreenDaoManager.getInstance();
    }

   public static UserDao getInstance(){
       if(mUserDao==null){
           mUserDao =new UserDao();
       }
       return mUserDao;
   }
    /**
     * 插入数据 若未建表则先建表
     * @param userInfo
     * @return
     */
    public  boolean insertUserData(UserInfo userInfo){
        boolean flag =false;
        flag =getUserInfoDao().insert(userInfo) ==-1?false :true;
        return flag;
    }

    /**
     * 插入或替换数据
     * @param userInfo
     * @return
     */
    public boolean insertOrReplaceData(UserInfo userInfo){
        boolean flag =false;
        try{
            flag = getUserInfoDao().insertOrReplace(userInfo)==-1?false:true;
        }catch (Exception e){
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 插入多条数据  子线程完成
     * @param list
     * @return
     */
    public boolean insertOrReplaceMultiData(final List<UserInfo> list){
        boolean flag =false;
        try{
            getUserInfoDao().getSession().runInTx(new Runnable() {
                @Override
                public void run() {
                    for(UserInfo userInfo:list){
                        daoManager.getDaoSession().insertOrReplace(userInfo);
                    }
                }
            });
            flag =true;
        }catch (Exception e){
            e.printStackTrace();
        }
        return  flag;
    }

    /**
     * 更新数据
     * @param userInfo
     * @return
     */
    public boolean updateUserData(UserInfo userInfo){
        boolean flag =false;
        try{
            getUserInfoDao().update(userInfo);
            flag =true;
        }catch (Exception e){
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 根据id删除数据
     * @param userInfo
     * @return
     */
    public boolean deleteUserData(UserInfo userInfo){
        boolean flag =false;
        try{
            getUserInfoDao().delete(userInfo);
            flag =true;
        }catch (Exception e){
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 删除所有数据
     * @return
     */
    public boolean deleteAllData(){
        boolean flag =false;
        try{
            getUserInfoDao().deleteAll();
            flag =true;
        }catch (Exception e){
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 根据主键查询
     * @param key
     * @return
     */
    public UserInfo queryUserDataById(long key){
        return getUserInfoDao().load(key);
    }

    /**
     * 查询所有数据
     * @return
     */
    public List<UserInfo> queryAllData(){
        return getUserInfoDao().loadAll();
    }

    /**
     * 根据名称查询 以年龄降序排列
     * @param name
     * @return
     */
    public List<UserInfo> queryUserByName(String name){
        Query<UserInfo> build = null;
        try{
            build =getUserInfoDao().queryBuilder()
                    .where(UserInfoDao.Properties.Name.eq(name))
                    .orderDesc(UserInfoDao.Properties.Age)
                    .build();
        }catch (Exception e){
            e.printStackTrace();
        }

        return build.list();
    }

    /**
     * 根据参数查询
     * @param where
     * @param param
     * @return
     */
    public List<UserInfo> queryUserByParams(String where,String... param){
        return getUserInfoDao().queryRaw(where,param);
    }

    public UserInfoDao getUserInfoDao(){
        return daoManager.getDaoSession().getUserInfoDao();
    }
}

4.调用
在需要用到的地方调用方法，我这里是建了一个RecyclerView,更直观的显示数据的操作。你可以根据需要在适当的地方调用增删改查方法就行。

private void updateData() {
        if (!lists.isEmpty()) {
            UserInfo userInfo = lists.get(0);
            userInfo.setName("李四");
            UserDao.getInstance().updateUserData(userInfo);
            queryListData();
        }
    }

    private void deleteData() {
        if (!lists.isEmpty()) {
            UserDao.getInstance().deleteUserData(lists.get(0));
            queryListData();
        }

    }

    private void addData() {
        UserInfo userInfo = new UserInfo();
        userInfo.setName("张三");
        userInfo.setAge(18);
        userInfo.setSex(1);
        UserDao.getInstance().insertUserData(userInfo);
        queryListData();
    }

    private void queryListData() {
        lists = UserDao.getInstance().queryAllData();
        adapter.setData(lists);
        Toast.makeText(this, "查询到" + lists.size() + "条数据", Toast.LENGTH_SHORT).show();
    }

5.其他方法
添加
单条数据
getUserInfoDao().insert(userInfo)
getUserInfoDao().insertOrReplace(userInfo);

多条数据
getUserInfoDao().insertInTx(userInfoList);
getUserInfoDao().insertOrReplaceInTx(userInfoList);

查询
单个条件
where()
whereOr()

多个条件
where(,,)
whereOr(,,)

降序 orderDesc()
升序 orderAsc()
当页限制个数 limit()
根据key查询 .load(key)
全部 .loadAll() 或者.queryBuilder().list()

修改
单条 .update(userInfo)
多条 .updateInTx(userInfoList)

删除
单条 .delete(userInfo)
多条 .deleteInTx(userInfoList)
全部 .deleteAll()

6.演示

7.demo下载
http://download.csdn.net/detail/feibendexiaoma/9884019

总结

这里只介绍了GreenDao的基础使用方法，比较高深的知识点如加密，多表关联等需继续深究，一步一步慢慢积累。