GreenDao的实用封装

前面简单介绍了下GreenDao的使用，从前面的介绍看来是不是觉得有点 so easy。对就是这么简单。曾经有位大神说作为一位合格的程序员就要在学习别人的东西时，有点自己的想法。为了表示我是位比较合格的程序员，今天和大家介绍下GreenDao的比较实用的封装。如果您还没来得及学习greenDao的实用详解，请前往GreenDao的使用详解学习。长话短说我们正式开始介绍。首先我们新建两个表，分别是Customer和Student表。其生成的文件如下所示。



(一)封装下DaoMaster,DaoSession,DevOpenHelper对象

其具体代码如DaoManager.java所示。

package com.jamy.DaoUtils;

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

import com.jamy.dao.DaoMaster;
import com.jamy.dao.DaoSession;

import de.greenrobot.dao.query.QueryBuilder;

/**
* Created by jamy on 2016/6/16.
* 进行数据库的管理
* 1.创建数据库
* 2.创建数据库表
* 3.对数据库进行增删查改
* 4.对数据库进行升级
*/
public class DaoManager {
private static  final String   TAG = DaoManager.class.getSimpleName();
private static  final String  DB_NAME="jamy.db";//数据库名称
private volatile  static DaoManager mDaoManager;//多线程访问
private  static DaoMaster.DevOpenHelper mHelper;
private static  DaoMaster mDaoMaster;
private static DaoSession mDaoSession;
private static SQLiteDatabase db;
private Context context;

/**
* 使用单例模式获得操作数据库的对象
* @return
*/
public  static DaoManager getInstance(){
DaoManager instance = null;
if (mDaoManager==null){
synchronized (DaoManager.class){
if (instance==null){
instance = new DaoManager();
mDaoManager = instance;
}
}
}
return mDaoManager;
}

/**
* 初始化Context对象
* @param context
*/
public void init(Context context){
this.context = context;
}

/**
* 判断数据库是否存在，如果不存在则创建
* @return
*/
public DaoMaster getDaoMaster(){
if (null == mDaoMaster){
mHelper =  new DaoMaster.DevOpenHelper(context,DB_NAME,null);
mDaoMaster = new DaoMaster(mHelper.getWritableDatabase());
}
return mDaoMaster;
}

/**
* 完成对数据库的增删查找
* @return
*/
public DaoSession getDaoSession(){
if (null == mDaoSession){
if (null == mDaoMaster){
mDaoMaster = getDaoMaster();
}
mDaoSession = mDaoMaster.newSession();
}
return mDaoSession;
}

/**
* 设置debug模式开启或关闭，默认关闭
* @param flag
*/
public void setDebug(boolean flag){
QueryBuilder.LOG_SQL = flag;
QueryBuilder.LOG_VALUES = flag;
}

/**
* 关闭数据库
*/
public void closeDataBase(){
closeHelper();
closeDaoSession();
}

public void closeDaoSession(){
if (null != mDaoSession){
mDaoSession.clear();
mDaoSession = null;
}
}

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

}

DaoManager主要是通过单列模式获取对应的对象，以及对所有的对象进行初始化。

(二)封装一可操作不同数据表的公共基类

其集体代码BaseDao.java所示。

package com.jamy.DaoUtils;

import android.content.Context;
import android.util.Log;
import com.jamy.dao.CustomerDao;
import com.jamy.dao.DaoSession;
import java.util.List;
import de.greenrobot.dao.query.QueryBuilder;

/**
* 将所有创建的表格相同的部分封装到这个BaseDao中
* Created by jamy on 16/6/16.
*/
public class BaseDao<T>{
public static final String TAG = BaseDao.class.getSimpleName();
public static final boolean DUBUG = true;
public DaoManager manager;
public DaoSession daoSession;

public BaseDao(Context context) {
manager = DaoManager.getInstance();
manager.init(context);
daoSession = manager.getDaoSession();
manager.setDebug(DUBUG);
}

/**************************数据库插入操作***********************/
/**
* 插入单个对象
* @param object
* @return
*/
public boolean insertObject(T object){
boolean flag = false;
try {
flag = manager.getDaoSession().insert(object) != -1 ? true:false;
} catch (Exception e) {
Log.e(TAG, e.toString());
}
return flag;
}

/**
* 插入多个对象，并开启新的线程
* @param objects
* @return
*/
public boolean insertMultObject(final List<T> objects){
boolean flag = false;
if (null == objects || objects.isEmpty()){
return false;
}
try {
manager.getDaoSession().runInTx(new Runnable() {
@Override
public void run() {
for (T object : objects) {
manager.getDaoSession().insertOrReplace(object);
}
}
});
flag = true;
} catch (Exception e) {
Log.e(TAG, e.toString());
flag = false;
}finally {
//            manager.CloseDataBase();
}
return flag;
}

/**************************数据库更新操作***********************/
/**
* 以对象形式进行数据修改
* 其中必须要知道对象的主键ID
* @param object
* @return
*/
public void  updateObject(T object){

if (null == object){
return ;
}
try {
manager.getDaoSession().update(object);
} catch (Exception e) {
Log.e(TAG, e.toString());
}
}

/**
* 批量更新数据
* @param objects
* @return
*/
public void updateMultObject(final List<T> objects, Class clss){
if (null == objects || objects.isEmpty()){
return;
}
try {

daoSession.getDao(clss).updateInTx(new Runnable() {
@Override
public void run() {
for(T object:objects){
daoSession.update(object);
}
}
});
} catch (Exception e) {
Log.e(TAG, e.toString());
}
}

/**************************数据库删除操作***********************/
/**
* 删除某个数据库表
* @param clss
* @return
*/
public boolean deleteAll(Class clss){
boolean flag = false;
try {
manager.getDaoSession().deleteAll(clss);
flag = true;
} catch (Exception e) {
Log.e(TAG, e.toString());
flag = false;
}
return flag;
}

/**
* 删除某个对象
* @param object
* @return
*/
public void deleteObject(T object){
try {
daoSession.delete(object);
} catch (Exception e) {
Log.e(TAG, e.toString());
}
}

/**
* 异步批量删除数据
* @param objects
* @return
*/
public boolean deleteMultObject(final List<T> objects, Class clss){
boolean flag = false;
if (null == objects || objects.isEmpty()){
return false;
}
try {

daoSession.getDao(clss).deleteInTx(new Runnable() {
@Override
public void run() {
for(T object:objects){
daoSession.delete(object);
}
}
});
flag = true;
} catch (Exception e) {
Log.e(TAG, e.toString());
flag = false;
}
return flag;
}

/**************************数据库查询操作***********************/

/**
* 获得某个表名
* @return
*/
public String getTablename(Class object){
return daoSession.getDao(object).getTablename();
}

/**
* 查询某个ID的对象是否存在
* @param
* @return
*/
public boolean isExitObject(long id,Class object){
QueryBuilder<T> qb = (QueryBuilder<T>) daoSession.getDao(object).queryBuilder();
qb.where(CustomerDao.Properties.Id.eq(id));
long length = qb.buildCount().count();
return length>0 ? true:false;
}

/**
* 根据主键ID来查询
* @param id
* @return
*/
public T QueryById(long id,Class object){
return (T) daoSession.getDao(object).loadByRowId(id);
}

/**
* 查询某条件下的对象
* @param object
* @return
*/
public List<T> QueryObject(Class object,String where,String...params){
Object obj = null;
List<T> objects = null;
try {
obj = daoSession.getDao(object);
if (null == obj){
return null;
}
objects = daoSession.getDao(object).queryRaw(where,params);
} catch (Exception e) {
Log.e(TAG, e.toString());
}

return objects;
}
/**
* 查询所有对象
* @param object
* @return
*/
public List<T> QueryAll(Class object){
List<T> objects = null;
try {
objects = (List<T>) daoSession.getDao(object).loadAll();
} catch (Exception e) {
Log.e(TAG,e.toString());
}
return objects;
}

/***************************关闭数据库*************************/
/**
* 关闭数据库一般在Odestory中使用
*/
public void CloseDataBase(){
manager.closeDataBase();
}

}

(三)让不同的数据表对象继承BaseDao

其具体代码如StudentManager.java以及CustomerManager.java所示(由于本Demo中这两个Manager比较类似，所以只展示StudentManager.java)。

package com.jamy.DaoUtils;

import android.content.Context;

import com.jamy.dao.CustomerDao;
import com.jamy.entity.Customer;
import com.jamy.entity.Student;

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

import de.greenrobot.dao.query.QueryBuilder;

/**
* Created by jamy on 16/6/16.
* 在这个类中添加不同的查询条件
*/
public class StudentManager extends BaseDao<Student>{
public StudentManager(Context context) {
super(context);
}

/***************************数据库查询*************************/

/**
* 通过ID查询对象
* @param id
* @return
*/
private Student loadById(long id){

return daoSession.getStudentDao().load(id);
}

/**
* 获取某个对象的主键ID
* @param student
* @return
*/
private long getID(Student student){

return daoSession.getStudentDao().getKey(student);
}

/**
* 通过名字获取Customer对象
* @return
*/
private List<Student> getStudentByName(String key){
QueryBuilder queryBuilder =  daoSession.getStudentDao().queryBuilder();
queryBuilder.where(CustomerDao.Properties.Name.eq(key));
int size = queryBuilder.list().size();
if (size > 0){
return queryBuilder.list();
}else{
return null;
}
}

/**
* 通过名字获取Customer对象
* @return
*/
private List<Long> getIdByName(String key){
List<Student> students = getStudentByName(key);
List<Long> ids = new ArrayList<Long>();
int size = students.size();
if (size > 0){
for (int i = 0;i < size;i++){
ids.add(students.get(i).getId());
}
return ids;
}else{
return null;
}
}

/***************************数据库删除*************************/

/**
* 根据ID进行数据库的删除操作
* @param id
*/
private void deleteById(long id){

daoSession.getStudentDao().deleteByKey(id);
}

/**
* 根据ID同步删除数据库操作
* @param ids
*/
private void deleteByIds(List<Long> ids){

daoSession.getStudentDao().deleteByKeyInTx(ids);
}

/***********************************
* 在次添加一些Student特有的数据库操作语句
* ************************************/

}

针对不同的数据表可以将一些特有的查询条件放在StudentManager类中(因为不同的数据表可能需要的查询条件不近相同)，这样方便查询。

(四)将已创建的多表Manager对象封装在一个类

其具体代码如DaoUtils.java所示。

package com.jamy.DaoUtils;

import android.content.Context;
import android.util.Log;

import com.jamy.dao.CustomerDao;
import com.jamy.dao.DaoSession;
import com.jamy.dao.StudentDao;
import com.jamy.entity.Customer;
import com.jamy.entity.Student;

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

import de.greenrobot.dao.AbstractDao;
import de.greenrobot.dao.query.QueryBuilder;

/**
* Created by jinfangmei on 2016/6/16.
*/
public class DaoUtils{
private  static CustomerManager customerManager;
private  static StudentManager studentManager;
public  static Context context;

public static void init(Context context){
DaoUtils.context = context.getApplicationContext();
}

/**
* 单列模式获取CustomerManager对象
* @return
*/
public static CustomerManager getCustomerInstance(){
if (customerManager == null) {
customerManager = new CustomerManager(context);
}
return customerManager;
}

/**
* 单列模式获取StudentManager对象
* @return
*/
public static StudentManager getStudentInstance(){
if (studentManager == null) {
studentManager = new StudentManager(context);
}
return studentManager;
}
}

上面有一点需注意，由于在DaoUtils中的Context是由static修饰，所以这里的context要用ApplicationContext(防止Activity被结束而造成内存泄漏)。

上面的一步步封装已经完成，下面在MainActivity中调用试试好不好用。哈哈。

MainActivity.java的具体代码如下所示。

package com.jamy.testgreendao;
import android.content.Context;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import com.jamy.DaoUtils.DaoUtils;
import com.jamy.entity.Customer;
import com.jamy.entity.Student;
import java.util.ArrayList;
import java.util.List;

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

private Button mAddButton;
public Button mDeleteButton,mUpdateButton,mQueryButton;
private List<Object> students;
private List<Customer> customers;
private Context context;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
initView();
DaoUtils.init(MainActivity.this);

}

private void initView() {
customers = new ArrayList<Customer>();
students  = new ArrayList<Object>();
mAddButton = (Button) findViewById(R.id.addbutton);
mDeleteButton = (Button) findViewById(R.id.deletebutton);
mUpdateButton = (Button) findViewById(R.id.uodatebutton);
mQueryButton = (Button) findViewById(R.id.queryButton);
mAddButton.setOnClickListener(this);
mDeleteButton.setOnClickListener(this);
mUpdateButton.setOnClickListener(this);
mQueryButton.setOnClickListener(this);

}

@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.addbutton:
for (int i=0;i<4;i++){
Student student = new Student();
student.setName("jamy");
student.setAge(110+i);
student.setDepartment("A1113"+i);
students.add(student);
}
for (int i=0;i<4;i++){
Customer customer = new Customer();
customer.setName("jin"+i);
customer.setAddress("shenzhen"+i);
customer.setType("CEO");
customers.add(customer);
}
DaoUtils.getCustomerInstance().insertMultObject(customers);
break;
case R.id.deletebutton:
DaoUtils.getCustomerInstance().deleteByIds(DaoUtils.getCustomerInstance().getIdByName("jin2"));

break;
case R.id.queryButton:
List<Customer> list = DaoUtils.getCustomerInstance().QueryAll(Customer.class);
for (int i=0;i<list.size();i++){
Customer customer = list.get(i);
Log.d("JAMY","id:"+customer.getId()+" name:"+customer.getName()
+"  Address:"+customer.getAddress()+"  Type:"+customer.getType());
}

break;
case R.id.uodatebutton:

Customer customer = new Customer();
customer.setId(1l);
customer.setName("jinfangmei");
customer.setType("CEO");
customer.setAddress("shenzhen0");
DaoUtils.getCustomerInstance().updateObject(customer);
//              if (null != customers){
//                  for (int i=0;i<customers.size();i++){
//                      Log.d("JAMY",customers.get(i).getId().toString());
//                  }
//              }
//              List<Long> ids = daoUtils.getIdByKey("jin1");
//              Log.d("JAMY",ids.toString());
break;
}
}

@Override
protected void onDestroy() {
super.onDestroy();
DaoUtils.getCustomerInstance().CloseDataBase();
}
}

好了，调用了下，感觉还是不错的。虽说不是很完美，但最起码凑合凑合能用。以上就是鄙人对GreenDao进行的一些简单的封装，知道还不是很完善，希望各位多给批评建议，没有你们的建议就没有我的逐步成长。两篇博客搞定，哈哈。