Android 你必须了解的ORM框架GreenDao

简介

greendao是一个开源的Android开发ORM使SQLite数据库,可以减轻和节省开发时间的同时处理低级别的数据库需求。SQLite是一个很好的嵌入式关系数据库,不过写SQL解析查询结果是相当繁琐和耗时的,greendao可以让你利用java对象来映射到数据库表便捷的使用Java面相对象的API来处理增、删、改、查的操作。

特点

  1. 性能大(貌似是Android最快的ORM)
  2. 易用性高
  3. 内存消耗极小
  4. 精简的库(小于100KB)
  5. 安全性高(支持SQLCipher来保持用户的数据安全)
  6. 支持RxJava

资料

  1. 官网:http://greenrobot.org/greendao/
  2. github:https://github.com/greenrobot/greenDAO

配置环境

在build.gradle中配置

apply plugin: 'com.android.library'  
//应用greendao插件
apply plugin: 'org.greenrobot.greendao'        

android {
    compileSdkVersion 25
    buildToolsVersion "25.0.0"
    defaultConfig {
        minSdkVersion 15
        targetSdkVersion 25
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

//greendao相关配置
greendao {
    schemaVersion 1                 //数据库版本号
    daoPackage 'com.greendao.dao'    //greendao自动生成的dao文件包名
    targetGenDir 'src/main/java'    //greendao自动生成的目标文件夹
}

//从maven中下载greendao插件
buildscript {
    repositories {
        mavenCentral()
    }
    dependencies {
        classpath 'org.greenrobot:greendao-gradle-plugin:3.2.0'
    }
}

//添加greendao需要的编译环境
dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    compile 'com.android.support:appcompat-v7:25.0.0'
    compile 'com.android.support:recyclerview-v7:25.0.0'
    compile 'org.greenrobot:greendao:3.2.0'
    compile 'org.greenrobot:greendao-generator:3.2.0'
    compile 'io.reactivex:rxandroid:1.2.1'
    compile 'io.reactivex:rxjava:1.1.6'
}

然后点击Sync Project with Gradle Files按钮下载编译环境,等待下载完成,环境配置就OK了。

开始

GreenDao3.0以后开始用注解配置数据表,使用起来非常快捷方便,下面代码简单的配置了User表,表里面有id和name两个字段

@Entity
public class User{
    @Id
    private Long id;

    @NotNull
    private String name;
}

然后用Build里面的Make Project或Make Module来自动生成相关DAO类和get set方法,完成之后,在我们定义好的com.greendao.dao包下也会多出DaoMaster、DaoSession、UserDao三个类,代码这里就不贴出来了,User实体会生成如下:

@Entity
public class User{

    @Id
    private Long id;
    
    @NotNull
    private String name;

    @Generated(hash = 1709734220)
    public User(Long id, @NotNull String name) {
        this.id = id;
        this.name = name;
    }

    @Generated(hash = 586692638)
    public User() {
    }

    public Long getId() {
        return this.id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }
    
}

数据表注解@Entity的详细配置

@Entity(
    // 目前还不是很清楚这个字段的功能和意义
    schema = "myschema",
    
    // 是否需要更新、删除属性和刷新方法,默认为true
    active = true,
    
    //指定数据库中的表的名称。默认是实体类的名称。
    nameInDb = "AWESOME_USERS",
    
    // 定义跨越多个列的索引。
    indexes = {
            @Index(value = "name DESC", unique = true)
    },
    
    // 默认为true,创建数据表,如果有多个实体映射到一个表或表创建在greenDao之外,则设置false
    createInDb = false,

    // 是否生成一个所有属性的构造函数,无参构造函数默认生成
    generateConstructors = true,

    // 是否自动生成get和set方法
    generateGettersSetters = true
)
public class User {
  ...
}

注意:如果定义了 schema="myschema",会报如下错误,具体解决方法暂时还没找到,有知道的小伙伴可以留言告知一下哦

* What went wrong:
Execution failed for task ':greendaolibrary:greendao'.
> Undefined schema \"myschema\" (referenced in entities: User).
Please, define non-default schemas explicitly inside build.gradle

各个字段的详细注解

@Id 主键ID注解,属性一般long或Long来定义,如果要设该字段为自增属性,那么可以定义为@Id(autoincrement = true)

@Property 字段名定义注解,@Property(nameInDb = "USER_NAME"),默认是驼峰法代替下划线,所有字母大写,如 customName 变成 CUSTOM_NAME

@NotNull 字段不能为空注解

@Transient 字段不添加到数据表注解

@Index 字段定义为索引注解,@Index(unique = true)索引添加唯一约束,@Index(name = "indexName")定义索引名

@Unique 字段定义唯一约束注解,并会创建索引

封装

定义DbCore.java类来获取全局唯一的DaoSession对象,代码如下:

public class DbCore {
    private static final String DEFAULT_DB_NAME = "green_dao.db";
    private static DaoMaster daoMaster;
    private static DaoSession daoSession;

    private static Context mContext;
    private static String DB_NAME;

    public static void init(Context context) {
        init(context, DEFAULT_DB_NAME);
    }

    public static void init(Context context,String dbName) {
        if (context == null) {
            throw new IllegalArgumentException("context can't be null");
        }
        mContext = context.getApplicationContext();
        DB_NAME = dbName;
    }

    public static DaoMaster getDaoMaster() {
        if (daoMaster == null) {
            OnlineOpenHelper helper = new OnlineOpenHelper(mContext, DB_NAME, null);
            daoMaster = new DaoMaster(helper.getWritableDatabase());
        }
        return daoMaster;
    }

    public static DaoSession getDaoSession() {
        if (daoSession == null) {
            if (daoMaster == null) {
                daoMaster = getDaoMaster();
            }
            daoSession = daoMaster.newSession();
        }
        return daoSession;
    }

    public static void enableQueryBuilderLog(){
        QueryBuilder.LOG_SQL = true;
        QueryBuilder.LOG_VALUES = true;
    }
}

OnlineOpenHelper升级帮助类

public class OnlineOpenHelper extends DaoMaster.OpenHelper{
    public OnlineOpenHelper(Context context,String name) {
        super(context, name);
    }

    public OnlineOpenHelper(Context context,String name,SQLiteDatabase.CursorFactory factory) {
        super(context, name, factory);
    }

    @Override
    public void onUpgrade(Database db,int oldVersion,int newVersion) {
        Log.i("greenDAO", "Upgrading schema from version " + oldVersion + " to " + newVersion );
    }
}

需在在application中初始化

DbCore.init(this);                 //初始化GreenDao
DbCore.enableQueryBuilderLog();    //打印sql语句日志

封装所有的增删改查、获取Dao、获取RxDao、获取QueryBuilder等方法 到BaseService.java

public class BaseService{
    private AbstractDao mDao;

    public BaseService(AbstractDao dao) {
        mDao = dao;
    }

    public void save(T item) {
        mDao.insert(item);
    }

    public void save(T... items) {
        mDao.insertInTx(items);
    }

    public void save(List items) {
        mDao.insertInTx(items);
    }

    public void saveOrUpdate(T item) {
        mDao.insertOrReplace(item);
    }

    public void saveOrUpdate(T... items) {
        mDao.insertOrReplaceInTx(items);
    }

    public void saveOrUpdate(List items) {
        mDao.insertOrReplaceInTx(items);
    }

    public void deleteByKey(K key) {
        mDao.deleteByKey(key);
    }

    public void delete(T item) {
        mDao.delete(item);
    }

    public void delete(T... items) {
        mDao.deleteInTx(items);
    }

    public void delete(List items) {
        mDao.deleteInTx(items);
    }

    public void deleteAll() {
        mDao.deleteAll();
    }

    public void update(T item) {
        mDao.update(item);
    }

    public void update(T... items) {
        mDao.updateInTx(items);
    }

    public void update(List items) {
        mDao.updateInTx(items);
    }

    public  T query(K key) {
        return  mDao.load(key);
    }

    public List queryAll() {
        return mDao.loadAll();
    }

    public List query(String where,String... params) {

        return mDao.queryRaw(where, params);
    }

    public QueryBuilder queryBuilder() {

        return mDao.queryBuilder();
    }

    public long count() {
        return mDao.count();
    }

    public void refresh(T item) {
        mDao.refresh(item);

    }

    public void detach(T item) {
        mDao.detach(item);
    }

    public AbstractDao getDao(){
        return mDao;
    }

    public RxDao getRxDao(){
        return  mDao.rx();
    }

    public QueryBuilder getQueryBuilder(){
        return  mDao.queryBuilder();
    }
    
}

封装User表的所有操作到UserService.java类中,如后面有多个表,则只需简单继承BaseService如下即可,后面,所有相关User操作只需通过UserService.getInstance()来实现所有操作

public class UserService extends BaseService{

    public UserService() {
        super(DbCore.getDaoSession().getUserDao());
    }
    
    public static UserService getInstance(){
        return SingleLoader.INSTANCE;
    }
    
    private static class SingleLoader{
        final static UserService INSTANCE = new UserService();
    }

}

使用

public void insert(){
    String userName = user_name.getText().toString();
    if(TextUtils.isEmpty(userName)){
       return; 
    }
    User user = new User(null,userName);

    //UserService.getInstance().save(user);                 //方式一
    //UserService.getInstance().getDao().save(user);        //方式二
    UserService.getInstance().getRxDao().insert(user)        //方式三 Rx模式
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Action1() {
                @Override
                public void call(User note) {
                    search();
                }
            });
}

public void delete(){
    if(mDatas.size()<=0){
        return;
    }
    User user = mDatas.get(0);
    //UserService.getInstance().delete(user);
    //UserService.getInstance().getDao().delete(user);
    UserService.getInstance().getRxDao().delete(user)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Action1(){
                @Override
                public void call(Void aVoid){
                    search();
                }
            });
}

public void update(){
    String userName = user_name.getText().toString();
    if(TextUtils.isEmpty(userName)){
        return;
    }
    User user = mDatas.get(0);
    user.setName(userName);
    //UserService.getInstance().update(user);
    //UserService.getInstance().getDao().update(user);
    UserService.getInstance().getRxDao().update(user)
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Action1(){
                @Override
                public void call(User user){
                    search();
                }
            });
}

ID降序查询所有数据

public void search() {
    //List users = UserService.getInstance().getQueryBuilder().orderDesc(UserDao.Properties.Id).build().list();
    UserService.getInstance().getQueryBuilder().orderDesc(UserDao.Properties.Id).rx().list()
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Action1>(){
                @Override
                public void call(List users){
                    mDatas.clear();
                    for(int i = 0;i

用Rx模式模糊查询

public void searchByName() {
    String userName = user_name.getText().toString();
    if(TextUtils.isEmpty(userName)){
        return;
    }
    //方式一
    //List users = UserService.getInstance().getDao().queryBuilder().where(UserDao.Properties.Name.like("%"+userName+"%")).build().list();
    //方式二
    //List users = UserService.getInstance().getDao().queryBuilder().where(new WhereCondition.PropertyCondition(UserDao.Properties.Name, " LIKE ?", "%"+userName+"%")).build().list();
    //方式三
    UserService.getInstance().getQueryBuilder().where(new WhereCondition.PropertyCondition(UserDao.Properties.Name, " LIKE ?", "%"+userName+"%")).rx().list()
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Action1>(){
                @Override
                public void call(List users){
                    mDatas.clear();
                    for(int i = 0;i

升级

字段更新
这里借鉴了国外大牛写的一个工具类,代码如下:

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>... daoClasses) {
        generateTempTables(db, daoClasses);
        DaoMaster.dropAllTables(db, true);
        DaoMaster.createAllTables(db, false);
        restoreData(db, daoClasses);
    }

    private void generateTempTables(Database db, Class>... 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 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();
                        //Crashlytics.logException(exception);
                    }

                    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());
        }
    }

    private void restoreData(Database db, Class>... 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 properties = 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);
                }
            }

            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()));
        //Crashlytics.logException(exception);
        throw exception;
    }

    private static List getColumns(Database db,String tableName) {
        List 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;
    }
}

具体应用只需要在OnlineOpenHelperonUpgrade方法中如下使用

switch(oldVersion){
    //User表添加字段或删除字段更新
    case 1: MigrationHelper.getInstance().migrate(db,UserDao.class);
}

新增数据表

@Entity
public class Role{

    @Id
    private Long id;
    
    @NotNull
    private String roleName;
}

在OnlineOpenHelper的onUpgrade方法添加RoleDao.createTable(db,false),如下:

switch(oldVersion){
    //User表添加字段或删除字段更新
    case 1: MigrationHelper.getInstance().migrate(db,UserDao.class);
    //第二个参数true or false 是否需要检查是否存在该表
    case 2: RoleDao.createTable(db,false);
}

到这里greenDao简单的操作处理都基本OK了!

github地址

写在最后的话:很多事情都从小事做起,坚持不懈,那么最终你也会从小牛变成大牛的。

你可能感兴趣的:(Android 你必须了解的ORM框架GreenDao)