数据持久化框架greendao

Android中轻松使用greenDao实现数据持久化

千次阅读 2017-06-25 23:15:11

在使用原始方法来操作SQLite数据库实现数据本地持久化时，往往要编写大量的sql语句来实现数据库的各种操作，这对程序员的技术要求较高，同时在一定程度上影响开发效率，那么我们可以使用目前市面上比较流行的第三方...

文章背景 
 程序猿或是程序媛们在开发Android项目的时候，在使用原始方法来操作SQLite数据库实现数据本地持久化时，往往要编写大量的sql语句来实现数据库的各种操作，这对程序员的技术要求较高，同时在一定程度上影响开发效率，那么我们可以使用目前市面上比较流行的第三方数据库操作库greenDao。但本人还是强烈建议先学习SQLite原始操作方法，万变不理其中，这样再学习greenDao就会变得更轻松，更深刻些，可以参考：http://blog.csdn.net/xinanheishao/article/details/73436291 
文章目标 
 greenDao实现数据库建库建表 
 greenDao实现增删改查操作 
 提供一个数据库操作工具给大伙。 
greenDao简单介绍 
 greenDao是一个将对象映射到SQLite数据库中的轻量且快速的ORM解决方案，所谓ORM可以简单理解为框架可以把数据库的表自动转化为实体模型，程序员只要操作实体即可，操作实体即操作对应的表，这种框架设计是目前比较流行也是软件开发的趋势。 
 greenDao是一个精简的库 
 greenDao和同类型的库相比，性能是最好的,不过数据量不大的情况下，也看不出性能优势 
 greenDao内存开销最小化 
 greenDao易于使用的 APIs 
演示效果图： 
  
导入greenDao3.0库 
dependencies {
    compile 'org.greenrobot:greendao:3.0.1'
    compile 'org.greenrobot:greendao-generator:3.0.0'
} 
gradle中的greenDao相关配置 
 在gradle的中配置完毕之后，sync project一下，gradle会自动去远程仓库下载一个gradle的插件，专为greenDAO服务的，用来生成数据库相关的代码。 
apply plugin: 'org.greenrobot.greendao'
buildscript {
    repositories {
        jcenter()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.3.1'
        classpath 'org.greenrobot:greendao-gradle-plugin:3.0.0'

        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
} 
greenDao生成配置 
 配置说明： 
 schemaVersion—->指定数据库schema版本号，迁移等操作会用到 
 daoPackage——–>通过gradle插件生成的数据库相关文件的包名，默认为你 的entity所在的包名 
 targetGenDir——–>这就是我们上面说到的自定义生成数据库文件的目录了，可以将生成的文件放到我们的java目录中，而不是build中，这样就不用额外的设置资源目录了 
greendao {
    schemaVersion 1
    daoPackage 'com.example.yangdechengapplication.greendao'
    targetGenDir 'src/main/java'
} 
实体类的生成 
package com.example.yangdechengapplication.entity;

import org.greenrobot.greendao.annotation.Entity;
import org.greenrobot.greendao.annotation.Id;
import org.greenrobot.greendao.annotation.Transient;
import org.greenrobot.greendao.annotation.Generated;

/**
 * Created by Administrator on 2017/6/25.
 */
@Entity
public class User {
    @Id
    private Long id;
    private String userNo;
    private String name;
    @Transient
    private int tempUsageCount; // not persisted
    public String getName() {
        return this.name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Long getId() {
        return this.id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getUserNo() {
        return this.userNo;
    }
    public void setUserNo(String userNo) {
        this.userNo = userNo;
    }
    @Generated(hash = 1192512955)
    public User(Long id, String userNo, String name) {
        this.id = id;
        this.userNo = userNo;
        this.name = name;
    }
    @Generated(hash = 586692638)
    public User() {
    }
} 
实体类中常用的注解： 
@Entity 　表明这个实体类会在数据库中生成一个与之相对应的表。 
@Id 　对应数据表中的 Id 字段，有了解数据库的话，是一条数据的唯一标识。 
@Property(nameInDb = “STUDENTNUM”) 　表名这个属性对应数据表中的 STUDENTNUM 字段。 
@Property 　可以自定义字段名，注意外键不能使用该属性 
@NotNull 　该属性值不能为空 
@Transient 　该属性不会被存入数据库中 
@Unique 　表名该属性在数据库中只能有唯一值 
当你编写完实体之后，点击编译根据实体类会在greenDao配置的目录下生成三个数据库数据库相关的类：DaoSession、DaoMaster以及所有实体类的dao类，其中DaoMaster 和 DaoSession 这两个类用于初始化数据库，UserDao就是操作User表的类。 
 如图所示: 
  
GreenDaoHelper 
 这是我封装的数据库库初始化的帮助类 
package com.example.yangdechengapplication.data;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;

import com.example.yangdechengapplication.MyApplication;
import com.example.yangdechengapplication.greendao.DaoMaster;
import com.example.yangdechengapplication.greendao.DaoSession;

/**
 * Created by Administrator on 2017/6/25.
 */

public class GreenDaoHelper {

    private static DaoMaster.DevOpenHelper mHelper;
    private static SQLiteDatabase db;
    private static DaoMaster mDaoMaster;
    private static DaoSession mDaoSession;
    private static GreenDaoHelper instance = new GreenDaoHelper();
    public static GreenDaoHelper getInstance(){
        return instance;
    }

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

}
 
然后再程序的入口初始化数据库 
package com.example.yangdechengapplication;

import android.app.Application;

import com.example.yangdechengapplication.data.BaseDBHelper;
import com.example.yangdechengapplication.data.GreenDaoHelper;
import com.example.yangdechengapplication.tools.CrashHandler;
import com.example.yangdechengapplication.tools.LogToFile;

/**
 * Created by Administrator on 2017/6/15.
 */

public class MyApplication extends Application {
    private final static float HEAP_UTILIZATION = 0.75f;
    private final static int MIN_HEAP_SIZE = 6* 1024* 1024 ;
    @Override
    public void onCreate() {
        super.onCreate();

        // 异常处理，不需要处理时注释掉这两句即可！
        CrashHandler crashHandler = CrashHandler.getInstance();
        // 注册crashHandler
        crashHandler.init(getApplicationContext());
        LogToFile.init(getApplicationContext());
        //ydc 20170616 初始化数据库
        BaseDBHelper.getInstance().init(getApplicationContext());
        //ydc 20170629  初始化greenDao数据库
        GreenDaoHelper.initGreenDao(getApplicationContext());
    }
}
 
查看数据库 
 如果是模拟器运行的话，Android系统底层是Linux构建的，所以我们可以使用adb shell命令来查看我们所创建的数据库，步骤如下： 
 adb shell 
 su 
 ls -l 
 cd data 
 ls -l 
 cd data 
 ls -l 
 cd 你的包名 
 ls -l 
 cd databases 
 ls -l 
还可以进一步操作： 
 在 # 提示符下输入以下命令，我们进入sqlite（Figure3）。 
 sqlite3 mygreendb.db 
 这个命令会打开mygreendb.db数据库，若mygreendb.db数据库不存在，则会新建一个名为 
 mygreendb.db的数据库。(注意数据库名大小写有区别) 
 在sqlite>提示符下输入 
 .help 这个命令让我们看到许多命令 
 .tables 查看所有表，例如我的系统里有USER表 
 
 
 
 
 
 
 
数据库增删改查操作 
 在Activity中获取UserDao实例 
UserDao  userDao= GreenDaoHelper.getDaoSession().getUserDao(); 
增加操作 
User user = new User(null,String.valueOf(userNo), "张三");
            userDao.insert(user); 
删除操作 
 userDao.deleteAll()； 
修改操作 
 先根据编号获取的想修改的User实体，再做修改 
 User user=getUserByNo(String.valueOf(2));
            user.setName("李四");
            userDao.update(user);

private User getUserByNo(String userNo){
        user=userDao.queryBuilder().where(UserDao.Properties.UserNo.eq(userNo)).unique();
        return user;
    }   
查询操作 
 List<User> userList = userDao.queryBuilder()
                    .where(UserDao.Properties.Id.notEq(999))
                    .orderAsc(UserDao.Properties.Id)
                    .limit(5)
                    .build().list(); 
GreendaoActivity 
 greenDao增删改查操作所在类Activity 
package com.example.yangdechengapplication;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;
import com.example.yangdechengapplication.data.DBHelperService;
import com.example.yangdechengapplication.data.GreenDaoHelper;
import com.example.yangdechengapplication.entity.User;
import com.example.yangdechengapplication.greendao.UserDao;
import java.util.List;

/**
 * Created by ydc on 2017/6/25.
 */

public class GreendaoActivity extends AppCompatActivity {
    private Button delete;
    private Button insertButton;
    private Button updateButton;
    private Button queryButton;
    private TextView tv_info;
    private UserDao userDao;
    private User user;

    private  int userNo=0;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_greendao);
        userDao= GreenDaoHelper.getDaoSession().getUserDao();

        delete = (Button)findViewById(R.id.delete);
        updateButton = (Button)findViewById(R.id.update);
        insertButton = (Button)findViewById(R.id.insert);
        queryButton = (Button)findViewById(R.id.query);
        tv_info=(TextView)findViewById(R.id.tv_info);

        delete.setOnClickListener(new DeleteListener());
        updateButton.setOnClickListener(new UpdateListener());
        insertButton.setOnClickListener(new InsertListener());
        queryButton.setOnClickListener(new QueryListener());
    }


    class InsertListener implements View.OnClickListener {

        @Override
        public void onClick(View v) {

            userNo++;
            user = new User(null,String.valueOf(userNo), "张三");
            userDao.insert(user);
        }
    }



    class UpdateListener implements View.OnClickListener {

        @Override
        public void onClick(View arg0) {
            user=getUserByNo(String.valueOf(userNo));
            user.setName("李四");
            userDao.update(user);
        }
    }

    class QueryListener implements View.OnClickListener {

        @Override
        public void onClick(View v) {
            String names="";
            List<User> userList = userDao.queryBuilder()
                    .where(UserDao.Properties.Id.notEq(999))
                    .orderAsc(UserDao.Properties.Id)
                    .limit(5)
                    .build().list();

            for (User u: userList
                 ) {
                names+="姓名:"+u.getName()+" 学号:"+u.getUserNo()+";\n";

            }
            tv_info.setText(names);
        }
    }
    class DeleteListener implements View.OnClickListener {
        @Override
        public void onClick(View v) {
            userDao.deleteAll();
        }
    }

    private User getUserByNo(String userNo){
        user=userDao.queryBuilder().where(UserDao.Properties.UserNo.eq(userNo)).unique();
        return user;
    }
}
 
Dome下载地址：http://download.csdn.net/download/xinanheishao/9880447

收起

展开全文

greenDao android 数据库数据 sqlite

实现Android数据持久化的3种方法与优劣比较

2021-05-27 06:35:52

在工作中需要实现本地数据持久化缓存的操作。查看了下当下流行的几款比较受欢迎的开源框架。选取了比较有代表性的(GreenDAO 与Litepal)进行实现和与原生的Sqlite框架进行实现和比较。一、GreenDAO的介绍与实现1、...


 近日，从事MobIM开发工作。在工作中需要实现本地数据持久化缓存的操作。查看了下当下流行的几款比较受欢迎的开源框架。选取了比较有代表性的(GreenDAO 与Litepal)进行实现和与原生的Sqlite框架进行实现和比较。
 一、GreenDAO的介绍与实现
 1、GreenDAO的优点性能高，号称Android最快的关系型数据库
 内存占用小
 库文件比较小，小于100K，编译时间低，而且可以避免65K方法限制
 支持数据库加密  greendao支持SQLCipher进行数据库加密
 简洁易用的API
 2、最新的GreenDAO的版本为3.2.2。集成方式十分便捷和简单。Javabean就是数据库对象，对JavaBean的操作，直接映射到数据库 上。避免手写建表SQL的繁琐，和手写数据库操作的代码。并且支持各类函数级别的增、删、改、查。
 3、GreenDAO的集成步骤
 1)在Project的build.gradle里添加greendao-gradle-plugin。classpath 'org.greenrobot:greendao-gradle-plugin:3.2.1'
 
 2)在App的build.gradle里声明引用GreenDAO的 plugin 。apply plugin: 'org.greenrobot.greendao'
 
 3)引用GreenDAO的工程jar包。   compile 'org.greenrobot:greendao:3.2.0'
 
 4)执行Sync Project with Gradle Files 。根据以上配置，下载和引用GreenDAO的类库。
 
 5)创建数据库映射的实体类。其中，@Entity 、@Id、@Property 等都是GreenDAO特有的元注解，可以通过标注JavaBean来告诉GreenDAO这是个数据库表，以及表对应的字段名。使用注解的方式来定义实 体类，通过gradle插件生成相应的代码，十分方便 。@Entity
 public class User {
 public static final int MAN = 1 ;
 public static final int WOMAN = 0 ;
 @Id(autoincrement = true)
 private Long id;
 //@Unique
 private String name;
 @Property(nameInDb = "db_age")
 private String age;
 private String date;
 private String regdate;
 .............
 6)标注完成后，再执行下 4)步骤，会自动生成 get、set 方法和构造函数。
 
 7)针对User类的数据库操作类也已经自动生成了。它就是 UserDao 。获取UserDAO需要用到DaoSession 和DaoMaster。通过以下步骤获取UserDAO。以此类推通过定义 Xyz类的JavaBean就可以自动生成 XyzDao。
 
 了解DaoMaster和DaoSession与XyzDao的关系
 
 DaoMaster： 使用greenDAO的切入点。DaoMaster保存数据库对象(SQLiteDatabase)并管理特定模式的DAO类(而不是对象)。 它具有静态方法来创建表或将它们删除。 其内部类OpenHelper和DevOpenHelper是在SQLite数据库中创建模式的SQLiteOpenHelper实现。一个 DaoMaster就代表着一个数据库的连接。
 DaoSession： 管理特定模式的所有可用DAO对象，您可以使用其中一个getter方法获取。 DaoSession还为实体提供了一些通用的持久性方法，如插入，加载，更新，刷新和删除。 DaoSession可以让我们使用一些Entity的基本操作和获取Dao操作类，DaoSession可以创建多个，每一个都是属于同一个数据库连接的。
 XyzDAO：数据访问对象(DAO)持续存在并查询实体。 对于每个实体，GreenDAO生成一个DAO。 它比DaoSession有更多的持久化方法，例如：count，loadAll和insertInTx。
 8) GreenDAO的数据库一般操作。
 
 
 二、LitePal的介绍与实现
 1、LitePal的介绍
 LitePal非常小，集成起来非常方便，通过建立JavaBean继承DataSupport的方式，直接使其JavaBean具有了，数据库操作的相关方法。
 2、LitePal的实现
 1)在App的build.gradle里导入LitePal的类库。   compile 'org.litepal.android:core:1.6.0'
 
 2)在资源文件夹assets下建立litepal.xml文件。
 
 
 3)建立JavaBean类，并继承DataSupport。
 
 4)声明LitePalApplication。    android:name="org.litepal.LitePalApplication"
 
 5)LitePal的数据库一般操作。
 
 
 三、Android SQLite原生数据库介绍与实现
 1、Android SQLite原生数据库介绍
 Android才用了小型的关系数据SQLite，占用资源很少。支持各种数据库操作。
 2、Android SQLite原生数据库的实现
 大家对Android 原生数据库的实现应该比较熟悉，这里不再详细赘述，主要指出主要步骤。
 
 
 
 
 四、3种数据库实现方式在具体实践中的比较
 在魅族metal手机上的测试结果：执行效率 SQLite原生 > GreenDAO > Litepal
 
 五、分析原因与使用方式推荐
 SQLite原生集成虽然费时，但是其中没有封装各类复合查询和各类判断，效率最高。
 GreenDAO开始配置的时候步骤比较繁琐，使用了注解类动态生成操作类，接口函数封装很完善，功能强大，如果不涉及到大规模的数据库操作推荐使用。
 Litepal配置简单，集成速度很快，但是要配置LitepalApplication，有一定侵入式，在一些小型快速的项目上可以推荐使用。
 文/Mob开发者平台 Android开发专家 徐化杰

收起

展开全文

android 数据库框架GreenDao的使用

2018-07-23 14:18:31

android的开发过程中，我们经常会用到数据存储的功能，目前android中常用的存储方式主要有： ...本文主要介绍本地数据库存储的一种实现方式，通过GreenDao创建本地数据库。目前市面上比较常用的android...

android的开发过程中，我们经常会用到数据存储的功能，目前android中常用的存储方式主要有： 
SharedPreferences存储数据:以key-value（键值对）的方式存储一些轻量级的数据
本地文件存储数据
本地数据库存储数据（基于sqlite）
服务器在线存储 
目前市面上比较常用的android数据库框架主要有：ORMLite和GreenDao，关于两者的区别，本文不做介绍，有兴趣可以查看此文章。本文主要介绍本地数据库存储的一种实现方式，通过GreenDao创建本地数据库。GreenDao是一个对象关系映射（ORM）的框架，能够提供一个接口通过操作对象的方式去操作关系型数据库，它能够让你操作数据库时更简单、更方便。 
  
GreenDao的优点 
GreenDao 优点： 
性能高，号称Android最快的关系型数据库
内存占用小
库文件比较小，小于100K，编译时间低，而且可以避免65K方法限制
支持数据库加密 greendao支持SQLCipher进行数据库加密 有关SQLCipher可以参考这篇博客Android数据存储之Sqlite采用SQLCipher数据库加密实战
简洁易用的API
GreenDao 3.0采用注解的方式通过编译方式生成Java数据对象和DAO对象。 
GreenDao的使用 
通过github上GreenDao的地址，我们在项目中引入GreenDao项目： 
 github引入说明： 
// In your root build.gradle file:
buildscript {
    repositories {
        jcenter()
        mavenCentral() // add repository
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.1.1'
        classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2' // add plugin
    }
}

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

dependencies {
    implementation 'org.greenrobot:greendao:3.2.2' // add library
} 
根据上文中的内容，将GreenDao引入到我们的工程代码中。 
创建实体 
@Entity
public class User {
    @Id
    private Long id;
    private String name;
    private int age;
} 
实体@Entity注解 
schema：告知GreenDao当前实体属于哪个schema
active：标记一个实体处于活动状态，活动实体有更新、删除和刷新方法
nameInDb：在数据中使用的别名，默认使用的是实体的类名
indexes：定义索引，可以跨越多个列
createInDb：标记创建数据库表 
基础属性注解 
@Id :主键 Long型，可以通过@Id(autoincrement = true)设置自增长
@Property：设置一个非默认关系映射所对应的列名，默认是的使用字段名 举例：@Property (nameInDb=”name”)
@NotNul：设置数据库表当前列不能为空
@Transient ：添加次标记之后不会生成数据库表的列 
索引注解 
@Index：使用@Index作为一个属性来创建一个索引，通过name设置索引别名，也可以通过unique给索引添加约束
@Unique：向数据库列添加了一个唯一的约束 
关系注解 
@ToOne：定义与另一个实体（一个实体对象）的关系
@ToMany：定义与多个实体对象的关系 
GreenDao配置 
我们在app的build.gradle配置文件中，添加如下代码： 
greendao {
    schemaVersion 1
    daoPackage 'com.lee.test.greendao'
    targetGenDir 'src/main/java'
} 
相关参数的说明： 
schemaVersion： 数据库schema版本，也可以理解为数据库版本号
daoPackage：设置DaoMaster 、DaoSession、Dao包名
targetGenDir：设置DaoMaster 、DaoSession、Dao目录
targetGenDirTest：设置生成单元测试目录
generateTests：设置自动生成单元测试用例 
创建数据库操作方法 
通过点击AndroidStudio中的MakeProject，GreenDao为我们的User实体类生成了对应的Getter、Setter方法以及俩个构造函数，同时在我们配置的com.lee.test.greendao包下生成了三个对应类文件DaoMaster、DaoSession和UserDao，之后所有相关的数据库操作都依靠这三个文件。 
DaoMaster：使用GreenDao的切入点。DaoMaster保存数据库对象（SQLiteDatabase）并管理特定模式的DAO类（而不是对象）。 它具有静态方法来创建表或将它们删除。 其内部类OpenHelper和DevOpenHelper是在SQLite数据库中创建模式的SQLiteOpenHelper实现。一个DaoMaster就代表着一个数据库的连接。
DaoSession：管理特定模式的所有可用DAO对象，您可以使用其中一个getter方法获取。 DaoSession还为实体提供了一些通用的持久性方法，如插入，加载，更新，刷新和删除。 DaoSession可以让我们使用一些Entity的基本操作和获取Dao操作类，DaoSession可以创建多个，每一个都是属于同一个数据库连接的。
UserDAO：数据访问对象（DAO）持续存在并查询实体。 对于每个实体，GreenDAO生成一个DAO。 它比DaoSession有更多的持久化方法，例如：count，loadAll和insertInTx。 
通过上面生成的三个类文件，创建一个数据库管理类DBManager，用于创建数据库、创建数据库表、包含增删改查的操作以及数据库的升级。 
数据库管理类： 
public class DBManager {
    private final static String dbName = "test_db";
    private static DBManager mInstance;
    private DaoMaster.DevOpenHelper openHelper;
    private Context context;

    public DBManager(Context context) {
        this.context = context;
        openHelper = new DaoMaster.DevOpenHelper(context, dbName, null);
    }

    /**
     * 获取单例引用
     *
     * @param context
     * @return
     */
    public static DBManager getInstance(Context context) {
        if (mInstance == null) {
            synchronized (DBManager.class) {
                if (mInstance == null) {
                    mInstance = new DBManager(context);
                }
            }
        }
        return mInstance;
    }

     /**
     * 打开输出日志，默认关闭
     */
    public void setDebug(){
        QueryBuilder.LOG_SQL = true;
        QueryBuilder.LOG_VALUES = true;
    }

} 
1.获取数据库： 
     /**
     * 获取可读数据库
     */
    private SQLiteDatabase getReadableDatabase() {
        if (openHelper == null) {
            openHelper = new DaoMaster.DevOpenHelper(context, dbName, null);
        }
        SQLiteDatabase db = openHelper.getReadableDatabase();
        return db;
    }

     /**
     * 获取可写数据库
     */
    private SQLiteDatabase getWritableDatabase() {
        if (openHelper == null) {
            openHelper = new DaoMaster.DevOpenHelper(context, dbName, null);
        }
        SQLiteDatabase db = openHelper.getWritableDatabase();
        return db;
    } 
2.插入数据 
     /**
     * 插入一条记录
     *
     * @param user
     */
    public void insertUser(User user) {
        DaoMaster daoMaster = new DaoMaster(getWritableDatabase());
        DaoSession daoSession = daoMaster.newSession();
        UserDao userDao = daoSession.getUserDao();
        userDao.insert(user);
    }

    /**
     * 插入用户集合
     *
     * @param users
     */
    public void insertUserList(List<User> users) {
        if (users == null || users.isEmpty()) {
            return;
        }
        DaoMaster daoMaster = new DaoMaster(getWritableDatabase());
        DaoSession daoSession = daoMaster.newSession();
        UserDao userDao = daoSession.getUserDao();
        userDao.insertInTx(users);
    } 
3.删除数据 
     /**
     * 删除一条记录
     *
     * @param user
     */
    public void deleteUser(User user) {
        DaoMaster daoMaster = new DaoMaster(getWritableDatabase());
        DaoSession daoSession = daoMaster.newSession();
        UserDao userDao = daoSession.getUserDao();
        userDao.delete(user);
    } 
4.更新数据 
     /**
     * 更新一条记录
     *
     * @param user
     */
    public void updateUser(User user) {
        DaoMaster daoMaster = new DaoMaster(getWritableDatabase());
        DaoSession daoSession = daoMaster.newSession();
        UserDao userDao = daoSession.getUserDao();
        userDao.update(user);
    } 
5.查询数据 
     /**
     * 查询用户列表
     */
    public List<User> queryUserList() {
        DaoMaster daoMaster = new DaoMaster(getReadableDatabase());
        DaoSession daoSession = daoMaster.newSession();
        UserDao userDao = daoSession.getUserDao();
        QueryBuilder<User> qb = userDao.queryBuilder();
        List<User> list = qb.list();
        return list;
    }

    /**
     * 查询用户列表
     */
    public List<User> queryUserList(int age) {
        DaoMaster daoMaster = new DaoMaster(getReadableDatabase());
        DaoSession daoSession = daoMaster.newSession();
        UserDao userDao = daoSession.getUserDao();
        QueryBuilder<User> qb = userDao.queryBuilder();
        qb.where(UserDao.Properties.Age.gt(age)).orderAsc(UserDao.Properties.Age);
        List<User> list = qb.list();
        return list;
    } 
6.关闭数据库 
     /**
     * 关闭所有的操作，数据库开启后，使用完毕要关闭
     */
    public void closeConnection(){
        closeHelper();
        closeDaoSession();
    }

    public void closeHelper(){
        if(openHelper != null){
            openHelper.close();
            openHelper = null;
        }
    }

    public void closeDaoSession(){
        if(daoSession != null){
            daoSession.clear();
            daoSession = null;
        }
    } 
到这里，GreenDao数据库的基本属性就介绍完了，通过上文的介绍，我们可以通过GreenDao实现基本的数据库操作。后续相关方法的使用，将另做介绍。

收起

展开全文

安卓持久框架Room VS GreenDao

千次阅读 2020-06-17 13:30:06

//greenDAO配置 compile 'org.greenrobot:greendao:3.2.2' 同时在module（App）下build.gradle添加插件的使用 apply plugin: 'org.greenrobot.greendao' 2、设置版本号、生成目录等 1 2 3 4 5 6 7 8 9 在module...

一 、Room的基本使用 
1、导包： 
 1
 2
  implementation "androidx.room:room-runtime:2.2.3"
 annotationProcessor 'android.arch.persistence.room:compiler:1.1.1'
 
2、添加数据库 
 1
 2
 3
 4
 5
 6
  @Database(entities = {User.class}, version = 1, exportSchema = false)
 public abstract class MyDataBase extends RoomDatabase {
  
     public abstract UserDao getUserDao();
  
 }
 
3、Application里面初始化 
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
  public class AppContext extends Application {
  
     public static MyDataBase myDataBase;
  
     @Override
     public void onCreate() {
         super.onCreate();
         initDataBase();
     }
  
     /* 初始化 数据库 */
     private void initDataBase() {
         myDataBase = Room.databaseBuilder(getApplicationContext(), MyDataBase.class, "User.db")
                 .build();
     }
 }
 
4、建立实体类（get和set方法一定要加上） 
 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
  @Entity(tableName = "Users")
 public class User {
  
     @NonNull
     @PrimaryKey
     @ColumnInfo(name = "UserId")//别名
     private String uuid;//数据库中字段名称
  
     @ColumnInfo(name = "UserName")
     private String userName;
  
     @ColumnInfo(name = "Date")
     private String date;
  
     @Ignore
     public User(String userName) {
         this.uuid = UUID.randomUUID().toString();
         this.userName = userName;
         this.date = SimpleDateFormat.getDateInstance().format(new Date(System.currentTimeMillis()));
     }
  
     public User(String uuid, String userName, String date) {
         this.uuid = uuid;
         this.userName = userName;
         this.date = date;
     }
  
     public String getUuid() {
         return uuid;
     }
  
     public void setUuid(String uuid) {
         this.uuid = uuid;
     }
  
     public String getUserName() {
         return userName;
     }
  
     public void setUserName(String userName) {
         this.userName = userName;
     }
  
     public String getDate() {
         return date;
     }
  
     public void setDate(String date) {
         this.date = date;
     }
 }
 
5、添加UserDao 
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
  @Dao
 public interface UserDao {
  
     @Query("SELECT * FROM Users")
     List<User> getUsers();
  
     @Insert
     void addUser(User user);
  
     @Insert
     void addAll(List<User> userList);
  
     @Delete
     int deleteUser(User user);
  
     @Update
     int updateUser(User user);
  
  
 }
 
6、使用 
 1
 2
 3
 4
 5
 6
 7
 8
  获取数据
 List<Fruit> users = AppContext.myDataBase.getFruitDao().getFruits();
  
 插入数据
 User user = new User(et.getText().toString());
 AppContext.myDataBase.getUserDao().addUser(user);
  
 需要注意的是：数数据库所有的操作都需要在子线程种运行。这里可以配合RxJava来使用
 
数据库的操作就到这里，结束了。 
  
下面来看一下数据库的升级管理 
此次升级，增加了一张Fruit表 
1、添加 
 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
  @Database(entities = {User.class, Fruit.class}, version = 2, exportSchema = false)
 public abstract class MyDataBase extends RoomDatabase {
  
     /* 升级数据库的方法 -- 当前为从 版本1 升级到 版本2 */
     public static final Migration MIGRATION_1_2 = new Migration(1, 2) {
         @Override
         public void migrate(SupportSQLiteDatabase database) {
             // 这里新创建一个Fruit表
             database.execSQL("CREATE TABLE `Fruit` (`FruitId` INTEGER NOT NULL, "
                     + "`FruitName` TEXT, PRIMARY KEY(`FruitId`))");
  
         }
     };
  
     public abstract UserDao getUserDao();
  
     public abstract FruitDao getFruitDao();
 }
  
  
 需要变化的点：
 1、表，entities 的注解里面多了一个Fruit表
 2、版本号+1 =2
 3、添加了一个Migration 、MIGRATION_1_2表示从1升到2的时候需要做的所有操作
 4、添加了一个新表对应的FruitDao
 
2、添加实体类和相应的Dao 
 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
  实体类：
 @Entity(tableName = "Fruit")
 public class Fruit {
  
     @NonNull
     @PrimaryKey
     @ColumnInfo(name = "FruitId")
     private Integer FruitId;
  
     @ColumnInfo(name = "FruitName")
     private String FruitName;
  
     public Fruit() {
         this.FruitName = "default_Fruit_Name";
     }
  
     @Ignore
     public Fruit(String FruitName) {
         this.FruitName = FruitName;
     }
  
     @NonNull
     public Integer getFruitId() {
         return FruitId;
     }
  
     public void setFruitId(@NonNull Integer fruitId) {
         FruitId = fruitId;
     }
  
     public String getFruitName() {
         return FruitName;
     }
  
     public void setFruitName(String fruitName) {
         FruitName = fruitName;
     }
 }
  
 DAO：
 @Dao
 public interface FruitDao {
  
     @Query("SELECT * FROM Fruit")
     List<Fruit> getFruits();
  
     @Insert
     void addFruit(Fruit fruit);
 }
 
3、添加升级操作 
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
  public class AppContext extends Application {
  
     public static MyDataBase myDataBase;
  
     @Override
     public void onCreate() {
         super.onCreate();
         initDataBase();
     }
  
     /* 初始化 数据库 */
     private void initDataBase() {
         Log.v("fwling", "初始化数据库");
         myDataBase = Room.databaseBuilder(getApplicationContext(), MyDataBase.class, "User.db")
                 .addMigrations(MyDataBase.MIGRATION_1_2)
                 .build();
     }
 }
  
 多了一行：.addMigrations(MyDataBase.MIGRATION_1_2)
 
以上就是Room的基本使用 
  
  
二、GreenDao的基本使用 
1、添加依赖（看清楚相应的文字说明，应该添加到哪里。别搞错） 
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
  在根项目的build.gradle的buildscript的dependencies下添加greenDao的插件
 classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2'
  
  
 项目的module下build.gradle的dependencies添加Green相应的包
 //greenDAO配置
 compile 'org.greenrobot:greendao:3.2.2'
  
 同时在module（App）下build.gradle添加插件的使用
 apply plugin: 'org.greenrobot.greendao'
 
　2、设置版本号、生成目录等 
 1
 2
 3
 4
 5
 6
 7
 8
 9
  在module（App）的build.gradle 下添加GreenDao的配置信息
  
 //greendao配置
 greendao {
     //数据库版本号，升级时修改
     schemaVersion 1
     //生成的DAO，DaoMaster和DaoSession的包路径。默认与表实体所在的包路径相同
     daoPackage 'com.fwl.demo.green_dao.db'
 }
 
3、初始化数据库 
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
  public class AppContext extends Application {
  
     private static DaoSession daoSession;
  
     @Override
     public void onCreate() {
         super.onCreate();
         initGreenDao();
     }
  
     /* 初始化 数据库 */
     private void initGreenDao() {
         DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(this, "aserbao.db");
         SQLiteDatabase db = helper.getWritableDatabase();
         DaoMaster daoMaster = new DaoMaster(db);
         daoSession = daoMaster.newSession();
     }
  
      
     public static DaoSession getDaoSession() {
         return daoSession;
     }
 }
 
4、创建实体类 
 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
  @Entity
 public class Student {
     @Id(autoincrement = true)
     Long id;
  
     String name;//姓名
  
     @Generated(hash = 1097502469)
     public Student(Long id, String name) {
         this.id = id;
         this.name = name;
     }
  
     @Generated(hash = 1556870573)
     public Student() {
     }
  
     public Long getId() {
         return id;
     }
  
     public void setId(Long id) {
         this.id = id;
     }
  
     public String getName() {
         return name;
     }
  
     public void setName(String name) {
         this.name = name;
     }
 }
  
  
 说明：我这边只添加了两个属性
 @Id(autoincrement = true)
 Long id;
 String name;//姓名
  
 get和set是手动、手动、手动生成的
 构造方法是自动、自动、自动生成的
 
5、编译，这步很重要。步骤三的有些报错的地方都是这步编译后导入的包。 
具体操作：Build--->Make Project 
6、使用： 
 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
  //查询
 List<Student> students = AppContext.getDaoSession().getStudentDao().getSession().loadAll(Student.class);
  
  
 //添加
 Student student=new Student();
 student.setName("dsa");
 AppContext.getDaoSession().getStudentDao().insert(student);
  
  
 //删除
 AppContext.getDaoSession().getStudentDao().deleteAll();
  
  
 //更新<查找id为1的Student，并将它的Name改为ABC>
 Student students = AppContext.getDaoSession().getStudentDao().getSession().load(Student.class, StudentDao.Properties.Id.eq(1));
 student.setName("ABC");
 AppContext.getDaoSession().getStudentDao().update(student);
 
GreenDao的基本使用就是上面这些了。 
下面来看看，Room和GreenDao的区别 
GreenDao Room
开发者只需要规定Entity的属性即可 需要规定Entity的属性，需要规定Dao接口
每次更新Entity需要重新build以生成代码，大型项目build耗时会比较久 更新Entity不需要重新build，因为使用的是Dao接口规定的方法，但是需要根据情况更新Dao接口
只有进行复杂操作时才需要写SQL语句  即使是进行简单的条件查询，也要写SQL语句
  
  
 
有一定的学习成本，需要学习注解、查询、条件语句等API 学习成本低，基本只需要掌握Room的注解即可
  
最后，两者的速度对比，GreenDao在批量操作数据的情况下，会比Room慢，慢不少。

GreenDao	Room
开发者只需要规定Entity的属性即可	需要规定Entity的属性，需要规定Dao接口
每次更新Entity需要重新build以生成代码，大型项目build耗时会比较久	更新Entity不需要重新build，因为使用的是Dao接口规定的方法，但是需要根据情况更新Dao接口
只有进行复杂操作时才需要写SQL语句	即使是进行简单的条件查询，也要写SQL语句
有一定的学习成本，需要学习注解、查询、条件语句等API	学习成本低，基本只需要掌握Room的注解即可

收起

展开全文

Android eclipse下数据开源框架GreenDao的配置
2017-01-09 14:25:00
　ORM(Object-RelationMapping,对象关系映射)，是一种为了解决面向对象与数据库存在的互一匹配的现象的技术，通过描述对象和关系数据库之间的映射，将程序中的对象自动持久化到关系数据库中。web中有很多的框架，像...
收起
Android组件化架构 - 5. 数据存储 & GreenDao, Room
2020-12-23 14:34:25
1. 数据的存储方式 ...比较值得介绍的是两个主流的数据库框架GreenDao,Room GreenDao 是目前众多orm数据库中最稳定,速度最快,编写体验最好的框架,并且支持RxJava, 支持sqlcipher数据库加密 // 一. greenDao的使用 //
收起
数据库 java android
Android ORM 框架 GreenDao 使用详解
2020-10-24 22:19:51
关于 Android 中常用的数据存储方式有 Sp 存储和文件存储，但是对于数据量比较大，并且结构复杂的数据我们想要存储只能通过数据库进行处理，Android 中提供了一个 SQLite 数据库，但是使用起来比较繁琐和复杂，...
收起
1024程序员节数据库 Android 移动开发安卓
Android ORM框架 GreenDao 的使用详解
2020-10-23 20:51:18
关于 Android 中常用的数据存储方式我们前面已经讲了 Sp 存储和文件存储，但是对于数据量比较大，并且结构复杂的数据我们想要存储只能通过数据库进行处理，Android 中提供了一个 SQLite 数据库，但是使用起来比较...
收起
android
Android 数据库框架GreenDao食用练习
2017-12-28 18:09:12
@Transient：表明这个字段不会被写入数据库，只是作为一个普通的java类字段，用来临时存储数据的，不会被持久化。 */ } 点击Build>make project 可见greendao自动为我们生成的相关内容。而后按照大佬的...
收起
数据库 android greendao
android使用数据库框架greendao笔记
2019-05-10 15:52:09
数据库框架很多，比如ormlite,但是我觉得比较好用的有greendao 官方网址 http://greenrobot.org/greendao/ 怎么开始呢，查看这个文档 http://greenrobot.org/greendao/documentation/how-to-get-started/ 添加依赖...
收起
Android
Android框架之路——GreenDao3.2.2的使用
万次阅读 多人点赞 2017-05-06 11:38:32
GreenDAO是一个开源的安卓ORM框架，能够使SQLite数据库的开发再次变得有趣。它减轻开发人员处理低级数据库需求，同时节省开发时间。 SQLite是一个令人敬畏的内嵌的关系数据库，编写SQL和解析查询结果是相当乏味和...
收起
android greendao 数据库框架 orm
数据库开源框架GreenDao的使用解析
2017-12-05 20:07:00
数据库开源框架GreenDao的使用解析 1,GreenDao概述 1),greenDao是一个当下十分火热的数据库开源框架,或者说是一个帮助Android开发者将数据存到SQLite中的一个开源项目, 也可以说是一个将对象映射到SQLite数据库中...
收起
android面试（16）-数据库存储框架greendao
千次阅读 2018-03-05 17:05:13
也就是我们常说的数据持久化，我们知道，android五种存储方式，网络存储，数据库存储，文件存储，SharePreference和contentprovider，其中数据库存储是比较常用的一种方式，但是android提供的原生的sqlite用起来比较...
收起
android 面试题 greenDao
Android(4) 数据库框架 GreenDao3.0的使用
2018-05-28 12:45:15
ORM：对象-关系映射（OBJECT/RELATIONALMAPPING，简称ORM），是随着面向对象的软件开发方法发展而产生的。...ORM 技术是在对象和关系之间提供了一条桥梁，前台的对象型数据和数据库中的关系型的数据通...
收起
Android 数据库框架
Android ORM框架 greenDao使用
2016-04-08 16:47:10
前言：平时开发时，总会进行数据存储操作。...greenDao在所有的Android数据库ORM开源框架中效率最高，官网这么描述：probably the fastest ORM for Android. 先说greenDao特点：性能最优、易用性高、占内存
收起
android 数据库开源框架数据存储 orm
记一次开源框架GreenDao移植到Andrdoi原生Make编译项目中的过程
2019-05-07 17:52:49
那么我们如何将频道数据进行持久化呢？我选择了GreenDao.引入步骤：将Android的原生项目映射到android studio项目—新建空项目，项目包名是Android原生项目包名，并将相应资源复制到android studio项目。在...
收起
greendao 移植原生
技术共享之数据库框架GreenDao的使用以及二次封装
千次阅读 2017-12-07 15:56:45
greendao 框架是一款ORM 数据库框架，ORM也就是对象关系映射。相比其他数据库框架与原生的sql语句相比好处：1、一个精简的库 2、性能最大化 3、内存开销最小化 4、易于使用的 APIs 5、对 Android 进行高度...
收起
数据库 android 框架技术对象
ORM数据库框架 greenDAO SQLite MD
2018-08-14 23:11:00
Markdown版本笔记我的GitHub首页我的博客我的微信我的邮箱 MyAndroidBlogs baiqiantao baiqiantao bqt20094 ...ORM数据库框架 greenDAO SQLite MD 目录目录简介...
收起
ORM框架greenDAO搭建
2016-11-18 14:52:34
简介greenDAO是一个可以帮助Android开发者快速将Java对象映射到SQLite数据库的表单中的ORM解决方案，通过使用一个简单的面向对象API，开发者可以对Java对象进行存储、更新、删除和查询；greenDAO搭建(Andorid Studio...
收起
android 框架
关于Android数据持久层SQLite数据库中的GreenDao和ROOM的使用
2020-11-09 14:55:06
而数据保存，在Android的开发中显得尤其重要，Android虽然提供了一个轻量级的数据库--SQLite，但是使用起来不是很方便，特别是对于不擅长SQL语句的同学，更是一场极大的考验，从而增加了学习成本。本文将介绍两种...
收起
jetpack kotlin
安卓进阶系列-07数据库框架(GreenDAO)的使用
2019-01-31 13:28:07
安卓提供了一个占用内存极小的数据库SQLite，也提供了不少操作数据库的API，然而不是所有程序员都擅长编写SQL语句，这时一个ORM的数据库框架就显得很好用了。在之前的博客我已经提到了LitePal的使用，但是实际开发...
收起
强大的数据库ORM框架-GreenDao项目源码剖析篇
千次阅读 2016-12-09 15:19:55
由上一篇博文( 强大的数据库ORM框架-GreenDao项目构建篇)可知，无论通过哪一种方式我们都可以比较容易的构建出GreenDao项目，并且成功生成相关的数据库管理文件，但是这些源码文件都各有什么作用，我们该如何去使用...
收起
GreenDao ORM android 数据库
安卓数据库框架greenDAO（一）
2016-05-28 23:04:00
一、GitHub简介： GitHub地址：https://github.com/greenrobot/greenDAO greenDAO greenDAO is a light & fast ORM solution for Android that maps objects...
收起
Android Sqlite 框架 GreenDao的原理与使用简介
千次阅读 2015-10-14 17:46:30
一、背景知识 ORM(Object Relation Mapping):对象关系模型。用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说，它其实是创建了一个...ORM作为项目中间件形式实现数据在不同场景下数据关系映
收起

Android中轻松使用greenDao实现数据持久化

实现Android数据持久化的3种方法与优劣比较

android 数据库框架GreenDao的使用

GreenDao的优点

GreenDao的使用

创建实体

GreenDao配置

创建数据库操作方法

安卓持久框架Room VS GreenDao

Android eclipse下数据开源框架GreenDao的配置

Android组件化架构 - 5. 数据存储 & GreenDao, Room

Android ORM 框架 GreenDao 使用详解

Android ORM框架 GreenDao 的使用详解

Android 数据库框架GreenDao食用练习

android使用数据库框架greendao笔记

Android框架之路——GreenDao3.2.2的使用

数据库开源框架GreenDao的使用解析

android面试（16）-数据库存储框架greendao

Android(4) 数据库框架 GreenDao3.0的使用

Android ORM框架 greenDao使用

记一次开源框架GreenDao移植到Andrdoi原生Make编译项目中的过程

技术共享之数据库框架GreenDao的使用以及二次封装

ORM数据库框架 greenDAO SQLite MD

ORM框架greenDAO搭建

关于Android数据持久层SQLite数据库中的GreenDao和ROOM的使用

安卓进阶系列-07数据库框架(GreenDAO)的使用

强大的数据库ORM框架-GreenDao项目源码剖析篇

安卓数据库框架greenDAO（一）

Android Sqlite 框架 GreenDao的原理与使用简介

数据持久化框架greendao