精华内容
下载资源
问答
  • 在使用原始方法来操作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

    演示效果图:
    greenDao

    导入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表的类。
    如图所示:
    dao效果图

    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表

    adb001

    adb002

    adb003

    adb004

    adb005

    adb006

    adb007

    数据库增删改查操作
    在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 与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'

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    2)在App的build.gradle里声明引用GreenDAO的 plugin 。apply plugin: 'org.greenrobot.greendao'

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    3)引用GreenDAO的工程jar包。   compile 'org.greenrobot:greendao:3.2.0'

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    4)执行Sync Project with Gradle Files 。根据以上配置,下载和引用GreenDAO的类库。

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    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 方法和构造函数。

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    7)针对User类的数据库操作类也已经自动生成了。它就是 UserDao 。获取UserDAO需要用到DaoSession 和DaoMaster。通过以下步骤获取UserDAO。以此类推通过定义 Xyz类的JavaBean就可以自动生成 XyzDao。

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    了解DaoMaster和DaoSession与XyzDao的关系

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    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的数据库一般操作。

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    二、LitePal的介绍与实现

    1、LitePal的介绍

    LitePal非常小,集成起来非常方便,通过建立JavaBean继承DataSupport的方式,直接使其JavaBean具有了,数据库操作的相关方法。

    2、LitePal的实现

    1)在App的build.gradle里导入LitePal的类库。   compile 'org.litepal.android:core:1.6.0'

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    2)在资源文件夹assets下建立litepal.xml文件。

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    3)建立JavaBean类,并继承DataSupport。

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    4)声明LitePalApplication。    android:name="org.litepal.LitePalApplication"

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    5)LitePal的数据库一般操作。

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    三、Android SQLite原生数据库介绍与实现

    1、Android SQLite原生数据库介绍

    Android才用了小型的关系数据SQLite,占用资源很少。支持各种数据库操作。

    2、Android SQLite原生数据库的实现

    大家对Android 原生数据库的实现应该比较熟悉,这里不再详细赘述,主要指出主要步骤。

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    四、3种数据库实现方式在具体实践中的比较

    在魅族metal手机上的测试结果:执行效率 SQLite原生 > GreenDAO > Litepal

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    五、分析原因与使用方式推荐

    SQLite原生集成虽然费时,但是其中没有封装各类复合查询和各类判断,效率最高。

    GreenDAO开始配置的时候步骤比较繁琐,使用了注解类动态生成操作类,接口函数封装很完善,功能强大,如果不涉及到大规模的数据库操作推荐使用。

    Litepal配置简单,集成速度很快,但是要配置LitepalApplication,有一定侵入式,在一些小型快速的项目上可以推荐使用。

    文/Mob开发者平台 Android开发专家 徐化杰

    展开全文
  • 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(12) {

            @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的区别

    GreenDaoRoom
    开发者只需要规定Entity的属性即可需要规定Entity的属性,需要规定Dao接口
    每次更新Entity需要重新build以生成代码,大型项目build耗时会比较久更新Entity不需要重新build,因为使用的是Dao接口规定的方法,但是需要根据情况更新Dao接口
    只有进行复杂操作时才需要写SQL语句

    即使是进行简单的条件查询,也要写SQL语句

     

     

    有一定的学习成本,需要学习注解、查询、条件语句等API学习成本低,基本只需要掌握Room的注解即可

     

    最后,两者的速度对比,GreenDao在批量操作数据的情况下,会比Room慢,慢不少。

     

    展开全文
  •  ORM(Object-RelationMapping,对象关系映射),是一种为了解决面向对象与数据库存在的互一匹配的现象的技术,通过描述对象和关系数据库之间的映射,将程序中的对象自动持久化到关系数据库中。web中有很多的框架,像...
  • 1. 数据的存储方式 ...比较值得介绍的是两个主流的数据库框架GreenDao,Room GreenDao 是目前众多orm数据库中最稳定,速度最快,编写体验最好的框架,并且支持RxJava, 支持sqlcipher数据库加密 // 一. greenDao的使用 //
  • 关于 Android 中常用的数据存储方式有 Sp 存储 和 文件存储,但是对于数据量比较大,并且结构复杂的数据我们想要存储只能通过数据库进行处理,Android 中提供了一个 SQLite 数据库,但是使用起来比较繁琐和复杂,...
  • 关于 Android 中常用的数据存储方式我们前面已经讲了 Sp 存储 和 文件存储,但是对于数据量比较大,并且结构复杂的数据我们想要存储只能通过数据库进行处理,Android 中提供了一个 SQLite 数据库,但是使用起来比较...
  • @Transient:表明这个字段不会被写入数据库,只是作为一个普通的java类字段,用来临时存储数据的,不会被持久化。 */ } 点击Build>make project 可见greendao自动为我们生成的相关内容。 而后按照大佬的...
  • 数据库框架很多,比如ormlite,但是我觉得比较好用的有greendao 官方网址 http://greenrobot.org/greendao/ 怎么开始呢,查看这个文档 http://greenrobot.org/greendao/documentation/how-to-get-started/ 添加依赖...
  • Android框架之路——GreenDao3.2.2的使用

    万次阅读 多人点赞 2017-05-06 11:38:32
    GreenDAO是一个开源的安卓ORM框架,能够使SQLite数据库的开发再次变得有趣。它减轻开发人员处理低级数据库需求,同时节省开发时间。 SQLite是一个令人敬畏的内嵌的关系数据库,编写SQL和解析查询结果是相当乏味和...
  • 数据库开源框架GreenDao的使用解析 1,GreenDao概述 1),greenDao是一个当下十分火热的数据库开源框架,或者说是一个帮助Android开发者将数据存到SQLite中的一个开源项目, 也可以说是一个将对象映射到SQLite数据库中...
  • 也就是我们常说的数据持久化,我们知道,android五种存储方式,网络存储,数据库存储,文件存储,SharePreference和contentprovider,其中数据库存储是比较常用的一种方式,但是android提供的原生的sqlite用起来比较...
  • ORM:对象-关系映射(OBJECT/RELATIONALMAPPING,简称ORM),是随着面向对象的软件开发方法发展而产生的。...ORM 技术是在对象和关系之间提供了一条桥梁,前台的对象型数据和数据库中的关系型的数据通...
  • 前言: 平时开发时,总会进行数据存储操作。...greenDao在所有的Android数据库ORM开源框架中效率最高,官网这么描述:probably the fastest ORM for Android. 先说greenDao特点: 性能最优、易用性高、占内存
  • 那么我们如何将频道数据进行持久化呢?我选择了GreenDao.引入步骤: 将Android的原生项目映射到android studio项目—新建空项目,项目包名是Android原生项目包名,并将相应资源复制到android studio项目。 在...
  • greendao 框架是一款ORM 数据库框架,ORM也就是对象关系映射。 相比其他数据库框架与原生的sql语句相比 好处:1、一个精简的库 2、性能最大 3、内存开销最小 4、易于使用的 APIs 5、对 Android 进行高度...
  • 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,但是使用起来不是很方便,特别是对于不擅长SQL语句的同学,更是一场极大的考验,从而增加了学习成本。本文将介绍两种...
  • 安卓提供了一个占用内存极小的数据库SQLite,也提供了不少操作数据库的API,然而不是所有程序员都擅长编写SQL语句,这时一个ORM的数据库框架就显得很好用了。 在之前的博客我已经提到了LitePal的使用,但是实际开发...
  • 由上一篇博文( 强大的数据库ORM框架-GreenDao项目构建篇)可知,无论通过哪一种方式我们都可以比较容易的构建出GreenDao项目,并且成功生成相关的数据库管理文件,但是这些源码文件都各有什么作用,我们该如何去使用...
  • 一、GitHub简介: GitHub地址:https://github.com/greenrobot/greenDAO greenDAO greenDAO is a light & fast ORM solution for Android that maps objects...
  • 一、背景知识 ORM(Object Relation Mapping):对象关系模型。用于实现面向对象编程语言里不同类型系统的数据之间的转换。从效果上说,它其实是创建了一个...ORM作为项目中间件形式实现数据在不同场景下数据关系映

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,589
精华内容 635
关键字:

数据持久化框架greendao