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

本文主要是介绍Android数据库框架-Archiver(LiteOrm)的使用，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

转自：Android数据库框架-Archiver(LiteOrm)的使用

在Android开发中，大家开发不同项目，不同的项目就不有不同需求。但是不管是什么项目都会涉及到数据存储。比如SharePreferences，SQLite，File等方式。但是我最近开发的项目是一个有IM的项目。所以需要用到SQLite，原因是这其中的数据并不是所有数据都是在后台拉取的。也有需要自己去创建表，和填充数据的功能。下面具体讲讲我在项目中使用的数据库和所遇到的数据库问题。

LiteOrm: LiteOrm是一个速度快、小巧却强大的android ORM框架类库，LiteOrm让你一行代码实现数据库的增删改查操作，以及实体关系的持久化和自动映射。

轻量，专注，性能优先，线程无关，专注数据及其关系（关系是重点）存储和读取。

不需要工具辅助，实体不需要无参构造，不需要繁多注解，约定大约配置，一切多余的，都不需要。

使用极致简约：db.save(u); db.delete(u); db.deleteAll(U.class);

开源项目地址：https://github.com/litesuits/android-lite-orm
作者个人主页：http://litesuits.com/

我为什么选择用LiteOrm的原因：

因为我开发的项目是一个IM的项目，当然要允许账号切换当账号切换之后上一个用户对应的数据和下一个用户对应的数据怎么区分？这是一个细节上的问题。所以我采用的QQ的做法，一个用户对应一个数据库。有些库写的也不错，可是考虑的不周全，一个用户对应一个数据库是最好的，但是有些库没有考虑进去，但是LiteOrm可以自定义数据库名字已经目录。
在当我使用其他的库的时候，报错了，尼玛我研究看瞎都没有看出到底是什么错，没有一个准确的提示告诉我到底是什么地方错误。比如我其中有一个字段是from，这个是数据库关键字，总是创建不成功，但是那个库又报一些看不懂错，根本没有说倒是是哪错了。但是在我使用LiteOrm的时候哪里错了会明确的告诉你。
因为LiteOrm体积小，专一，一个库只做一件事，是什么库就做什么事情，有些库什么功能都有，又是HTTP请求，又是下载图片，但是我只需要用到其中一个模块而已。

1、创建数据库：

 ? 
 /** 
       * 创建数据库细节 ： 
       * 细节一：每次启动都会调用这个方法，是否会重复创建，或者说怎么判断这个数据库已经存在。 
       * 回答：尽在第一次创建，开发这不用关心存在否。 
       *  
       * 细节二：如果指定目录创建在SD卡上，卸载APP之后，重新安装，以前的创建的数据库还存在 
       * 回答：如果不想这样，就不要指定创建在SD卡上面，默认创建就在APP里。卸载后数据库就不存在了 
       *  
       * 细节三：创建数据库有两种模式，第一种是单一操作没有级联关系的，第二种是级联操作。 
       * 创建单一操作模式：LiteOrm.newSingleInstance(_activity, DB_NAME); 
       * 创建级联操作模式：LiteOrm.newCascadeInstance(_activity, DB_NAME); 
       */ 
      public  static  void  createDb(Context _activity,Object userId){ 
           //DB_NAME = Environment.getExternalStorageDirectory().getAbsolutePath()+"/pinme.db"; 
          DB_NAME =  "pinme_" + userId.toString() + ".db" ; 
              liteOrm = LiteOrm.newCascadeInstance(_activity, DB_NAME);  
              liteOrm.setDebugged( true ); 
      } 

解释一下创建数据库Cascade 和 Single 两种模式的的区别：

    LiteOrm是基类，是基础。有两个孩子实现：Cascade 和 Single。

    如果使用Single，效率最高，只保存当前Model，简单的首选。

    如果使用Cascade实例，将会无限级联操作（不会死循环），将所有与这个Model相关的实体、关系都保存下来。重点介绍下Cascade，举个例子，一个学校有10个学院（一对多），一个学院10个专业，一个专业10个班级，一个班级10个老师，一个老师10个学生（多对多关系）。只要调用cascade.save( school ); 那么这个学校，以及10 0000个学生，和他们的关系，都保存下来了。删除也一样，都删了

2、如何创建表：都说了ORM嘛，所以不需要像android原生的代码那样去写SQL语句去创建。只需要如下创建实体类

 ? 
 public  class  BaseModel  implements  Serializable { 
      // 设置为主键,自增 
      @PrimaryKey (AssignType.AUTO_INCREMENT) 
      public  int  id; 
      public  int  getId() { 
          return  id; 
      } 
      public  void  setId( int  id) { 
          this .id = id; 
      } 
 } 

 ? 
 @Table ( "Conversation" )  //指定表名，可任意写 
 public  class  Conversation  extends  BaseModel { 
       
      public  static  final  String MESSAGEID =  "messageId" ; 
      public  static  final  String ISVISIBILITY =  "isVisibility" ; 
          //这里又是一个实体类的LIST，可以理解为另外一张表。这么写，就代表 Conversation表和User表是 一对多关系 
           <span></span> private  List<User> user; 
      private  String nickName; 
      private  String headImgUrl; 
      private  String content; 
      private  String sendDate; 
      private  int  msgType; 
      private  int  subType; 
      private  int  messageId;  // 用于话题聊天的id，和私聊的 Userid 
      private  int  senderUserId; 
      private  Boolean isVisibility =  true ; 
      private  int  messageType; 
      private  int  messageNum; 
       
      //  以下省略一堆 get和set方法 
 } 

问题来了：现在实体类创建了，那什么时候创建表，如何创建表，在哪里写创建表的代码？

其实不需要去刻意的去写创建表的代码，当我们把 Conversation 对象填充数据后使用 liteOrm.save(Conversation );即可，会自动创建Conversation

下面是我自己根据我自己的需求封装的一个帮助类

 ? 
 public  class  LiteOrmDBUtil { 
       
      public  static  String DB_NAME; 
      public  static  LiteOrm liteOrm; 
       
      public  static  void  createDb(Context _activity,Object userId){ 
          DB_NAME =  "pinme_" + userId.toString() + ".db" ; 
          liteOrm = LiteOrm.newCascadeInstance(_activity, DB_NAME);  
          liteOrm.setDebugged( true ); 
      } 
       
       
      public  static  LiteOrm getLiteOrm(){ 
          return  liteOrm; 
      } 
       
      /** 
       * 插入一条记录 
       * @param t 
       */ 
      public  static  <T>  void  insert(T t){ 
          liteOrm.save(t); 
      } 
       
      /** 
       * 插入所有记录 
       * @param list 
       */ 
      public  static  <T>  void  insertAll(List<T> list){ 
          liteOrm.save(list); 
      } 
       
      /** 
       * 查询所有 
       * @param cla 
       * @return 
       */ 
      public  static  <T> List<T> getQueryAll(Class<T> cla){ 
          return  liteOrm.query(cla); 
      } 
       
      /** 
       * 查询  某字段 等于 Value的值 
       * @param cla 
       * @param field 
       * @param value 
       * @return 
       */ 
      public  static  <T> List<T> getQueryByWhere(Class<T> cla,String field,String [] value){ 
          return  liteOrm.<T>query( new  QueryBuilder(cla).where(field +  "=?" , value)); 
      } 
       
      /** 
       * 查询  某字段 等于 Value的值  可以指定从1-20，就是分页 
       * @param cla 
       * @param field 
       * @param value 
       * @param start 
       * @param length 
       * @return 
       */ 
      public  static  <T> List<T> getQueryByWhereLength(Class<T> cla,String field,String [] value, int  start, int  length){ 
          return  liteOrm.<T>query( new  QueryBuilder(cla).where(field +  "=?" , value).limit(start, length)); 
      } 
      /** 
       * 删除所有 某字段等于 Vlaue的值 
       * @param cla 
       * @param field 
       * @param value 
       */ 
      public  static  <T>  void  deleteWhere(Class<T> cla,String field,String [] value){ 
          liteOrm.delete(cla, WhereBuilder.create().where(field +  "=?" , value)); 
      } 
       
      /** 
       * 删除所有 
       * @param cla 
       */ 
      public  static  <T>  void  deleteAll(Class<T> cla){ 
          liteOrm.deleteAll(cla); 
      } 
       
      /** 
       * 仅在以存在时更新 
       * @param t 
       */ 
      public  static  <T>  void  update(T t){ 
          liteOrm.update(t,ConflictAlgorithm.Replace); 
      } 
       
       
      public  static  <T>  void  updateALL(List<T> list){ 
          liteOrm.update(list); 
      } 
       
       
      public  static  void  Text(){ 
           
          //我们把这个对象当做以填充数据的后的对象 
          Conversation mConversation =  new  Conversation(); 
           
          List<Conversation> list =  new  ArrayList<Conversation>(); 
          for  ( int  i =  0 ; i <  10 ; i++) { 
              list.add(mConversation); 
          } 
           
           
          //1、插入单条数据 
          LiteOrmDBUtil.insert(mConversation); 
           
          //2、插入多条数据 
          LiteOrmDBUtil.insertAll(list); 
           
          //3、查询Conversation表中所有记录 
          List<Conversation> list = LiteOrmDBUtil.getQueryAll(Conversation. class ); 
           
          //4、查询Conversation表中 isVisibility 字段 等于 true 的记录 
          List<Conversation> list =  LiteOrmDBUtil.getQueryByWhere(Conversation. class , Conversation.ISVISIBILITY,  new  String[]{ "true" }); 
           
          //5、查询Conversation表中 isVisibility 字段 等于 true 的记录,并且只取20条   
          List<Conversation> list =  LiteOrmDBUtil.getQueryByWhereLength(Conversation. class , Conversation.ISVISIBILITY,  new  String[]{ "true" }, 0 , 20 ); 
           
          //6、删除Conversation表中 isVisibility 字段 等于 true 的记录 
          LiteOrmDBUtil.deleteWhere(Conversation. class ,Conversation.ISVISIBILITY ,  new  String[]{ "true" }); 
           
          //7、删除所有 
          LiteOrmDBUtil.deleteAll(Conversation. class ); 
           
           
      } 
 } 