本文介紹了greendao的基礎入門使用：其中包括資料庫的增刪改查，基本使用功能，簡單方便，易懂。
優勢：

1:效能最大化

2:記憶體開銷最小

3:API 簡單好用

4:對Android 高度優化

5:2.2版本以上還支援加密資料庫

6:支援protobuf協議儲存(protobuf 比json更快,google的優秀產品,因此greendao能很好地與retrofit 2.0結合protobuf網路請求並快取)


  由於現在手中的專案需要用到資料庫來儲存資料，聽說greendao現在很流行，於是就想學習一下，在網上找了很多，
  但是水平有限，好多大神寫的看不懂啊！不知道啥意思，於是就找呀找，最後，找到一篇翻譯外文的簡書，哇哦，終於學會了，不過下班了，
  現在忘記是誰寫的了，無法新增你的資訊了，不過還是要謝謝你的譯文哦！
那麼我就來總結一下，小白使用greendao的步驟吧！哈哈
歡迎大家給出建議、更好的方法和知識哦，謝謝啦！

 那好直接來吧！
 

先看效果

步驟一、在自己的build.gradle中加入這些配置

buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.greenrobot:greendao-gradle-plugin:3.2.0'
    }
}
apply plugin: 'org.greenrobot.greendao'

greendao {
    //資料庫的schema版本，也可以理解為資料庫版本號
    schemaVersion 1
    //設定DaoMaster、DaoSession、Dao包名，也就是要放置這些類的包的全路徑。
    daoPackage 'cn.hnshangyu.testgreendao.greendao'
    //設定DaoMaster、DaoSession、Dao目錄
    targetGenDir 'src/main/java'
}
dependencies {
    compile 'org.greenrobot:greendao:3.2.0'
}
 

針對於daoPackage 我的專案內容如下

步驟二、建立Student實體類

package cn.hnshangyu.testgreendao.bean;

import org.greenrobot.greendao.annotation.Entity;
import org.greenrobot.greendao.annotation.Id;
import org.greenrobot.greendao.annotation.Keep;

@Entity(generateConstructors = false)
    public class Student {  
        @Id
        private Long id;  
        private String name;
        private int age;  

        public Student() {  
        }  

        @Keep
        public Student(String name, int age) {  
            this.name = name;  
            this.age = age;  
        }  


        public Student(Long id, String name, int age) {  
            this.id = id;  
            this.name = name;  
            this.age = age;  
        }  

        @Keep  
        public Long getId() {  
            return id;  
        }  

        @Keep  
        public void setId(Long id) {  
            this.id = id;  
        }  

        @Keep  
        public String getName() {  
            return name;  
        }  

        @Keep  
        public void setName(String name) {  
            this.name = name;  
        }  

        @Keep  
        public int getAge() {  
            return age;  
        }  

        @Keep  
        public void setAge(int age) {  
            this.age = age;  
        }  

        @Keep  
        @Override  
        public boolean equals(Object o) {  
            if (this == o) return true;  
            if (!(o instanceof Student)) return false;  

            Student student = (Student) o;  

            return name.equals(student.name);  

        }  

        @Keep  
        @Override  
        public int hashCode() {  
            return (int) (id ^ (id >>> 32));  
        }  

        @Keep  
        @Override  
        public String toString() {  
            return "Student{" +  
                    "id=" + id +  
                    ", name='" + name + '\'' +  
                    ", age=" + age +  
                    '}';  
        }  
    }  
 

步驟三、修復一下工程，自動生成greendao包下的類（就是點選一下小錘子），你會自動生成上圖中greendao包中的類。

步驟四、開始使用，建立管理類

package cn.hnshangyu.testgreendao.db;

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

import cn.hnshangyu.testgreendao.greendao.DaoMaster;
import cn.hnshangyu.testgreendao.greendao.DaoSession;

public class DbManager {

    // 是否加密
    public static final boolean ENCRYPTED = true;

    private static final String DB_NAME = "test.db";
    private static DbManager mDbManager;
    private static DaoMaster.DevOpenHelper mDevOpenHelper;
    private static DaoMaster mDaoMaster;
    private static DaoSession mDaoSession;

    private Context mContext;

    private DbManager(Context context) {
        this.mContext = context;
        // 初始化資料庫資訊
        mDevOpenHelper = new DaoMaster.DevOpenHelper(context, DB_NAME);
        getDaoMaster(context);
        getDaoSession(context);
    }

    public static DbManager getInstance(Context context) {
        if (null == mDbManager) {
            synchronized (DbManager.class) {
                if (null == mDbManager) {
                    mDbManager = new DbManager(context);
                }
            }
        }
        return mDbManager;
    }

    /**
     * 獲取可讀資料庫
     *
     * @param context
     * @return
     */
    public static SQLiteDatabase getReadableDatabase(Context context) {
        if (null == mDevOpenHelper) {
            getInstance(context);
        }
        return mDevOpenHelper.getReadableDatabase();
    }

    /**
     * 獲取可寫資料庫
     *
     * @param context
     * @return
     */
    public static SQLiteDatabase getWritableDatabase(Context context) {
        if (null == mDevOpenHelper) {
            getInstance(context);
        }

        return mDevOpenHelper.getWritableDatabase();
    }

    /**
     * 獲取DaoMaster
     *
     * @param context
     * @return
     */
    public static DaoMaster getDaoMaster(Context context) {
        if (null == mDaoMaster) {
            synchronized (DbManager.class) {
                if (null == mDaoMaster) {
                    mDaoMaster = new DaoMaster(getWritableDatabase(context));
                }
            }
        }
        return mDaoMaster;
    }

    /**
     * 獲取DaoSession
     *
     * @param context
     * @return
     */
    public static DaoSession getDaoSession(Context context) {
        if (null == mDaoSession) {
            synchronized (DbManager.class) {
                mDaoSession = getDaoMaster(context).newSession();
            }
        }

        return mDaoSession;
    }
}

步驟五、增刪改查，

package cn.hnshangyu.testgreendao.db;

import android.content.Context;

import org.greenrobot.greendao.query.QueryBuilder;

import java.util.List;

import cn.hnshangyu.testgreendao.bean.Student;

public class StudentDaoOpe {

    /**
     * 新增資料至資料庫
     *
     * @param context
     * @param stu
     */
    public static void insertData(Context context, Student stu) {

        DbManager.getDaoSession(context).getStudentDao().insert(stu);
    }


    /**
     * 將資料實體通過事務新增至資料庫
     *
     * @param context
     * @param list
     */
    public static void insertData(Context context, List<Student> list) {
        if (null == list || list.size() <= 0) {
            return;
        }
        DbManager.getDaoSession(context).getStudentDao().insertInTx(list);
    }

    /**
     * 新增資料至資料庫，如果存在，將原來的資料覆蓋
     * 內部程式碼判斷了如果存在就update(entity);不存在就insert(entity)；
     *
     * @param context
     * @param student
     */
    public static void saveData(Context context, Student student) {
        DbManager.getDaoSession(context).getStudentDao().save(student);
    }

    /**
     * 刪除資料至資料庫
     *
     * @param context
     * @param student 刪除具體內容
     */
    public static void deleteData(Context context, Student student) {
        DbManager.getDaoSession(context).getStudentDao().delete(student);
    }

    /**
     * 根據id刪除資料至資料庫
     *
     * @param context
     * @param id      刪除具體內容
     */
    public static void deleteByKeyData(Context context, long id) {
        DbManager.getDaoSession(context).getStudentDao().deleteByKey(id);
    }

    /**
     * 刪除全部資料
     *
     * @param context
     */
    public static void deleteAllData(Context context) {
        DbManager.getDaoSession(context).getStudentDao().deleteAll();
    }

    /**
     * 更新資料庫
     *
     * @param context
     * @param student
     */
    public static void updateData(Context context, Student student) {
        DbManager.getDaoSession(context).getStudentDao().update(student);
    }

    /**
     * 查詢所有資料
     *
     * @param context
     * @return
     */
    public static List<Student> queryAll(Context context) {
        QueryBuilder<Student> builder = DbManager.getDaoSession(context).getStudentDao().queryBuilder();

        return builder.build().list();
    }

/**
     * 根據id，其他的欄位類似
     *
     * @param context
     * @param id
     * @return
     */
    public static List<Student> queryForId(Context context, long id) {
        QueryBuilder<Student> builder = DbManager.getDaoSession(context).getStudentDao().queryBuilder();
        /**
         * 返回當前id的資料集合,當然where(這裡面可以有多組，做為條件);
         * 這裡build.list()；與where(StudentDao.Properties.Id.eq(id)).list()結果是一樣的；
         * 在QueryBuilder類中list()方法return build().list();
         *
         */
        // Query<Student> build = builder.where(StudentDao.Properties.Id.eq(id)).build();
        // List<Student> list = build.list();
        return builder.where(StudentDao.Properties.Id.eq(id)).list();
    }
}

步驟六、mainactivity佈局

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context="cn.hnshangyu.testgreendao.MainActivity">

    <LinearLayout
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:orientation="horizontal">

        <Button
            android:id="@+id/add"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="增" />

        <Button
            android:id="@+id/delete"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="刪" />

        <Button
            android:id="@+id/updata"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="改" />

        <Button
            android:id="@+id/check"
            android:layout_width="0dp"
            android:layout_height="wrap_content"
            android:layout_weight="1"
            android:text="查" />


    </LinearLayout>

    <Button
        android:id="@+id/deleteAll"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerInParent="true"
        android:layout_weight="1"
        android:text="刪除全部" />

    <Button
        android:id="@+id/check_id"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_above="@id/deleteAll"
        android:layout_centerInParent="true"
        android:text="根據id查" />

</RelativeLayout>

步驟七、mainActivity

package cn.hnshangyu.testgreendao;

import android.content.Context;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.Button;

import java.util.ArrayList;
import java.util.List;

import butterknife.ButterKnife;
import butterknife.InjectView;
import cn.hnshangyu.testgreendao.bean.Student;
import cn.hnshangyu.testgreendao.db.StudentDaoOpe;

public class MainActivity extends AppCompatActivity {

    @InjectView(R.id.add)
    Button add;
    @InjectView(R.id.delete)
    Button delete;
    @InjectView(R.id.updata)
    Button updata;
    @InjectView(R.id.check)
    Button check;
    @InjectView(R.id.deleteAll)
    Button deleteAll;
    @InjectView(R.id.check_id)
    Button checkId;

    private Context mContext;
    private Student student;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ButterKnife.inject(this);
        mContext = this;
        initData();
        initListener();

    }

    private List<Student> studentList = new ArrayList<>();

    /**
     * 初始化資料
     */
    private void initData() {
        for (int i = 0; i < 100; i++) {
            student = new Student((long) i, "huang" + i, 25);
            studentList.add(student);
        }

    }

    private void initListener() {
        /**
         *增
         */
        add.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                StudentDaoOpe.insertData(mContext, studentList);
            }
        });
        /**
         * 刪
         */
        delete.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Student student = new Student((long) 5, "haung" + 5, 25);
                /**
                 * 根據特定的物件刪除
                 */
                StudentDaoOpe.deleteData(mContext, student);
                /**
                 * 根據主鍵刪除
                 */
                StudentDaoOpe.deleteByKeyData(mContext, 7);
            }
        });
        /**
         *刪除所有
         */
        deleteAll.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                StudentDaoOpe.deleteAllData(mContext);
            }
        });
        /**
         * 更新
         */
        updata.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Student student = new Student((long) 2, "haungxiaoguo", 16516);
                StudentDaoOpe.updateData(mContext, student);
            }
        });
        /**
         * 查詢全部
         */
        check.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                List<Student> students = StudentDaoOpe.queryAll(mContext);
                for (int i = 0; i < students.size(); i++) {
                    Log.i("Log", students.get(i).getName());
                }
            }
        });
        /**
         * 根據id查詢
         */
        checkId.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                List<Student> students = StudentDaoOpe.queryForId(mContext, 50);
                for (int i = 0; i < students.size(); i++) {
                    Log.i("Log", students.get(i).getName());
                }
            }
        });
    }
}

下面就是效果了

點選“增”->“查”出現

點選“刪”->“查”出現

huang5與huang7被刪除了

點選“改”->“查”出現

huang2被修改成huangxiaoguo了

點選“根據ID查”

查詢結果只有huang50

greendao中的註解

(一) @Entity 定義實體
@nameInDb 在資料庫中的名字，如不寫則為實體中類名
@indexes 索引
@createInDb 是否建立表，預設為true,false時不建立
@schema 指定架構名稱為實體
@active 無論是更新生成都重新整理
(二) @Id
(三) @NotNull 不為null
(四) @Unique 唯一約束
(五) @ToMany 一對多
(六) @OrderBy 排序
(七) @ToOne 一對一
(八) @Transient 不儲存在資料庫中
(九) @generated 由greendao產生的建構函式或方法

這樣以後用著就方便了，哈哈哈~~~

Greendao的模糊查詢需要對傳人的值前後加”%”，如：”%”+value+”%”；

Greendao模糊查詢like方法的使用：like(“%你想匹配的%”);

1、例如：

QueryBuilder<Shops> qb = words_Dao.queryBuilder();
qb.where(Properties.Shops_id.like("%"+"你需要搜的"+"%"));

2、分頁載入：

   /**
     * 查詢所有資料
     *  分頁載入
     * @param context
     * @param pageSize 當前第幾頁
     * @param pageNum  每頁顯示多少個
     * @return
     */
    public static List<BaseRecordStation> queryAll(Context context, int pageSize, int pageNum) {
        QueryBuilder<BaseRecordStation> builder = DbManager.getDaoSession(context, DB_NAME).getBaseRecordStationDao().queryBuilder();
        List<BaseRecordStation> list = builder
                .offset(pageSize - 1)//從0開始的
                .limit(pageNum)
                .orderDesc(BaseRecordStationDao.Properties.Id)
                .build()
                .list();
        return list;
    }