目錄
一膘魄、簡介
二昙读、環(huán)境搭建
三召调、使用準(zhǔn)備
四、簡單使用示例
五蛮浑、二次封裝（重點）
六唠叛、GreenDao的常用注解
一、簡介
- greenDAO 是一個將對象映射到 SQLite 數(shù)據(jù)庫中的輕量且快速的 ORM 解決方案沮稚，GreenDao特點：
- 性能最大化艺沼，可能是Android平臺上最快的ORM框架
- 易于使用的API
- 最小的內(nèi)存開銷
- 依賴體積小
- 支持?jǐn)?shù)據(jù)庫加密
- 強(qiáng)大的社區(qū)支持
- Github地址
二、環(huán)境搭建
- 在根目錄的 build.gradle 添加
buildscript {
repositories {
jcenter()
// 添加倉庫
mavenCentral()
}
dependencies {
classpath 'com.android.tools.build:gradle:3.2.1'
// 添加插件
classpath 'org.greenrobot:greendao-gradle-plugin:3.2.2'
}
}
- 在app的 build.gradle 添加
apply plugin: 'com.android.application'
apply plugin: 'org.greenrobot.greendao' // 應(yīng)用插件
dependencies {
implementation 'org.greenrobot:greendao:3.2.2' // 添加依賴
}
- GreenDao 3 采用注解的方式來定義實體類蕴掏，可按如下設(shè)置生成文件的目錄障般，在app的 build.gradle 添加
greendao {
// 指定數(shù)據(jù)庫schema版本號，遷移等操作會用到
schemaVersion 1
// 設(shè)置生成數(shù)據(jù)庫文件的目錄盛杰，默認(rèn)是在build中挽荡，可以將生成的文件放到我們的java目錄中
targetGenDir 'src/main/java'
// 設(shè)置生成的數(shù)據(jù)庫相關(guān)文件的包名，默認(rèn)為entity所在的包名
daoPackage 'com.shufeng.greendao.gen'
}
三即供、使用準(zhǔn)備
參照 Android框架之路——GreenDao3.2.2的使用
- 編寫實體類
package com.shufeng.greendaotest.bean;
import org.greenrobot.greendao.annotation.Entity;
import org.greenrobot.greendao.annotation.Id;
import org.greenrobot.greendao.annotation.NotNull;
import org.greenrobot.greendao.annotation.Generated;
@Entity
public class Meizi
{
@Id(autoincrement = true)
private Long _id;
private String source;
@NotNull
private String url;
}
-
點擊MakeProject后定拟，就能看到實體類生成的代碼及其他生成的文件
屏幕快照 2019-01-05 下午3.49.35.png 編寫DaoManager
package com.shufeng.greendaotest.database;
import android.content.Context;
import com.shufeng.greendao.gen.DaoMaster;
import com.shufeng.greendao.gen.DaoSession;
import com.shufeng.greendaotest.BuildConfig;
import org.greenrobot.greendao.query.QueryBuilder;
/**
* 創(chuàng)建數(shù)據(jù)庫、創(chuàng)建數(shù)據(jù)庫表逗嫡、包含增刪改查的操作以及數(shù)據(jù)庫的升級
* Created by Mr.sorrow on 2017/5/5.
*/
public class DaoManager
{
private static final String TAG = DaoManager.class.getSimpleName();
private static final String DB_NAME = "greendaotest";
private Context context;
//多線程中要被共享的使用volatile關(guān)鍵字修飾
private volatile static DaoManager manager = new DaoManager();
private static DaoMaster sDaoMaster;
private static DaoMaster.DevOpenHelper sHelper;
private static DaoSession sDaoSession;
/**
* 單例模式獲得操作數(shù)據(jù)庫對象
*
* @return
*/
public static DaoManager getInstance()
{
return manager;
}
private DaoManager()
{
setDebug();
}
public void init(Context context)
{
this.context = context;
}
/**
* 判斷是否有存在數(shù)據(jù)庫青自，如果沒有則創(chuàng)建
*
* @return
*/
public DaoMaster getDaoMaster()
{
if (sDaoMaster == null)
{
DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(context, DB_NAME, null);
sDaoMaster = new DaoMaster(helper.getWritableDatabase());
}
return sDaoMaster;
}
/**
* 完成對數(shù)據(jù)庫的添加株依、刪除、修改性穿、查詢操作，僅僅是一個接口
*
* @return
*/
public DaoSession getDaoSession()
{
if (sDaoSession == null)
{
if (sDaoMaster == null)
{
sDaoMaster = getDaoMaster();
}
sDaoSession = sDaoMaster.newSession();
}
return sDaoSession;
}
/**
* 打開輸出日志雷滚，默認(rèn)關(guān)閉
*/
public void setDebug()
{
if (BuildConfig.DEBUG)
{
QueryBuilder.LOG_SQL = true;
QueryBuilder.LOG_VALUES = true;
}
}
/**
* 關(guān)閉所有的操作需曾，數(shù)據(jù)庫開啟后，使用完畢要關(guān)閉
*/
public void closeConnection()
{
closeHelper();
closeDaoSession();
}
public void closeHelper()
{
if (sHelper != null)
{
sHelper.close();
sHelper = null;
}
}
public void closeDaoSession()
{
if (sDaoSession != null)
{
sDaoSession.clear();
sDaoSession = null;
}
}
}
- 編寫Application祈远，并初始化 DaoManager
package com.shufeng.greendaotest;
import android.app.Application;
import com.shufeng.greendaotest.database.DaoManager;
public class MyApplication extends Application
{
@Override
public void onCreate()
{
super.onCreate();
initGreenDao();
}
private void initGreenDao()
{
DaoManager mManager = DaoManager.getInstance();
mManager.init(this);
}
}
注意在AndroidManifest.xml的application中添加
android:name=".MyApplication"
- 編寫MeiziDaoUtils
package com.shufeng.greendaotest.database;
import android.content.Context;
import android.util.Log;
import com.shufeng.greendao.gen.MeiziDao;
import com.shufeng.greendaotest.bean.Meizi;
import org.greenrobot.greendao.query.QueryBuilder;
import java.util.List;
public class MeiziDaoUtils
{
private static final String TAG = MeiziDaoUtils.class.getSimpleName();
private DaoManager mManager;
public MeiziDaoUtils(Context context){
mManager = DaoManager.getInstance();
mManager.init(context);
}
/**
* 完成meizi記錄的插入呆万，如果表未創(chuàng)建，先創(chuàng)建Meizi表
* @param meizi
* @return
*/
public boolean insertMeizi(Meizi meizi){
boolean flag = false;
flag = mManager.getDaoSession().getMeiziDao().insert(meizi) == -1 ? false : true;
Log.i(TAG, "insert Meizi :" + flag + "-->" + meizi.toString());
return flag;
}
/**
* 插入多條數(shù)據(jù)车份，在子線程操作
* @param meiziList
* @return
*/
public boolean insertMultMeizi(final List<Meizi> meiziList) {
boolean flag = false;
try {
mManager.getDaoSession().runInTx(new Runnable() {
@Override
public void run() {
for (Meizi meizi : meiziList) {
mManager.getDaoSession().insertOrReplace(meizi);
}
}
});
flag = true;
} catch (Exception e) {
e.printStackTrace();
}
return flag;
}
/**
* 修改一條數(shù)據(jù)
* @param meizi
* @return
*/
public boolean updateMeizi(Meizi meizi){
boolean flag = false;
try {
mManager.getDaoSession().update(meizi);
flag = true;
}catch (Exception e){
e.printStackTrace();
}
return flag;
}
/**
* 刪除單條記錄
* @param meizi
* @return
*/
public boolean deleteMeizi(Meizi meizi){
boolean flag = false;
try {
//按照id刪除
mManager.getDaoSession().delete(meizi);
flag = true;
}catch (Exception e){
e.printStackTrace();
}
return flag;
}
/**
* 刪除所有記錄
* @return
*/
public boolean deleteAll(){
boolean flag = false;
try {
//按照id刪除
mManager.getDaoSession().deleteAll(Meizi.class);
flag = true;
}catch (Exception e){
e.printStackTrace();
}
return flag;
}
/**
* 查詢所有記錄
* @return
*/
public List<Meizi> queryAllMeizi(){
return mManager.getDaoSession().loadAll(Meizi.class);
}
/**
* 根據(jù)主鍵id查詢記錄
* @param key
* @return
*/
public Meizi queryMeiziById(long key){
return mManager.getDaoSession().load(Meizi.class, key);
}
/**
* 使用native sql進(jìn)行查詢操作
*/
public List<Meizi> queryMeiziByNativeSql(String sql, String[] conditions){
return mManager.getDaoSession().queryRaw(Meizi.class, sql, conditions);
}
/**
* 使用queryBuilder進(jìn)行查詢
* @return
*/
public List<Meizi> queryMeiziByQueryBuilder(long id){
QueryBuilder<Meizi> queryBuilder = mManager.getDaoSession().queryBuilder(Meizi.class);
return queryBuilder.where(MeiziDao.Properties._id.eq(id)).list();
// return queryBuilder.where(MeiziDao.Properties._id.ge(id)).list();
}
}
四谋减、簡單使用示例
- 布局文件
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity"
android:orientation="vertical">
<Button
android:id="@+id/btn_insert_one"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="插入一個"
/>
<Button
android:id="@+id/btn_insert_many"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="插入多個"
/>
<Button
android:id="@+id/btn_alter"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="修改"
/>
<Button
android:id="@+id/btn_delete"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="刪除"
/>
<Button
android:id="@+id/btn_delete_all"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="刪除所有"
/>
<Button
android:id="@+id/btn_check_one"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="查找一個"
/>
<Button
android:id="@+id/btn_check_all"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="查找全部"
/>
<Button
android:id="@+id/btn_query_native_sql"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="使用native sql進(jìn)行條件查詢"
/>
<Button
android:id="@+id/btn_query_builder"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="使用queryBuilder進(jìn)行條件查詢"
/>
</LinearLayout>
- activity中使用
package com.shufeng.greendaotest;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import com.shufeng.greendaotest.bean.Meizi;
import com.shufeng.greendaotest.database.MeiziDaoUtils;
import java.util.ArrayList;
import java.util.List;
public class MainActivity extends AppCompatActivity implements View.OnClickListener
{
private final String TAG = MainActivity.class.getSimpleName();
MeiziDaoUtils mMeiziDaoUtils;
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findViewById(R.id.btn_insert_one).setOnClickListener(this);
findViewById(R.id.btn_insert_many).setOnClickListener(this);
findViewById(R.id.btn_alter).setOnClickListener(this);
findViewById(R.id.btn_delete).setOnClickListener(this);
findViewById(R.id.btn_delete_all).setOnClickListener(this);
findViewById(R.id.btn_check_one).setOnClickListener(this);
findViewById(R.id.btn_check_all).setOnClickListener(this);
findViewById(R.id.btn_query_native_sql).setOnClickListener(this);
findViewById(R.id.btn_query_builder).setOnClickListener(this);
mMeiziDaoUtils = new MeiziDaoUtils(this);
}
@Override
public void onClick(View view)
{
switch (view.getId())
{
case R.id.btn_insert_one:
mMeiziDaoUtils.insertMeizi(new Meizi(null, "Google",
"http://7xi8d6.48096_n.jpg"));
break;
case R.id.btn_insert_many:
List<Meizi> meiziList = new ArrayList<>();
meiziList.add(new Meizi(null, "HuaWei",
"http://7xi8d648096_n.jpg"));
meiziList.add(new Meizi(null, "Apple",
"http://7xi8d648096_n.jpg"));
meiziList.add(new Meizi(null, "MIUI",
"http://7xi8d648096_n.jpg"));
mMeiziDaoUtils.insertMultMeizi(meiziList);
break;
case R.id.btn_alter:
Meizi meizi = new Meizi();
meizi.set_id(1l);
meizi.setSource("BAIDU");
meizi.setUrl("http://baidu.jpg");
mMeiziDaoUtils.updateMeizi(meizi);
break;
case R.id.btn_delete:
Meizi meizi1 = new Meizi();
meizi1.set_id(1002l);
mMeiziDaoUtils.deleteMeizi(meizi1);
break;
case R.id.btn_delete_all:
mMeiziDaoUtils.deleteAll();
break;
case R.id.btn_check_one:
Log.i(TAG, mMeiziDaoUtils.queryMeiziById(1002l).toString());
break;
case R.id.btn_check_all:
List<Meizi> meiziList1 = mMeiziDaoUtils.queryAllMeizi();
for (Meizi meizi2 : meiziList1) {
Log.i(TAG, meizi2.toString());
}
break;
case R.id.btn_query_native_sql:
String sql = "where _id > ?";
String[] condition = new String[]{"2"};
List<Meizi> meiziList2 = mMeiziDaoUtils.queryMeiziByNativeSql(sql, condition);
for (Meizi meizi2 : meiziList2) {
Log.i(TAG, meizi2.toString());
}
break;
case R.id.btn_query_builder:
List<Meizi> meiziList3 = mMeiziDaoUtils.queryMeiziByQueryBuilder(10);
for (Meizi meizi2 : meiziList3) {
Log.i(TAG, meizi2.toString());
}
break;
}
}
}
五、二次封裝
如果實體類比較多扫沼，也即數(shù)據(jù)庫表較多出爹，但使用MeiziDaoUtils的方式編寫，則會產(chǎn)生很多相似代碼缎除，因此編寫了如下通用的DaoUtils
1严就、CommonDaoUtils
package com.shufeng.greendaotest.database;
import android.util.Log;
import com.shufeng.greendao.gen.DaoSession;
import org.greenrobot.greendao.AbstractDao;
import org.greenrobot.greendao.query.QueryBuilder;
import org.greenrobot.greendao.query.WhereCondition;
import java.util.List;
public class CommonDaoUtils<T>
{
private static final String TAG = CommonDaoUtils.class.getSimpleName();
private DaoSession daoSession;
private Class<T> entityClass;
private AbstractDao<T, Long> entityDao;
public CommonDaoUtils(Class<T> pEntityClass, AbstractDao<T, Long> pEntityDao)
{
DaoManager mManager = DaoManager.getInstance();
daoSession = mManager.getDaoSession();
entityClass = pEntityClass;
entityDao = pEntityDao;
}
/**
* 插入記錄，如果表未創(chuàng)建器罐，先創(chuàng)建表
*
* @param pEntity
* @return
*/
public boolean insert(T pEntity)
{
boolean flag = entityDao.insert(pEntity) == -1 ? false : true;
Log.i(TAG, "insert Meizi :" + flag + "-->" + pEntity.toString());
return flag;
}
/**
* 插入多條數(shù)據(jù)梢为，在子線程操作
*
* @param pEntityList
* @return
*/
public boolean insertMulti(final List<T> pEntityList)
{
try
{
daoSession.runInTx(new Runnable()
{
@Override
public void run()
{
for (T meizi : pEntityList)
{
daoSession.insertOrReplace(meizi);
}
}
});
return true;
}
catch (Exception e)
{
e.printStackTrace();
}
return false;
}
/**
* 修改一條數(shù)據(jù)
*
* @param pEntity
* @return
*/
public boolean update(T pEntity)
{
try
{
daoSession.update(pEntity);
return true;
}
catch (Exception e)
{
e.printStackTrace();
}
return false;
}
/**
* 刪除單條記錄
*
* @param pEntity
* @return
*/
public boolean delete(T pEntity)
{
try
{
//按照id刪除
daoSession.delete(pEntity);
return true;
}
catch (Exception e)
{
e.printStackTrace();
}
return false;
}
/**
* 刪除所有記錄
*
* @return
*/
public boolean deleteAll()
{
try
{
//按照id刪除
daoSession.deleteAll(entityClass);
return true;
}
catch (Exception e)
{
e.printStackTrace();
}
return false;
}
/**
* 查詢所有記錄
*
* @return
*/
public List<T> queryAll()
{
return daoSession.loadAll(entityClass);
}
/**
* 根據(jù)主鍵id查詢記錄
*
* @param key
* @return
*/
public T queryById(long key)
{
return daoSession.load(entityClass, key);
}
/**
* 使用native sql進(jìn)行查詢操作
*/
public List<T> queryByNativeSql(String sql, String[] conditions)
{
return daoSession.queryRaw(entityClass, sql, conditions);
}
/**
* 使用queryBuilder進(jìn)行查詢
*
* @return
*/
public List<T> queryByQueryBuilder(WhereCondition cond, WhereCondition... condMore)
{
QueryBuilder<T> queryBuilder = daoSession.queryBuilder(entityClass);
return queryBuilder.where(cond, condMore).list();
}
}
2、DaoUtilsStore用來存放各個DaoUtils
package com.shufeng.greendaotest.database;
import com.shufeng.greendao.gen.HanziDao;
import com.shufeng.greendao.gen.MeiziDao;
import com.shufeng.greendaotest.bean.Hanzi;
import com.shufeng.greendaotest.bean.Meizi;
/**
* 存放DaoUtils
*/
public class DaoUtilsStore
{
private volatile static DaoUtilsStore instance = new DaoUtilsStore();
private CommonDaoUtils<Meizi> meiziDaoUtils;
private CommonDaoUtils<Hanzi> hanziDaoUtils;
public static DaoUtilsStore getInstance()
{
return instance;
}
private DaoUtilsStore()
{
DaoManager mManager = DaoManager.getInstance();
MeiziDao _MeiziDao = mManager.getDaoSession().getMeiziDao();
meiziDaoUtils = new CommonDaoUtils(Meizi.class, _MeiziDao);
HanziDao _HanziDao = mManager.getDaoSession().getHanziDao();
hanziDaoUtils = new CommonDaoUtils(Hanzi.class, _HanziDao);
}
public CommonDaoUtils<Meizi> getMeiziDaoUtils()
{
return meiziDaoUtils;
}
public CommonDaoUtils<Hanzi> getHanziDaoUtils()
{
return hanziDaoUtils;
}
}
3轰坊、使用
CommonDaoUtils<Meizi> meiziDaoUtils;
DaoUtilsStore _Store = DaoUtilsStore.getInstance();
meiziDaoUtils = _Store.getMeiziDaoUtils();
六铸董、GreenDao的常用注解
實體@Entity注解
- schema：告知GreenDao當(dāng)前實體屬于哪個schema
- active：標(biāo)記一個實體處于活躍狀態(tài)，活動實體有更新肴沫、刪除和刷新方法
- nameInDb：在數(shù)據(jù)庫中使用的別名粟害，默認(rèn)使用的是實體的類名
- indexes：定義索引，可以跨越多個列
- createInDb：標(biāo)記創(chuàng)建數(shù)據(jù)庫表
基礎(chǔ)屬性注解
- @Id：主鍵 Long 型颤芬，可以通過@Id(autoincrement = true)設(shè)置自增長
- @Property：設(shè)置一個非默認(rèn)關(guān)系映射所對應(yīng)的列名我磁，默認(rèn)是使用字段名，例如：@Property(nameInDb = "name")
- @NotNull：設(shè)置數(shù)據(jù)庫表當(dāng)前列不能為空
- @Transient：添加此標(biāo)記后不會生成數(shù)據(jù)庫表的列
索引注解
- @Index：使用@Index作為一個屬性來創(chuàng)建一個索引驻襟，通過name設(shè)置索引別名夺艰，也可以通過unique給索引添加約束
- @Unique：向數(shù)據(jù)庫添加了一個唯一的約束
關(guān)系注解
- @ToOne：定義與另一個實體（一個實體對象）的關(guān)系
- @ToMany：定義與多個實體對象的關(guān)系
