GreenDao的简单封装

一.GreenDao简介

最近在写数据库的框架，用的是SQLite原生语言进行封装的，感觉非常的繁琐，效率也低，所以就来参考下GreenDao的做法，学习一下他的用法，给他简单封装，
便于后续的使用。

GreenDAO是一个开源的安卓ORM框架，能够使SQLite数据库的开发再次变得有趣。它减轻开发人员处理低级数据库需求，同时节省开发时间。 SQLite是一个令人敬畏的内嵌的关系数据库，编写SQL和解析查询结果是相当乏味和耗时的任务。通过将Java对象映射到数据库表（称为ORM，“对象/关系映射”），GreenDAO可以将它们从这些映射中释放出来，这样，您可以使用简单的面向对象的API来存储，更新，删除和查询数据库。
简单的讲，GreenDAO 是一个将对象映射到 SQLite 数据库中的轻量且快速的 ORM 解决方案。

二.ORM简介

对象-关系映射（OBJECT/RELATIONALMAPPING，简称ORM），是随着面向对象的软件开发方法发展而产生的。用来把对象模型表示的对象映射到基于SQL的关系模型数据库结构中去。这样，我们在具体的操作实体对象的时候，就不需要再去和复杂的 SQL 语句打交道，只需简单的操作实体对象的属性和方法。ORM 技术是在对象和关系之间提供了一条桥梁，前台的对象型数据和数据库中的关系型的数据通过这个桥梁来相互转化。
简单的讲，就是JavaBean和我们的数据库进行一个关系映射，一个实例对象对应数据库的一条记录，每个对象的属性则对应着数据库表的字段。

三.GreenDao的使用

先来看看效果图

一.GreenDao的配置

1.在项目的build.gradle里添加依赖

buildscript {
    repositories {
        jcenter()
        google()
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:3.1.0'
        classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2'
       // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

2.配置app的build.gradle

①添加greendao插件

apply plugin: 'org.greenrobot.greendao'

②配置生成的数据库版本号和生成的文件的路径

greendao {
    schemaVersion 1  //版本
    daoPackage '包名.生成的文件夹名' // 一般为app包名+生成文件的文件夹名,例com.example.greendao.dao
    targetGenDir 'src/main/java' //生成文件路径
}

③添加依赖

//greendao
    implementation 'org.greenrobot:greendao:3.2.2'
    implementation 'org.greenrobot:greendao-generator:3.2.2'

二.GreenDao文件的生成

1.dao实体类的写法

@Entity
public class DBbean {
    @Id
    private Long id;
    @Property(nameInDb = "date")
    private String date;
    @Generated(hash = 738726528)
    public DBbean(Long id, String date) {
        this.id = id;
        this.date = date;
    }
    @Generated(hash = 758483710)
    public DBbean() {
    }
    public Long getId() {
        return this.id;
    }
    public void setId(Long id) {
        this.id = id;
    }
    public String getDate() {
        return this.date;
    }
    public void setDate(String date) {
        this.date = date;
    }
    @Override
    public String toString() {
        return "id="+id+" date="+date;
    }
}

• @Entity：告诉GreenDao该对象为实体，只有被@Entity注释的Bean类才能被dao类操作

• @Id：对象的Id，使用Long类型作为EntityId，否则会报错。(autoincrement = true)表示主键会自增，如果false就会使用旧值

• @Property(nameInDb = “”)表示该属性将作为表的一个字段,其中nameInDb属性值是在数据库中对应的字段名称,可以自定义字段名,例如可以定一个跟实体对象字段不一样的字段名

• @NotNull：属性不能为空

• @Transient：使用该注释的属性不会被存入数据库的字段中

• @Unique：该属性值必须在数据库中是唯一值

• @Generated：编译后自动生成的构造函数、方法等的注释，提示构造函数、方法等不能被修改

2.生成Dao类文件

我们点击make project后greenDao的插件会在我们刚才配置的路径下自动生成三个类文件：DBbeanDao，DaoMaster,DaoSession,以后数据库操作都会用到这三个类。

四.GreenDao的简单封装

1.GreenDao管理类的封装

网上也有很多类似的GreenDao的管理，用于数据库的增删改查，我这里简单做个封装，增强它的扩展性。

package com.lcp.library.db;

import org.greenrobot.greendao.AbstractDao;
import org.greenrobot.greendao.query.LazyList;
import org.greenrobot.greendao.query.WhereCondition;

import java.util.List;

/**
 * Created by lcp on 2018/6/17.
 */
public class GreendaoManager<T,D extends AbstractDao<T,Long>> {

    private D dao;

    public GreendaoManager(D dao) {
        this.dao = dao;
    }

    /**
     * 增或者替换（有的话就替换，没有则增）
     */
    public void insertOrReplace(T bean) {
        dao.insertOrReplace(bean);
    }


    /**
     * 删
     *
     * @param i 删除数据的id
     */
    public void delete(long i) {
        dao.deleteByKey(i);
        //当然Greendao还提供了其他的删除方法，只是传值不同而已
    }

    /**
     * 删除所有
     */
    public void deleteAll() {
        dao.deleteAll();
    }


    /**
     * 改
     *
     * @param
     */
    public void correct(T bean) {
        dao.update(bean);
    }


    /**
     * 查找符合某一条件的所有元素
     */
    public List searchEveryWhere(WhereCondition condition) {
        LazyList DBbeans = dao.queryBuilder().where(condition).listLazy();
        return DBbeans;
    }

 /**
     * 查询所有数据
     *
     * @param
     * @return
     */
    public List queryAll() {
        //惰性
        LazyList DBbeans = dao.queryBuilder().listLazy();
        return DBbeans;
    }
}

1. 我这里有考虑过把它做成单例对象，然后通过构造传入Dao对象，对不同的Dao对象赋值，后面想想单例的对象只会创建一次，即最初的那次，所以传入的Dao对象也是最初的，我们要的是能给每个Dao对象进行操作，这样显然不符合要求
2. 我又有了一个想法，写成单例，不用构造方法传参，直接用另写一个方法A传参，这样又会有问题，对于调用者来说不知道初始化一定要调用那个A方法，所以，调用其他的函数的时候会报空指针（因为其他函数引用了dao这个对象）
3. 于是我就取消了单例的方法，采取构造方法传参的形式

2.定义一个MyApplication用于GreenDao的初始化操作

package com.example.administrator.rxjavaretrofitmvp.app;

import android.app.Application;
import android.database.sqlite.SQLiteDatabase;

import com.example.administrator.rxjavaretrofitmvp.greendao.dao.DaoMaster;
import com.example.administrator.rxjavaretrofitmvp.greendao.dao.DaoSession;

/**
 * Created by lcp on 2018/6/17.
 */
public class MyApplication extends Application {

    public static MyApplication instance=null;
    private DaoMaster.DevOpenHelper mHelper;
    private SQLiteDatabase db;
    private DaoMaster mDaoMaster;
    private DaoSession mDaoSession;

    @Override
    public void onCreate() {
        super.onCreate();
        instance=this;
        setDataBase();
    }


    public static MyApplication getInstances(){
        return instance;
    }

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

• 初始化数据库
• 把DaoSession写在单例的Application里，以后调用的时候就不需要new了

3.封装的使用

package com.lcp.lcplib.ui;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;

import com.lcp.lcplib.Entity.DBbean;
import com.lcp.lcplib.R;
import com.lcp.lcplib.app.MyApplication;
import com.lcp.lcplib.greendao.dao.DBbeanDao;
import com.lcp.lcplibrary.mvp.db.GreendaoManager;

import org.greenrobot.greendao.query.WhereCondition;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;


public class DbActivity extends Activity {

    private Long id=0L;
    private TextView txt;
    private GreendaoManager greendaoManager;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_db);
        txt = findViewById(R.id.txt);
        //得到Dao对象
        DBbeanDao dBbeanDao = MyApplication.getInstances().getDaoSession().getDBbeanDao();
        //得到该Dao对象的管理器（如果你本地就一张表,GreendaoManager可以写成单例,通过构造方法传参，如果多张表不建议写成单例）
        greendaoManager = new GreendaoManager<>(dBbeanDao);


        //增
        findViewById(R.id.button).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                id++;
                Date date = new Date();
                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String strdate = format.format(date);
                DBbean dBbean = new DBbean(id, strdate);
                DbActivity.this.greendaoManager.insertOrReplace(dBbean);
            }
        });


        //删
        findViewById(R.id.button2).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                DbActivity.this.greendaoManager.delete(id);
                id--;
            }
        });


        //改
        findViewById(R.id.button3).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Date date = new Date();
                SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String strdate = format.format(date);
                DBbean dBbean = new DBbean(id, strdate);
                DbActivity.this.greendaoManager.correct(dBbean);
            }
        });


        //查询所有
        findViewById(R.id.button4).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                List dBbeans = DbActivity.this.greendaoManager.queryAll();
                StringBuffer stringBuffer=new StringBuffer();
                for (int i=0;i
                {
                    DBbean dBbean = (DBbean) dBbeans.get(i);
                    String s = dBbean.toString();
                    stringBuffer.append(s+"\n");
                }
                txt.setText(stringBuffer.toString());
            }
        });

        //删除所有
        findViewById(R.id.button5).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                DbActivity.this.greendaoManager.deleteAll();
            }
        });


        //查询包含某一数据的记录
        findViewById(R.id.button6).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                WhereCondition condition = DBbeanDao.Properties.Id.eq(id);
                List dBbeans = DbActivity.this.greendaoManager.searchEveryWhere(condition);
                StringBuffer stringBuffer=new StringBuffer();
                for (int i=0;i
                {
                    DBbean dBbean = dBbeans.get(i);
                    String s = dBbean.toString();
                    stringBuffer.append(s+"\n");
                }
                txt.setText(stringBuffer.toString());
            }
        });
    }
}

1. 可以通过MyApplication拿到DaoSession对象，在拿到你的Dao对象，如果你本地有多个实体类，Make Project会生成多个dao对象，一个实体类就是一张表
2. 拿到你想操作的表的Dao对象（如果你本地有多张表的时候）
3. 在传入GreenDaoManager管理器，生成对象
4. 通过对象进行增删改查操作

总结

以上就是我对GreenDao的简单封装，当你本地有多张表的时候使用起来就非常方便了，扩展性很强，有知道还可以在优化的小伙伴欢迎私信我~
最后附上源码