GreenDao3.2.2使用

最新推荐文章于 2024-04-05 08:25:53 发布
最新推荐文章于 2024-04-05 08:25:53 发布
阅读量506 收藏
点赞数
分类专栏： android
本文详细介绍GreenDao的基本使用方法，包括配置、创建实体类、数据库管理、增删改查操作等，帮助初学者快速掌握这款轻量级ORM框架。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

许久不用有些遗忘，看到了这篇文章写的非常详细，适合刚接触GreenDao的童鞋上手。

这篇是简单的用法。



一.前言 
官方文档是这样解释的： 
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'//数据库升级辅助
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

设置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
    }
  • 1
  • 2
  • 3
  • 4
  • 5

混淆

### 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
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10

四.实现 
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
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

编写完变量之后，编译项目，（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;
 }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

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;
 }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

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);
     //----------------------------
 }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30

这里建议使用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();
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144
  • 145
  • 146
  • 147
  • 148
  • 149
  • 150
  • 151
  • 152
  • 153
  • 154
  • 155
  • 156
  • 157
  • 158
  • 159
  • 160

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();
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31

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



转载自：http://blog.youkuaiyun.com/feibendexiaoma/article/details/73912660

【greenDAO3】 项目搭建与增删改查操作
njweiyukun的博客
07-13 4万+
最近需要开始一个新的项目了，考虑到既然是新项目了，那么一些常用的框架肯定也要用当下最火的！这次的新项目中涉及到了本地数据存储，很早前有个项目的本地数据库框架用的是ActiveAndroid，github找了下这个框架，发现已经两年多已经没有更新了。然后就想到了一直没有时间去涉及到的greenDAO，github一搜索，哦呦？star有5000+，并且依然保持着很高的更新频率，并且性能远远的高于ac
Android框架之路——GreenDao3.2.2的使用
热门推荐
等一杯咖啡的博客
05-06 3万+
一、简介 GreenDAO是一个开源的安卓ORM框架，能够使SQLite数据库的开发再次变得有趣。它减轻开发人员处理低级数据库需求，同时节省开发时间。 SQLite是一个令人敬畏的内嵌的关系数据库，编写SQL和解析查询结果是相当乏味和耗时的任务。通过将Java对象映射到数据库表（称为ORM，“对象/关系映射”），GreenDAO可以将它们从这些映射中释放出来，这样，您可以使用简单的面向对象的AP
GreenDao 3
最新发布
2401_84123557的博客
04-05 929
分享一份NDK基础开发资料分享内容包括不限于高级UI、性能优化、架构师课程、NDK、混合式开发（ReactNative+Weex）微信小程序、Flutter等全方面的Android进阶实践技术；希望能帮助到大家，也节省大家在网上搜索资料的时间来学习，也可以分享动态给身边好友一起学习！《Android学习笔记总结+移动架构视频+大厂面试真题+项目实战源码》，点击传送门即可获取！板技术停滞不前！**
greenDao3.2
10-13
greenDao3.2 使用及配置，项目demo
Greendao3.2使用
ddmt6831的博客
02-04 1171
一、配置，添加红色部分 apply plugin: 'com.android.application' apply plugin: 'org.greenrobot.greendao' android { compileSdkVersion 22 buildToolsVersion "25.0.2" defaultConfig { applica
GreenDao3.2.2使用demo
06-29
在"GreenDao3.2.2使用demo"中，我们可以学习到以下几个关键知识点： 1. **安装与集成**：首先，你需要在项目中添加GreenDao的依赖库。在Gradle构建系统中，可以通过在app模块的build.gradle文件中添加对应的依赖项...
GreenDao3.2.2使用教程及Demo源码免费下载
以下是对GreenDao3.2.2使用Demo源码下载相关的知识点进行详细说明： 1. GreenDao框架简介： - ORM框架：GreenDao框架遵循对象关系映射的原则，将对象的属性与数据库中的表行对应起来，从而简化数据库操作。 - 轻...
GreenDao3.2.2的使用Demo源码下载
05-06
GreenDao 3.2.2是该库的一个版本，提供了许多优化和改进，使得开发者能够更加高效、便捷地在Android应用中使用SQLite数据库。 首先，GreenDao的安装与集成通常是通过Gradle来完成的。在项目的build.gradle文件中...
GreenDao3.2.2使用演示与源码分享
GreenDao3.2.2是一款开源、轻量级的Android ORM（对象关系映射）解决方案，它用于将Java对象映射到SQLite数据库中，从而使得数据库的存取操作更加直观和便捷。GreenDao通过注解或XML文件来配置模型对象和数据库结构...
GreenDao3.2.2的使用Demo源码
07-13
在GreenDao 3.2.2的使用Demo中，我们通常会经历以下步骤： 1. **引入依赖**：在项目中添加GreenDao的依赖库，通常是在build.gradle文件中配置。 2. **创建实体类**：定义数据模型，每个实体类对应数据库中的一个表...
GreenDao+greendao-gradle-plugin
11-02
GreenDao以及GreenDao-gradle的jar包，使用GreenDao数据库
GreenDao3.2的使用
dlshtian的博客
02-14 274
看了greenDao这篇简单使用文章觉得不错 转载http://www.open-open.com/lib/view/open1484706351512.html#
GreenDao混淆配置
一品大帅的专栏
04-27 6775
-keep class org.greenrobot.greendao.**{*;} -keep public interface org.greenrobot.greendao.** -keepclassmembers class * extends org.greenrobot.greendao.AbstractDao { public static java.lang.String TABL
GreenDao3学习
skyang在路上
10-10 229
可以看看这个详细博客GreenDao3使用教程 这里借用一下ppjun的GreenDao demo来学习 androidManifest.xml添加读写权限 &amp;amp;lt;uses-permission android:name=&amp;quot;android.permission.READ_EXTERNAL_STORAGE&amp;quot;/&amp;amp;gt; &amp;amp;lt;uses-permission android:
GreenDao3.2.2的使用
riqthen的博客
05-30 921
一、在app的build.gradle中配置 greendao { schemaVersion 1 daoPackage 'com.at3.bitcontinent.dao' //生成的文件存放的文件夹 targetGenDir 'src/main/java' } //greenDao ---&amp;amp;amp;amp;amp;amp;amp;gt; https://github.com/greenrobot...
GreenDAO 3介绍与应用
开发笔记
11-15 4310
前言 当我看到需要在android工程下新建一个module-->java library的generator library的时候，便去翻阅了一下官方文档，此时发现出现了GreenDao 3，可以不用新建额外的module，而是在android工程中添加一个Gradle plugin，官方解释道：事实上，这个Gradle plugin内部也是使用原来的generator library. G
GreenDAO3.2初探
郭霖
05-27 481
今天是假期前的最后一篇文章，介绍GreanDAO的使用方式\b。
GreenDao 3，看完不会的来打我
m0_65145426的博客
12-15 1127
@Property 设置一个非默认关系映射所对应的列名，默认是使用字段名,例如： @Entity (nameInDb = “User”) public class User { @Property(nameInDb = “userName”) private String userName; } @NotNull 设置数据库表当前列不能为空 @Transient 添加此标记后不会生成数据库表的列 @Unique 表名该属性在数据库中只能有唯一值 @Entity public .
Android实战——GreenDao3.2的使用，爱不释手
点击置顶文章查看博客目录（全站式导航）
01-13 2万+
GreenDao3.2的使用，爱不释手 本篇文章包括以下内容： 前言 GreenDao3.2的简介 GreenDao3.2的配置 GreenDao3.2的使用 结语 前言GreenDao是一款操作数据库的神器，经过了2.0版本的升级后，已经被广泛的开发者使用。确实是很好用，入门简单，可以剩去了数据库的建表操作和数据库SQL的编写，博主用了一次之后爱不释手，和
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值