简介，依赖集成，数据库封装集成
为什么不使用原生SQLite
1、创表，增删改查需要些大量代码，开发效率极低
2、需大量封装，测试繁琐
3、效率极低（当你使用了GreenDao||Realm你会发现它完全不能接受）。
4、加密等操作需手动处理。
目前流行的Andorid数据库框架
下面先列出目前流行的常见ORM框架：
ORMLite、Afinal、ActiveAndroid、SugarORM、GreenDao、Realm
ORMLite:https://github.com/j256/ormlite-android
Afinal：https://github.com/yangfuhai/afinal
ActiviteAndroid:https://github.com/pardom/ActiveAndroid
SugarORM:Android 平台专用ORM
GreenDao:https://github.com/greenrobot/greenDAO
Realm：https://github.com/realm/realm-java
简介
GreenDAO 是一个将对象映射到 SQLite 数据库中的轻量且快速的 ORM 解决方案
特点
性能最大化，可能是Android平台上最快的ORM框架
易于使用的API
最小的内存开销
依赖体积小
支持数据库加密
集成
在项目根目录的 build.gradle 添加
buildscript {
repositories {
jcenter()
mavenCentral() // 1. add repository
}
dependencies {
classpath 'com.android.tools.build:gradle:3.5.3'
classpath 'org.greenrobot:greendao-gradle-plugin:3.3.0' //2. add plugin
}
}
在app的 build.gradle 添加
apply plugin: 'com.android.application'
apply plugin: 'org.greenrobot.greendao' // 1.apply plugin
dependencies {
implementation 'org.greenrobot:greendao:3.3.0' // 2.add library
}
GreenDao 3 采用注解的方式来定义实体类，可按如下设置生成文件的目录，在app的 build.gradle 添加
greendao {
// 指定数据库schema版本号，迁移等操作会用到
schemaVersion 1
// 设置生成数据库文件的目录，默认是在build中，可以将生成的文件放到我们的java目录中
targetGenDir 'src/main/java'
// 设置生成的数据库相关文件的包名，默认为entity所在的包名
daoPackage 'com.yoho.greendao.gen'
}
使用准备
1.编写实体类
@Entity
public class Goods {
@Id(autoincrement = true)
private Long _id = null;
private String name;
@NonNull
private String goodsId;
}
2.点击MakeProject后，就能看到实体类生成的代码及其他生成的文件
image.png
image.png
DaoMaster：使用greenDAO的切入点。DaoMaster保存数据库对象（SQLiteDatabase）并管理特定模式的DAO类（而不是对象）。 它具有静态方法来创建表或将它们删除。 其内部类OpenHelper和DevOpenHelper是在SQLite数据库中创建模式的SQLiteOpenHelper实现。一个DaoMaster就代表着一个数据库的连接。
DaoSession：管理特定模式的所有可用DAO对象，您可以使用其中一个getter方法获取。 DaoSession还为实体提供了一些通用的持久性方法，如插入，加载，更新，刷新和删除。 DaoSession可以让我们使用一些Entity的基本操作和获取Dao操作类，DaoSession可以创建多个，每一个都是属于同一个数据库连接的。
XxxDAO：数据访问对象（DAO）持续存在并查询实体。 对于每个实体，GreenDAO生成一个DAO。 它比DaoSession有更多的持久化方法，例如：count，loadAll和insertInTx。
image.png
编写DBManager
/**
* 数据库管理类
* 创建数据库，数据表，升级数据库，包含增删改查
*/
public class DBManager {
private volatile static DBManager dbManager = new DBManager();
private static final String DB_NAME = "yoho_db";
public static DBManager getDbManager() {
return dbManager;
}
private Context mContext;
/**
* DaoMaster保存数据库对象，一个DaoMaster就是一个数据库链接
*/
private static DaoMaster mDaoMaster;
/**
* OpenHelper DevOpenHelper SQLiteOpenHelper数据库的实现
*/
private static DaoMaster.DevOpenHelper devOpenHelper;
/**
* 管理特定模式的所有可用DAO对象,DaoSession还为实体提供了一些通用的持久性方法，如插入，加载，更新，刷新和删除
*/
private static DaoSession daoSession;
public void init(Context mContext) {
this.mContext = mContext;
}
/**
* 获取数据库，没有就创建
*/
public DaoMaster getDaoMaster() {
if (mDaoMaster == null) {
DaoMaster.DevOpenHelper devOpenHelper = new DaoMaster.DevOpenHelper(mContext, DB_NAME, null);
mDaoMaster = new DaoMaster(devOpenHelper.getWritableDatabase());
}
return mDaoMaster;
}
/**
* 完成对数据库的添加、删除、修改、查询操作，仅仅是一个接口
*/
public DaoSession getDaoSession() {
if (daoSession == null) {
if (mDaoMaster == null) {
getDaoMaster();
}
daoSession = mDaoMaster.newSession();
}
return daoSession;
}
/**
* 关闭所有的操作，数据库开启后，使用完毕要关闭
*/
public void closeConnection() {
if (devOpenHelper != null) {
devOpenHelper.close();
devOpenHelper = null;
}
if (daoSession != null) {
daoSession.clear();
daoSession = null;
}
}
编写Application，并初始化 DaoManager
DBManager.getDbManager().init(this);
直接使用
其实我们现在就可以直接使用数据库
//增加一条数据
DBManager.getDbManager().getDaoSession().insert(new Goods());
//增加一条或替换数据
DBManager.getDbManager().getDaoSession().insertOrReplace(new Goods());
//删除一条数据
DBManager.getDbManager().getDaoSession().delete(new Goods());
//删除整体数据
DBManager.getDbManager().getDaoSession().deleteAll(Goods.class);
//修改数据
DBManager.getDbManager().getDaoSession().update(new Goods());
//查询全部数据
DBManager.getDbManager().getDaoSession().loadAll(Goods.class);
//查询通过主键查询
DBManager.getDbManager().getDaoSession().load(Goods.class, 0);
//查询通过SQL语句查询
String sql = "where _id > ？ and name = ？ ";
String[] condition = new String[]{"2", "xx"};
DBManager.getDbManager().getDaoSession().queryRaw(Goods.class, sql, condition);
//查询使用QueryBuilder查询 eq 相等 gt 大于 ge 等于或大于
QueryBuilder qb = DBManager.getDbManager().getDaoSession().queryBuilder(Goods.class);
qb.where(GoodsDao.Properties._id.eq(1));
qb.and(GoodsDao.Properties.GoodsId.eq(1),GoodsDao.Properties.Name.ge(""));
封装数据库DAO
将重复使用的DAO相关CRUD方法统一管理使用
private DaoSession mDaoSession;
private Class<T> entityClass;
//对应实体DAO对象
private AbstractDao<T, Long> entityDao;
public CommonDaoUtils(Class<T> entityClass, AbstractDao<T, Long> entityDao) {
mDaoSession = DBManager.getDbManager().getDaoSession();
this.entityClass = entityClass;
this.entityDao = entityDao;
}
/**
* 插入数据
*
* @param entity 数据实体
* @return 结果
*/
public boolean insert(T entity) {
return mDaoSession.insert(entity) != -1;
}
/**
* 多数据插入
*
* @param entityList 数据实体集合
* @return 结果
*/
public boolean insert(List<T> entityList) {
try {
mDaoSession.runInTx(() -> {
for (T entity : entityList) {
mDaoSession.insertOrReplace(entity);
}
});
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
/**
* 修改一条数据
*
* @param entity 数据实体
* @return 结果
*/
public boolean update(T entity) {
try {
mDaoSession.update(entity);
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
public boolean delete(T entity) {
try {
mDaoSession.delete(entity);
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
public boolean deleteAll() {
try {
mDaoSession.delete(entityClass);
return true;
} catch (Exception e) {
e.printStackTrace();
}
return false;
}
public List<T> queryAll() {
return mDaoSession.loadAll(entityClass);
}
public T query(long key) {
return mDaoSession.load(entityClass, key);
}
public List<T> queryBySql(String sql, String[] conditions) {
return mDaoSession.queryRaw(entityClass, sql, conditions);
}
public List<T> queryBuilder(WhereCondition cond, WhereCondition... condMore) {
return mDaoSession.queryBuilder(entityClass).where(cond, condMore).list();
}
public class DaoUtilsStore {
private CommonDaoUtils<Goods> goodsDaoUtils;
public static DaoUtilsStore getDaoUtilsStore() {
if (daoUtilsStore == null) {
daoUtilsStore = new DaoUtilsStore();
}
return daoUtilsStore;
}
private static DaoUtilsStore daoUtilsStore;
public DaoUtilsStore() {
goodsDaoUtils = new CommonDaoUtils<Goods>(Goods.class, DBManager.getDbManager().getDaoSession().getGoodsDao());
}
public CommonDaoUtils<Goods> getGoodsDaoUtils() {
return goodsDaoUtils;
}
}
