Android 数据库框架 LiteOrm使用

转载 2017年04月08日 23:11:56

版权声明:转载请注明出处 https://github.com/baiiu


前言

关于Android ORM框架,之前写过关于GreenDao的使用,在被安利了一篇 Android数据库框架:greenDAO vs LiteOrm ,又看了下LiteOrm的基本使用,很方便,而且效率并不低,特别是在级联查询上,很方便很面向对象。

恩,LiteOrm不是OrmLite。关于它的使用主要是看GitHub上的samples,因为它没有文档。不过数据库框架的使用方法都比较相似,看看方法名大概就能猜出来什么意思。

GitHub地址:https://github.com/litesuits/android-lite-orm 
LiteSuits 官网: http://litesuits.com/?form=gorm

1. 开始使用

/*
1. 创建config信息
*/
DataBaseConfig config = new DataBaseConfig(mContext);
//数据库名,可设置存储路径。默认在内部存储位置databases文件夹下
config.dbName = DB_NAME_PATH + File.separator + DB_NAME;
config.debugged = true; //是否打Log
config.dbVersion = 1; // database Version
config.onUpdateListener = null; //升级

/*
2. 生成实例对象
*/
//级联操作
liteOrm = LiteOrm.newCascadeInstance(config);
//独立操作
liteOrm = LiteOrm.newSingleInstance(config);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17

可以看到,LiteOrm提供了两种获取实例的方式:singleInstance和cascadeInstance。其中:

    独立操作:使用 LiteOrm 的 single 实例,可与 cascade 方式平滑切换,性能高,仅处理该对象数据,其关系、和关联对象忽略;

    级联操作:使用 LiteOrm 的 cascade 实例,可与 single 方式平滑切换,全递归,该对象数据,及其关系、和关联对象都被处理;

这两种获取方式根据项目需求而定,如果级联操作比较多的话,就可以使用cascadeInstance,而其又可以和独立操作任意切换:

LiteOrm db = LiteOrm.newCascadeInstance(this, "cascade.db");
db.cascade().save(user);//级联操作:保存[当前对象],以及该对象所有的[关联对象]以及它们的[映射关系]。
db.single().save(user);//非级联操作:仅保存[当前对象],高效率。
  • 1
  • 2
  • 3
  • 1
  • 2
  • 3

从此处就可以看到该框架的强大了吧。最简单的是它通过注解的形式声明对象间关系,那下面就说说它的注解。

2. 注解

基础注解

  • @Table("test_model") 表名
  • @PrimaryKey(AssignType.AUTO_INCREMENT) 主键自增长
  • @PrimaryKey(AssignType.BY_MYSELF) 自己设置主键
  • @Ignore 忽略该字段,不存入数据库
  • @Column("login") 指定列名
  • @Collate("NOCASE") 大小写无关

关系映射:

  • @Mapping(Relation.ManyToMany) 多对多
  • @Mapping(Relation.OneToMany) 一对多
  • @Mapping(Relation.OneToOne) 一对一
  • @Mapping(Relation.ManyToOne) 多对一
  • @MapCollection(ConcurrentLinkedQueue.class) 指定约束对象的集合类型

约束相关:

  • @NotNull 非空约束
  • @Default("true") 默认约束
  • @Check("index > 0 ") check约束
  • @Unique 唯一约束
  • @UniqueCombine() 联合唯一约束

约束冲突:

ON CONFLICT 子句不是一个单独的 SQL 命令。 它可以出现在很多其它的 SQL 命令中,是一个非标准的子句。ON CONFLICT 子句指定一个用于解决约束冲突的算法。 有五种选择(具体解释请看文末参考链接,copy过来也没啥意思): 
@Conflict(Strategy.ROLLBACK) 
@Conflict(Strategy.ABORT) 
@Conflict(Strategy.FAIL) 
@Conflict(Strategy.IGNORE) 
@Conflict(Strategy.REPLACE)

这里总结了LiteOrm使用的几乎所有的注解,全部从samples中总结出来。有些一看就懂,但有些就比较生疏。但框架毕竟是框架,用着用着就熟悉了。从注解也可以看出来该框架确实比较全面。为了弄懂一些东西,又复习了一遍Sql语句。因为它的查询某些语法完全和SQL语句一样。下面就介绍一下他的基本CRUD操作。

3. CRUD 操作

常用操作:
- 保存(插入or更新)
School school = new School("hello");
liteOrm.save(school);
- 插入
Book book = new Book("good");
liteOrm.insert(book, ConflictAlgorithm.Abort);
- 更新
book.setIndex(1988);
book.setAuthor("hehe");
liteOrm.update(book);
- 更新指定列
// 把所有书的author强制批量改为liter
HashMap<String, Object> bookIdMap = new HashMap<String, Object>();
bookIdMap.put(Book.COL_AUTHOR, "liter");
liteOrm.update(bookList, new ColumnsValue(bookIdMap), ConflictAlgorithm.Fail);
// 仅 author 这一列更新为该对象的最新值。
//liteOrm.update(bookList, new ColumnsValue(new String[]{Book.COL_AUTHOR}, null), ConflictAlgorithm.Fail);
- 查询
List list = liteOrm.query(Book.class);
OrmLog.i(TAG, list);
- 查找 使用QueryBuilder
List<Student> list = liteOrm.query(new QueryBuilder<Student>(Student.class)
        .where(Person.COL_NAME + " LIKE ?", new String[]{"%0"})
        .whereAppendAnd()
        .whereAppend(Person.COL_NAME + " LIKE ?", new String[]{"%s%"}));
OrmLog.i(TAG, list);
- 查询 根据ID
Student student = liteOrm.queryById(student1.getId(), Student.class);
OrmLog.i(TAG, student);
- 查询 任意
List<Book> books = liteOrm.query(new QueryBuilder<Book>(Book.class)
        .columns(new String[]{"id", "author", Book.COL_INDEX})
        .distinct(true)
        .whereGreaterThan("id", 0)
        .whereAppendAnd()
        .whereLessThan("id", 10000)
        .limit(6, 9)
        .appendOrderAscBy(Book.COL_INDEX));
OrmLog.i(TAG, books);
- 删除 实体
// 删除 student-0
liteOrm.delete(student0);
- 删除 指定数量
// 按id升序,删除[2, size-1],结果:仅保留第一个和最后一个
// 最后一个参数可为null,默认按 id 升序排列
liteOrm.delete(Book.class, 2, bookList.size() - 1, "id");
- 删除 使用WhereBuilder
// 删除 student-1
liteOrm.delete(new WhereBuilder(Student.class)
        .where(Person.COL_NAME + " LIKE ?", new String[]{"%1%"})
        .and()
        .greaterThan("id", 0)
        .and()
        .lessThan("id", 10000));
- 删除全部
// 连同其关联的classes,classes关联的其他对象一带删除
liteOrm.deleteAll(School.class);
liteOrm.deleteAll(Book.class);


// 顺带测试:连库文件一起删掉
liteOrm.deleteDatabase();
// 顺带测试:然后重建一个新库
liteOrm.openOrCreateDatabase();
// 满血复活
常用注解:

@Table("class")指定表名是class

@Ignore 忽略字段不被保存到数据库中

@Column("_id") 标明字段在数据中的列名是_id

@Mapping(Relation.XX)用于多表映射

@Check("check > 99")//大于99才存储
private int check = 100;

@Collate("NOCASE") 排序规则,nocase就是大小写无关
private String _collate;

@Default("SQL默认值") 指定字段缺省值

@NotNull 字段不能为空

@PrimaryKey(AssignType.AUTO_INCREMENT) 主键自增长

@Conflict(Strategy.FAIL) 冲突的时候不存储

@Unique 唯一,确保某列中的所有值是不同的。

@UniqueCombine(1) UniqueCombine 值为1,和 UniqueCombine同值 的属性联合唯一
private int mIndex;
@UniqueCombine(1) UniqueCombine值为1,和 mIndex联合唯一
private String author;

@Mapping(Relation.ManyToMany)
@MapCollection(ConcurrentLinkedQueue.class) 表示Queue的具体容器是ConcurrentLinkedQueue
private Queue<Student> studentLinkedQueue;

基础操作:

// 1. 保存数据
Person person = new Person("name",23);
liteOrm.save(person); 
List<Person> list = new ArrayList<>();
liteOrm.save(list);

// 2. 读取全部数据
List<Person> list = liteOrm.query(Person.class);

// 3. 删除全部
liteOrm.deleteAll(Person.class);
liteOrm.deleteDatabase();
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

查询操作

查询操作里面这个 ? 必不可少,是不是和写sql很像,? 是个占位符。同时SQL并不区分大小写,但关键字建议大写。

//聚合函数count查询,好像只有这一个
long nums = liteOrm.queryCount(Address.class); //查询有多少行

//模糊查询
QueryBuilder<Address> qb = new QueryBuilder<Address>(Address.class).where("address LIKE ?", new String[]{"%山%"});

//与或非等
qb = new QueryBuilder<Address>(Address.class)        
.whereEquals("city", "南京")
.whereAppendAnd() 
.whereEquals("address", "香港路");

//自己拼SQL语句
QueryBuilder<Address> qb = new QueryBuilder<Address>(Address.class)        
.columns(new String[]{Address.COL_ADDRESS})    //查询列
.appendOrderAscBy(Address.COL_ADDRESS)        //升序
.appendOrderDescBy(Address.COL_ID)       //当第一列相同时使用该列降序排序
.distinct(true)        //去重
.where(Address.COL_ADDRESS + "=?", new String[]{"香港路"}); //where条件

liteOrm.query(qb);
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

在写查询语句时,一定要铭记sql语句:

SELECTFROMWHERE 条件
GROUP BY 分组条件
HAVING 分组后条件
ORDER BY 排序
LIMIT (x,y)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

LiteOrm提供的查询功能很强大,看到这是不是和我一样想去把sql复习一遍?毕竟好久没写sql语句了。用框架多了都忘记原理了。 
看了下LiteOrm的query过程,底层确实还是拼sql语句,这样想想realm确实犀利,毕竟自己做的引擎,快是必须的了。下面介绍一下LiteOrm的级联查询,这一块我看到的时候立刻就爱上了它,完完全全的面向对象的操作,表也帮你自动生成。

4. 级联操作

为什么说面向对象呢。就是仅仅需要在JavaBean里声明对象间关系,并用注解标识就OK了。举个例子:

@Table("school")
public class School{
  @Mapping(Relation.OneToMany)
  public ArrayList<Classes> classesList; //一个学校有多个教室
}

@Table("class")public class Classes  {        
  @Mapping(Relation.OneToOne)   
  public Teacher teacher; //一个教室有一个老师,假设
}

@Table("teacher")public class Teacher {   
  @Mapping(Relation.ManyToMany)    
  @MapCollection(ConcurrentLinkedQueue.class)   
  private Queue<Student> studentLinkedQueue; //一个老师多个学生,一个学生多个老师,多对多关系
}

@Table("student")public class Student  {    
  @Mapping(Relation.ManyToMany)    
  private Teacher[] teachersArray;//一个老师多个学生,一个学生多个老师,多对多关系
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

就这样声明,你在Java里创建完对象后使用save()方法保存后,数据库中各种关联表就建好了,完全不用自己设置主键、外键什么的。是不是很方便?不过前提是你要使用LiteOrm.newCascadeInstance(config)这个实例。

说完了这些就该考虑封装啦,因为毕竟数据库框架这种东西没有最好,只有更好。说不定哪一天Square出一个Orm框架也说不定。所以就单独封装一层,方便对外提供方法并且方便以后可能的替换。

5. 基础封装

在上一篇 Retrofit2.0 封装 的封装中使用了枚举来封装,真的不错,很方便,比单例方便而且更安全。所有同样还是使用枚举来封装。

public enum UOrm implements SQLiteHelper.OnUpdateListener {
  INSTANCE;
  private LiteOrm mLiteOrm;
  UOrm() {
    DataBaseConfig config = new DataBaseConfig(MyApplcation.mContext);
    config.dbName = DB_NAME_PATH + File.separator + DB_NAME;
    config.dbVersion = 1;
    config.onUpdateListener = this;
    config.debugged = BuildConfig.DEBUG;
    //可替换为 newCascadeInstance支持级联操作
    mLiteOrm = LiteOrm.newSingleInstance(config);
  }

  @Override public void onUpdate(SQLiteDatabase sqLiteDatabase, int i, int i1) {
  }

  public void save(Object o) {
    if (o == null) {
      return;
    }

    mLiteOrm.save(o);
  }

  public <T> void save(List<T> collection) {
    if (CommonUtil.isEmpty(collection)) {
      return;
    }

    mLiteOrm.save(collection);
  }

  public <T> void delete(Class<T> tClass) {
    if (tClass == null) {
      return;
    }

    mLiteOrm.delete(tClass);
  }

  public <T> List<T> queryAll(Class<T> tClass) {
    if (tClass == null) {
      return null;
    }

    return mLiteOrm.query(tClass);
  }

}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50

使用时只用这样调用:

    UOrm.INSTANCE.save(modelA);

这里的封装仅仅提供了最最基础的方法,主要是提供liteOrm的实例。你也可以根据业务需求向里面添加方法。 
写到这感觉这样封装并不是很好,如果你有更好的封装方法请告诉我哈,大家一起交流。

结语

关于数据库框架,自己所考虑的主要是性能和方便调用。

Realm性能超级高,但是它对model类限制的太多,直接导致某些情况下model不能复用,需要重新拷贝一份来单独处理业务逻辑部分,在机器内存有限的情况下这样做肯定不好,不过官方貌似也意识到了。 
GreenDao都说好,自己也用了确实不错。但是不得不说确实很复杂,而且在级联这块的配置更复杂一些。之后再次重新考虑数据库框架时写个demo来尝试一下这块。 
LiteOrm虽然名气不大,但是真的很方便,对model类没有限制,级联操作也很方便,效率上和GreenDao差一点也真的可以忽略了。所有目前个人选择使用LiteOrm,也分享给大家。可惜的是LiteOrm没有gradle引入。

本文相关代码在:GitHub LiteOrmLearn 
本文的相关代码在上面,另外官方的samples是eclipse版的,我完全移到as上了。

希望本文能对你有帮助。另外,真的希望Realm能更好,毕竟1.0.0 release已经出来了。

举报

相关文章推荐

Android数据库框架-Archiver(LiteOrm)的简单使用(一)

Android系统为开发者提供了SQLiteOpenHelper帮助类来操作数据库,当然了,系统也封装得比较好了,不过今日我们来看看其他的数据库框架。 开源地址:https://github.com/...

LiteOrm的简单使用

首先去网上下载jar包,(https://github.com/litesuits/android-lite-orm),然后解压,复制最新的jar包,然后构建一下,是那个蓝色向下的小箭头,创建一个数据...

我是如何成为一名python大咖的?

人生苦短,都说必须python,那么我分享下我是如何从小白成为Python资深开发者的吧。2014年我大学刚毕业..

liteorm简单封装

public class DatabaseManager { private static LiteOrm liteOrm; private static Context mContex...

Android数据库框架-Archiver(LiteOrm)的简单使用(一)

Android数据库框架-Archiver(LiteOrm)的简单使用(一) Android系统为开发者提供了SQLiteOpenHelper帮助类来操作数据库,当然了,系统也封装得...

Android 数据库框架LiteOrm简介

Android高性能数据库框架:LiteOrm 简介: LiteOrm是一个小巧、强大、比系统自带数据库操作性能快1倍的 android ORM 框架类库,速度快、体积小、性能高。开发者一行代码实现数...

LiteOrm:Android数据库框架-存储服务器(LiteOrm)的使用

在Android开发中,大家开发不同项目,不同的项目就不有不同需求。但是不管是什么项目都会涉及到数据存储。比如SharePreferences,SQLite,File等方式。在项目开发过程中。有很多项...

LiteOrm:Android数据库框架-存储服务器(LiteOrm)的使用

LiteOrm:Android数据库框架-存储服务器(LiteOrm)的使用

Android 快速开发系列之数据库篇(LiteOrm)

Android 快速开发系列之数据库篇(LiteOrm) 继上一篇GreenDao后,本文将带领大家学习下基于注解的orm框架:LiteOrm,注意不是Ormlite,作者是马天宇,不是...

Android ORM框架介绍之android-liteorm(archiver)注解与封装

Android ORM框架介绍之android-liteorm注解与封装LiteOrm代号: archiverLiteOrm 是一个速度快、小巧却强大的 Android ORM 框架类库,速度快、体积...
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)