Android 中数据库框架GreenDao与LitePal对比、集成、使用详解,greendao与原生SQLite性能对比

1.性能对比：参考这篇文章http://blog.csdn.net/aggies/article/details/45200627

2.LitePal框架详解。【操作非常简单，适合于数据库操作较少的项目】

3.greendao重要的3个类【GreenDaoManager管理类   MigrationHelper数据库升级合并类  MyOpenHelper数据库升级操作类】【greendao缓存问题】

4.原生数据库sqlite操作：http://blog.csdn.net/yingtian648/article/details/52179357

5.greendao与原生SQLite性能对比

LitePal是使用反射的方式完成的数据库表的创建

集成步骤如下：

第一步：添加依赖
详见GitHub地址，Android Studio添加依赖：compile 'org.litepal.android:core:1.4.1'

第二步：创建assets文件夹，并在其中新建一个xml文件，命名为：litepal.xml 【litepal.xml 中的内容如下】



第三步：创建类继承DataSupport，如下代码段【记得将该类的完整地址：包名+.类名配置进litepal文件中】

public class User extends DataSupport {
int id;
//transient紧在gson生成对象时忽略，litePal不会忽略还是会创建表
private transient String telephone;
private transient String pwd;
private transient String email;
private transient String department;
//公司id
private String companyId;

第四步：在自定义的Application的onCreate方法中添加：LitePal.initialize(this);//初始化

第五步：增删改查，添加字段，添加表

添加：User user = gson.fromJson(result.getData(), User.class);
    user.save();

删除，修改，查询都比较简单，这里就不赘述了，详见：https://github.com/LitePalFramework/LitePal

多条件查询：

List<MyPapersQuestion> questions = DataSupport.where("examineBatchId = ? and userTel = ?"//后面的参数对应这里的"?"
, bean.getExamineBatchId()
, UserUtils.getPhone(this))
.find(MyPapersQuestion.class);

添加字段：直接在类中操作，结束后，在litepal.xml中将版本号的value修改，运行就可以了

添加表格：定义类继承DataSupport在litepal.xml中配置好，并将版本号的value修改，运行就可以了

3.GreenDao框架详解。【操作比litepal复杂一些，查询，插入效率比litepal好很多，适合于大量操作数据库的项目】【暂不支持继承实体类】

greendao的GitHub地址：https://github.com/greenrobot/greenDAO

关于greendao的集成，请看GitHub中的介绍，这里只说一个容易出问题的地方：完成GitHub上的配置后需在app的build.gradle中配置，如下图【

其中schemaVersion是版本号，会在make project是同步到DaoMaster中的SCHEMA_VERSION值。//当类需要添加字段、添加表时，需要修改版本号。

daoPackage是dao文件存放的包名，

targetGenDir是dao包放置的位置】【可以直接搬到你的项目中使用】

greendao {
schemaVersion 1
daoPackage 'com.koma.greendao.gen'
targetGenDir 'src/main/java'
}

greendao使用详解：

① 自定义实体类Student如下：【默认表名是类名（大写）可以在@Entity(nameInDb = "Student") 来定义类在数据库中的名字】



② ctrl+f9或者点击“Build”下的“Make Project”【开发工具：Android studio】，这时你会在上文配置的daoPackage中看到多了几个类：DaoMaster,DaoSession,StudentDao,以及本身的变化——自动生成了对应的get,set方法和构造函数，效果图如下：【id如果是自增，在插入数据时可以传null】



③ 到这里你已经可以进行增删改查的操作了，但是最好还加入2个帮助类来处理版本更新，表添加字段，添加表的问题。

第一步：自定义MyOpenHelper类，用于表格添加字段，添加表等操作。

public class MyOpenHelper extends DaoMaster.OpenHelper {
public MyOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory) {
super(context, name, factory);
}

public MyOpenHelper(
4000
Context context, String name) {
this(context, name, null);
}

//当build.gradle中配置的版本号提升时，会执行下面方面
@Override
public void onUpgrade(Database db, int oldVersion, int newVersion) {
super.onUpgrade(db, oldVersion, newVersion);
//版本升级——创建新表格DOG【不会删除其他表格数据】
DogDao.createTable(db,true);//ifNotExists = true表示不存在则创建新表，falase表示不管存不存在都创建表【如果原来有表，则会删除后重新创建】
//版本升级——添加字段“grade”
DoctorDao.createTable(db,true);
db.execSQL("ALTER TABLE DOCTOR ADD grade INTEGER");
}
}

第二步：自定义GreenDaoManager类，用来获取当前版本对应的DaoSession.

public class GreenDaoManager {
private static volatile GreenDaoManager mInstance = null;
public static final String DB_NAME = "test.db";

private GreenDaoManager(Context context) {}

//单例模式
public static GreenDaoManager getInstance(Context context) {
if (mInstance == null) {
synchronized (GreenDaoManager.class) {
if (mInstance == null) {
mInstance = new GreenDaoManager(context);
}
}
}
return mInstance;
}

//第一次发布app不需要升级数据库正常使用DevOpenHelper获取daosession
public DaoSession getSession(Context context) {
DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(context, DB_NAME, null);
DaoMaster daoMaster = new DaoMaster(helper.getWritableDb());
return daoMaster.newSession();
}

//再次app需要升级数据库时 获取daosession
public DaoSession getUpdateSession(Context context) {
MyOpenHelper dbHelper = new MyOpenHelper(context,DB_NAME);
DaoMaster daoMaster = new DaoMaster(dbHelper.getWritableDb());
return daoMaster.newSession();
}
}

第三步：增删改查，给表格添加字段，添加表（类）

/** 第一步 获取daosession */
DaoSession session = GreenDaoManager.getInstance(this).getUpdateSession(this);
/** 第二步 获取dao */
DoctorDao doctorDao = session.getDoctorDao();

/** 模糊查询——条件查询 */
List<Doctor> doctors = doctorDao.queryBuilder().where(DoctorDao.Properties.Name.like("%1%")).build().list();
/** 查询医生名==“小花”的医生——条件查询 */
List<Doctor> doctors1 = doctorDao.queryBuilder().where(DoctorDao.Properties.Name.eq("小花")).build().list();

for (int i = 0; i < doctors.size(); i++) {
String s = doctors.get(i).getName() + "   年龄_" + queryDataList.get(i).getId();
/** 删除单条记录 */
doctorDao.delete(doctors.get(i));
/** 删除表中所有记录 */
doctorDao.deleteAll();
}

doctorDao.insert(dataList.get(i));//插入数据

/** 更新表格数据——依据是id */
doctorDao.update(new Doctor(1l, "李白", 1, "国子监"));

表添加字段：

① 在实体类中添加一个字段如：private String grade;

② 在自定义的MyOpenHelper类中添加：见上面的注释

③ 在配置文件中将版本号改为2：schemaVersion 2

完成。

添加表格：与添加字段步骤类似，先创建一个实体类，在修改MyOpenHelper中代码，再升级版本号。

greendao缓存问题

如果数据库数据已修改 → 搜索数据库后得到的是老数据【恭喜你 遇到了greendao缓存问题】

处理：只需在搜索前调用DaoSession.clear()方法清理所有缓存即可；

以下是3个greendao中的重要类：【最新版】

【管理类】【调用：GreenDaoManager.getInstance().getSession()、数据库升级时需掉一次getUpdateSession】

public class GreenDaoManager {
private static volatile GreenDaoManager mInstance = null;
public static final String DB_NAME = "ecosurvey.db";

private GreenDaoManager() {
}

//单例模式
public static GreenDaoManager getInstance() {
if (mInstance == null) {
synchronized (GreenDaoManager.class) {
if (mInstance == null) {
mInstance = new GreenDaoManager();
}
}
}
return mInstance;
}

//第一次发布app不需要升级数据库正常使用DevOpenHelper获取daosession
public DaoSession getSession(Context context) {
DaoMaster.DevOpenHelper helper = new DaoMaster.DevOpenHelper(context, DB_NAME, null);
DaoMaster daoMaster = new DaoMaster(helper.getWritableDb());
return daoMaster.newSession();
}

//再次app需要升级数据库时 获取daosession
public DaoSession getUpdateSession(Context context) {
MyOpenHelper dbHelper = new MyOpenHelper(context, DB_NAME);
DaoMaster daoMaster = new DaoMaster(dbHelper.getWritableDb());
return daoMaster.newSession();
}
}

public class MyOpenHelper extends DaoMaster.OpenHelper {
public MyOpenHelper(Context context, String name, SQLiteDatabase.CursorFactory factory) {
super(context, name, factory);
}

public MyOpenHelper(Context context, String name) {
this(context, name, null);
}

@Override
public void onUpgrade(Database db, int oldVersion, int newVersion) {
super.onUpgrade(db, oldVersion, newVersion);
//之前的数据不重要，直接删除旧表
JDLogDao.dropTable(db, true);
JDLogDao.createTable(db, true);【应当调用MigrationHelper.getInstance().createTable(db,true);防止用户部分数据库升级时未升级，部分表格找不到】
//需要把旧表的数据添加到新表
MigrationHelper.getInstance().migrate(db, SampleInfoDao.class);
}
}

【数据库升级时调用，在MyOpenHelper中调用】【将旧表数据添加到新表】

import android.database.Cursor;
import android.text.TextUtils;
import android.util.Log;

import com.adas.jdbasevisitor.greendao.dao.DaoMaster;

import org.greenrobot.greendao.AbstractDao;
import org.greenrobot.greendao.database.Database;
import org.greenrobot.greendao.internal.DaoConfig;

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

public class MigrationHelper {

private static final String CONVERSION_CLASS_NOT_FOUND_EXCEPTION = "MIGRATION HELPER - CLASS DOESN'T MATCH WITH THE CURRENT PARAMETERS";
private static MigrationHelper instance;

public static MigrationHelper getInstance() {
if (instance == null) {
instance = new MigrationHelper();
}
return instance;
}

public void migrate(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
generateTempTables(db, daoClasses);
DaoMaster.dropAllTables(db, true);
DaoMaster.createAllTables(db, false);
restoreData(db, daoClasses);
}

/**
* 生成临时列表
*
* @param db
* @param daoClasses
*/
private void generateTempTables(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
for (int i = 0; i < daoClasses.length; i++) {
DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);

String divider = "";
String tableName = daoConfig.tablename;
String tempTableName = daoConfig.tablename.concat("_TEMP");
ArrayList<String> properties = new ArrayList<>();

StringBuilder createTableStringBuilder = new StringBuilder();

createTableStringBuilder.append("CREATE TABLE ").append(tempTableName).append(" (");

for (int j = 0; j < daoConfig.properties.length; j++) {
String columnName = daoConfig.properties[j].columnName;

if (getColumns(db, tableName).contains(columnName)) {
properties.add(columnName);

String type = null;

try {
type = getTypeByClass(daoConfig.properties[j].type);
} catch (Exception exception) {
exception.printStackTrace();
}

createTableStringBuilder.append(divider).append(columnName).append(" ").append(type);

if (daoConfig.properties[j].primaryKey) {
createTableStringBuilder.append(" PRIMARY KEY");
}

divider = ",";
}
}
createTableStringBuilder.append(");");

db.execSQL(createTableStringBuilder.toString());

StringBuilder insertTableStringBuilder = new StringBuilder();

insertTableStringBuilder.append("INSERT INTO ").append(tempTableName).append(" (");
insertTableStringBuilder.append(TextUtils.join(",", properties));
insertTableStringBuilder.append(") SELECT ");
insertTableStringBuilder.append(TextUtils.join(",", properties));
insertTableStringBuilder.append(" FROM ").append(tableName).append(";");

db.execSQL(insertTableStringBuilder.toString());

}
}

/**
* 存储新的数据库表 以及数据
*
* @param db
* @param daoClasses
*/
private void restoreData(Database db, Class<? extends AbstractDao<?, ?>>... daoClasses) {
for (int i = 0; i < daoClasses.length; i++) {
DaoConfig daoConfig = new DaoConfig(db, daoClasses[i]);
String tableName = daoConfig.tablename;
String tempTableName = daoConfig.tablename.concat("_TEMP");
ArrayList<String> properties = new ArrayList();
ArrayList<String> propertiesQuery = new ArrayList();
for (int j = 0; j < daoConfig.properties.length; j++) {
String columnName = daoConfig.properties[j].columnName;

if (getColumns(db, tempTableName).contains(columnName)) {
properties.add(columnName);
propertiesQuery.add(columnName);
} else {
try {
//如果添加的字段有integer类型，需要添加默认值【不然会报错】
if (getTypeByClass(daoConfig.properties[j].type).equals("INTEGER")) {
propertiesQuery.add("0 as" + columnName);
properties.add(columnName);
}
//float型 也不能为空 添加默认值
if (getTypeByClass(daoConfig.properties[j].type).equals("REAL")) {
propertiesQuery.add("0.0 as" + columnName);
properties.add(columnName);
}

} catch (Exception e) {
e.printStackTrace();
}
}
}
StringBuilder insertTableStringBuilder = new StringBuilder();

insertTableStringBuilder.append("INSERT INTO ").append(tableName).append(" (");
insertTableStringBuilder.append(TextUtils.join(",", properties));
insertTableStringBuilder.append(") SELECT ");
insertTableStringBuilder.append(TextUtils.join(",", properties));
insertTableStringBuilder.append(" FROM ").append(tempTableName).append(";");

StringBuilder dropTableStringBuilder = new StringBuilder();
dropTableStringBuilder.append("DROP TABLE ").append(tempTableName);
db.execSQL(insertTableStringBuilder.toString());
db.execSQL(dropTableStringBuilder.toString());
}
}

private String getTypeByClass(Class<?> type) throws Exception {
if (type.equals(String.class)) {
return "TEXT";
}
if (type.equals(Long.class) || type.equals(Integer.class) || type.equals(long.class)) {
return "INTEGER";
}
if (type.equals(Boolean.class)) {
return "BOOLEAN";
}

Exception exception = new Exception(CONVERSION_CLASS_NOT_FOUND_EXCEPTION.concat(" - Class: ").concat(type.toString()));
exception.printStackTrace();
throw exception;
}

private List<String> getColumns(Database db, String tableName) {
List<String> columns = new ArrayList<>();
Cursor cursor = null;
try {
cursor = db.rawQuery("SELECT * FROM " + tableName + " limit 1", null);
if (cursor != null) {
columns = new ArrayList<>(Arrays.asList(cursor.getColumnNames()));
}
} catch (Exception e) {
Log.v(tableName, e.getMessage(), e);
e.printStackTrace();
} finally {
if (cursor != null)
cursor.close();
}
return columns;
}

//创建表格
public void createTable(Database db, boolean ifNotExists) {
DaoMaster.createAllTables(db, ifNotExists);
}
}

5.greendao与原生的SQLite性能对比（看下图）


 


可以得出结果：



备注：

1.这里的查询数据：greendao查询时每次都使用了daoSession.clear()清理了greendao缓存【不清理时：第一次查询与表中一样，从第二次开始以后查询相同的数据都比原生的查询耗时少一半】

2.更新的时候greendao需要查询出来后逐个修改，之后再dao.update，这是耗时差距很大的原因之一