GreenDao 介绍：
greenDAO是一个对象关系映射（ORM）的框架，能够提供一个接口通过操作对象的方式去操作关系型数据库，它能够让你操作数据库时更简单、更方便。如下图所示：
官网地址：http://greenrobot.org/greendao/
Github地址：https://github.com/greenrobot/greenDAO
GreenDao 3.x使用
GreenDao 3.x采用注解的方式来定义实体类，通过gradle插件生成相应的代码。
****一、在as项目中添加配置****
一、先项目的Project 的 build.gradle 里添加
buildscript {
repositories {
mavenCentral()
}
dependencies {
classpath 'org.greenrobot:greendao-gradle-plugin:3.2.0'
}
}
apply plugin: 'org.greenrobot.greendao'
dependencies {
compile 'org.greenrobot:greendao:3.2.0'
}
二、 新建一个java module选择java library,并在新建lib的build.gradle 里添加
dependencies {
compile fileTree(include: ['*.jar'],dir:'libs')
compile'org.greenrobot:greendao-generator:3.2.0'
}
schemaVersion： 数据库schema版本，也可以理解为数据库版本号
daoPackage：设置DaoMaster、DaoSession、Dao包名
targetGenDir：设置DaoMaster、DaoSession、Dao目录
targetGenDirTest：设置生成单元测试目录
generateTests：设置自动生成单元测试用例
****二、生成数据库表，直接上代码****
public static void main(String[] args) { //生成数据库的实体类
Schema schema = new Schema(1, "com.dralong.entity");
addDb(schema); //创建数据库dao层
schema.setDefaultJavaPackageDao("com.dralong.dao");
try { //生成到java-gen文件夹下
new DaoGenerator().generateAll(schema, "E:\\AndroidWork\\BookEntry\\app\\src\\main\\java-gen");
} catch (Exception e) {
e.printStackTrace();
}
}
private static void addDb(Schema schema) {
Entity entity = schema.addEntity("Type");//创建表
entity.addIdProperty();//primary key
entity.addStringProperty("name");
entity.addStringProperty("nickname");
Entity detail = schema.addEntity("Detail");//创建表
detail.addIdProperty();//primary key
detail.addStringProperty("name");
detail.addStringProperty("typeName");
detail.addFloatProperty("money");
detail.addDateProperty("time");
Property IncomeAndExpenses_Id = entity.addLongProperty("type_Id").notNull().getProperty(); //添加一对一外键关联
detail.addToOne(entity, IncomeAndExpenses_Id);
}
运行main方法自动生成数据库实体类代码
****三、封装以及使用****
一、封装application方便使用
public class BaseApp extends Application {
public DaoSession daoSession;
public SQLiteDatabase db;
public DaoMaster.DevOpenHelper helper;
public DaoMaster daoMaster;
@Override
public void onCreate() {
super.onCreate();
setupDatabase();
}
private void setupDatabase() {
// 通过 DaoMaster 的内部类 DevOpenHelper，你可以得到一个便利的 SQLiteOpenHelper 对象。
// 可能你已经注意到了，你并不需要去编写「CREATE TABLE」这样的 SQL 语句，因为 greenDAO 已经帮你做了。
// 注意：默认的 DaoMaster.DevOpenHelper 会在数据库升级时，删除所有的表，意味着这将导致数据的丢失。
// 所以，在正式的项目中，你还应该做一层封装，来实现数据库的安全升级。
helper = new DaoMaster.DevOpenHelper(this, Constants.DB_NAME, null);
db = helper.getWritableDatabase();
// 注意：该数据库连接属于 DaoMaster，所以多个 Session 指的是相同的数据库连接。
daoMaster = new DaoMaster(db);
daoSession = daoMaster.newSession();
}
public DaoSession getDaoSession() {
return daoSession;
}
public SQLiteDatabase getDb() {
return db;
}
}
封装manager
/**
* 1、创建数据库
* 2、创建数据库表
* 3、包含对数据库的CRUD
* 4、对数据库的升级
*/
public class DaoManager {
private static final String TAG = DaoManager.class.getSimpleName();
private static volatile DaoManager manager;
private static DaoMaster.DevOpenHelper helper;
private static DaoSession daoSession;
private Context mContext;
private DaoManager(Context context) {
this.mContext = context;
}
public static DaoManager getInstance(Context context) {
if (manager == null) {
synchronized (DaoManager.class) {
if (manager == null) {
manager = new DaoManager(context);
}
}
}
return manager;
}
private static DaoMaster daoMaster;
//判断是否存在数据库，没有就创建
public DaoMaster getDaoMaster() {
if (daoMaster == null) {
helper = new DaoMaster.DevOpenHelper(mContext, Constants.DB_NAME, null);
daoMaster = new DaoMaster(helper.getWritableDb());
}
return daoMaster;
}
// 数据处理
public DaoSession getDaoSession() {
if (daoSession == null) {
if (daoMaster == null) {
daoMaster = getDaoMaster();
}
daoSession = daoMaster.newSession();
}
return daoSession;
}
//输出日志
public void setDebug() {
QueryBuilder.LOG_SQL = true;
QueryBuilder.LOG_VALUES = true;
}
public void close() {
closeHelper();
closeSession();
}
public void closeHelper() {
if (helper != null) {
helper.close();
helper = null;
}
}
//关闭session
public void closeSession() {
if (daoSession != null) {
daoSession.clear();
daoSession = null;
}
}
}
对数据库操作增删改查
class DaoHelper<T> {
private DaoManager manager;
private Class<T> clazz;
public DaoHelper(Context context) {
manager = DaoManager.getInstance(context);
}
private Class<T> getClazz() {
if (clazz == null) {//获取泛型的Class对象
clazz = ((Class<T>) (((ParameterizedType) (this.getClass().getGenericSuperclass())).getActualTypeArguments()[0]));
}
return clazz;
}
// 插入增加
public boolean insert(T t) {
return manager.getDaoSession().insert(t) != -1 ? true : false;
}
//插入集合
public boolean insertList(final List<T> datas) {
boolean flag = false;
try {
manager.getDaoSession().runInTx(new Runnable() {
@Override
public void run() {
for (T t : datas) {
manager.getDaoSession().insertOrReplace(t);
}
}
});
flag = true;
} catch (Exception e) {
e.printStackTrace();
}
return flag;
}
//删除
public boolean delete(T t) {
try {
manager.getDaoSession().delete(t);
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
// 删除所有
public boolean deleteAll() {
try {
manager.getDaoSession().deleteAll(clazz);
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
//列出所有
public List<T> listAll() {
return (List<T>) manager.getDaoSession().loadAll(getClazz());
}
public T find(long id) {
return manager.getDaoSession().load(clazz, id);
}
//更新
public boolean update(T t) {
try {
manager.getDaoSession().update(t);
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
//queryRaw查询
public List<T> queryAll(String where, String... selectionArgs) {
List<T> list = manager.getDaoSession().queryRaw(clazz, where, selectionArgs);
return list;
}
//biuld查询
public List<T> queryBuilder() {
List<T> list = manager.getDaoSession().queryBuilder(clazz) .list();
return list;
}
//查询全部，dao查询
public List<T> queryDaoAll(Class clazz) {
DaoMaster daoMaster = manager.getDaoMaster();
DaoSession session = daoMaster.newSession();
List<T> list = session.loadAll(clazz);
return list;
}
}
