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

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

今天学习的一种框架：LiteOrm

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

       特征：

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

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

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

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

        1、LiteOrm可以自定义数据库名字已经目录。

        2、使用LiteOrm的时候哪里错了会明确的告诉你。

        3、LiteOrm体积小，专一，一个库只做一件事，是什么库就做什么事情。

2、代码预览，转载自：http://blog.csdn.net/napoleonbai/article/details/41958725[java] view plain copy

1. package com.napoleonbai.android.model;  
2.   
3. import java.io.Serializable;  
4.   
5. import com.litesuits.orm.db.annotation.Check;  
6. import com.litesuits.orm.db.annotation.Column;  
7. import com.litesuits.orm.db.annotation.Ignore;  
8. import com.litesuits.orm.db.annotation.PrimaryKey;  
9. import com.litesuits.orm.db.annotation.PrimaryKey.AssignType;  
10.   
11. /** 
12.  * 所有Model的顶层父类 
13.  *  
14.  * @author NapoleonBai 
15.  * 
16.  */  
17. public class BaseModel implements Serializable {  
18.   
19.     private static final long serialVersionUID = 1L;  
20.   
21.     // 设置为主键,自增  
22.     @PrimaryKey(AssignType.AUTO_INCREMENT)  
23.     // 取名为“_id”,如果此处不重新命名,就采用属性名称  
24.     @Column("_id")  
25.     public int id;  
26.   
27.     // @Check条件检测  
28.     @Check("description NOT NULL")  
29.     public String description = "字段描述";  
30.   
31.     @Ignore  
32.     private String ignore = "标记Ignore,并不会出现在数据库中";  
33.   
34.     @Override  
35.     public String toString() {  
36.         return "BaseModel{" + "description='" + description + '\'' + '}';  
37.     }  
38. }  

这是建立的一个顶层的Model父类,这里处理所有Model类都共有的字段，比如数据库的“_id”字段这些等等

然后我们还需要一个Model类，暂时我们用Users来替代

[java] view plain copy

1. package com.napoleonbai.android.model;  
2.   
3. import com.litesuits.orm.db.annotation.Check;  
4. import com.litesuits.orm.db.annotation.Default;  
5. import com.litesuits.orm.db.annotation.NotNull;  
6. import com.litesuits.orm.db.annotation.Table;  
7. import com.litesuits.orm.db.annotation.Unique;  
8.   
9. /** 
10.  * 用户信息类 
11.  *  
12.  * @author NapoleonBai 
13.  * 
14.  */  
15. // 创建一个名为user_table的表格  
16. @Table("user_table")  
17. public class Users extends BaseModel {  
18.     private static final long serialVersionUID = 1L;  
19.     // 非空约束 形同于@Check("userName NOT NULL")  
20.     @NotNull  
21.     private String userName;  
22.   
23.     // 性别用 0 - 1 - 2替代,0=男,1=女,2=未知  
24.     @Check("userSex >= 0 AND userSex < 3")  
25.     // 设置默认值  
26.     @Default("2")  
27.     private int userSex;  
28.   
29.     // 唯一键约束  
30.     @Unique  
31.     @NotNull  
32.     private String userPhone;  
33.   
34.     private String userEmail;  
35.   
36.     /** 
37.      * 构造方法，传入数据 
38.      *  
39.      * @param name 
40.      * @param sex 
41.      * @param phone 
42.      * @param email 
43.      */  
44.     public Users(String name, int sex, String phone, String email) {  
45.         this.userName = name;  
46.         this.userSex = sex;  
47.         this.userEmail = email;  
48.         this.userPhone = phone;  
49.     }  
50.   
51.     public Users() {  
52.     }  
53.   
54.     public String getUserName() {  
55.         return userName;  
56.     }  
57.   
58.     public void setUserName(String userName) {  
59.         this.userName = userName;  
60.     }  
61.   
62.     public int getUserSex() {  
63.         return userSex;  
64.     }  
65.   
66.     public void setUserSex(int userSex) {  
67.         this.userSex = userSex;  
68.     }  
69.   
70.     public String getUserPhone() {  
71.         return userPhone;  
72.     }  
73.   
74.     public void setUserPhone(String userPhone) {  
75.         this.userPhone = userPhone;  
76.     }  
77.   
78.     public String getUserEmail() {  
79.         return userEmail;  
80.     }  
81.   
82.     public void setUserEmail(String userEmail) {  
83.         this.userEmail = userEmail;  
84.     }  
85.   
86.     public void setUserID(int id) {  
87.         super.id = id;  
88.     }  
89. }  

什么get、set方法都不用多说了吧，这里提供了两个构造方法，一个有参一个无参，有参的就绑定数据了，无参的就创建对象的引用，先不绑定数据，各有用处吧。

@Table是指点表名，后面的@Check这些都类似，都是Archiver(LiteOrm)框架提供的，如需深入了解，请查看源码就好。

然后就看操作类了

[java] view plain copy

1. package com.napoleonbai.android.archiver;  
2.   
3. import java.util.ArrayList;  
4.   
5. import com.litesuits.android.log.Log;  
6. import com.litesuits.orm.LiteOrm;  
7. import com.litesuits.orm.db.DataBase;  
8. import com.litesuits.orm.db.assit.QueryBuilder;  
9. import com.litesuits.orm.db.model.ColumnsValue;  
10. import com.litesuits.orm.db.model.ConflictAlgorithm;  
11. import com.napoleonbai.android.model.Users;  
12.   
13. import android.app.Activity;  
14. import android.os.Bundle;  
15. import android.view.Menu;  
16. import android.view.View;  
17.   
18. public class MainActivity extends Activity {  
19.     /** 数据库引用对象 */  
20.     private DataBase mainDB;  
21.   
22.     @Override  
23.     protected void onCreate(Bundle savedInstanceState) {  
24.         super.onCreate(savedInstanceState);  
25.         setContentView(R.layout.activity_main);  
26.     }  
27.   
28.     @Override  
29.     public boolean onCreateOptionsMenu(Menu menu) {  
30.         getMenuInflater().inflate(R.menu.main, menu);  
31.         return true;  
32.     }  
33.   
34.     /** 
35.      * 按钮事件的监听 
36.      *  
37.      * @param v 
38.      */  
39.     public void onClick(View v) {  
40.         managerDB(v.getId());  
41.     }  
42.   
43.     /** 
44.      * 执行数据库操作 
45.      *  
46.      * @param v 
47.      */  
48.     private void managerDB(final int id) {  
49.         new Thread(new Runnable() {  
50.             @Override  
51.             public void run() {  
52.                 switch (id) {  
53.                 case R.id.button1:  
54.                     // 创建数据库  
55.                     if (mainDB == null) {  
56.                         // 创建数据库,传入当前上下文对象和数据库名称  
57.                         mainDB = LiteOrm.newInstance(MainActivity.this,  
58.                                 "napoleonbai.db");  
59.                     }  
60.                     break;  
61.                 case R.id.button2:  
62.                     // 新增数据  
63.                     Users mUser = new Users("NapoleonBai"  
64.                             + Thread.currentThread().getId(), 1, "1688888"  
65.                             + Thread.currentThread().getId(),  
66.                             "[e-mail]");  
67.   
68.                     mainDB.save(mUser);  
69.                     break;  
70.                 case R.id.button3:  
71.                     // 删除指定数据  
72.                     // 删除第2到第5条 ,换句话说就是删除第二、三、四、五条数据  
73.                     // 最后一个参数可为null，默认按ID升序排列  
74.                 <span style="white-space:pre">    </span> mainDB.delete(Users.class, 2, 5, "_id");  
75.                     break;  
76.                 case R.id.button4:  
77.                     // 修改数据  
78.   
79.                     // 查询得到全部数据  
80.                     ArrayList<Users> userDatas = mainDB.queryAll(Users.class);  
81.                     // 设置第一个数据的Name  
82.                     userDatas.get(0).setUserName("小白杨");  
83.                     // 修改数据  
84.                     mainDB.update(userDatas.get(0));  
85.                     break;  
86.                 case R.id.button5:  
87.                     // 查询一条数据  
88.                     //指定查询ID和查询对象  
89.                     Users u2=mainDB.queryById(11,Users.class);  
90.                     Log.i("data",u2.getUserName());  
91.                     break;  
92.                 case R.id.button6:  
93.                     // 查询全部数据  
94.                     ArrayList<Users> datas = mainDB.queryAll(Users.class);  
95.                     //得到数据库中有多少条数据  
96.                     Log.i("data", datas.size());  
97.                     break;  
98.                 default:  
99.                     break;  
100.                 }  
101.             }  
102.         }).start();  
103.   
104.     }  
105. }  

这里的界面布局是六个按钮组成的，onClick是布局中设置的点击事件监听方法，采用子线程的方式来更新数据库，当然了，这里就没有对线程进行优化，这不是重点。

重点是：代码中没有给全操作方法，当然了，一眼就能看出来，是不是呢？嘻嘻

那么就请看补充：

1.在删除数据的时候，我们只是说明了删除从某到某的数据

那么，我们如果要删除指定字段的数据呢？要删除全部数据呢？

[java] view plain copy

1. // 删除某个对象(类似于删除某条数据，比如按照ID删除)  
2. Users user = new Users();  
3. user.setUserID(1);  
4. mainDB.delete(user);  
5. // 当然，删除全部数据，就只需要使用  
6.  mainDB.deleteAll(Users.class);  

这样就好了，没错！

2.修改数据，上面小编也只是说了从数据库中查询出来，然后根据查询回来的数据进行修改，当然了，也可以得到判断ID，进行指定的数据修改，不过上面的方式

这样做的话， 显得太力不从心了。所以，那么有没有直接点的方法呢？能不能更新指定数据的指定字段，指定数据的全部数据呢?

结果是：

[java] view plain copy

1. //修改指定ID的指定字段数据  
2.                     Users u1 = new Users();  
3.                     u1.setUserID(10);  
4.                     //更改userName字段的数据  
5.                     ColumnsValue cv = new ColumnsValue(new String[] { "userName" },  
6.                             new Object[] { "大白杨" });  
7.                     //仅能在已经存在时更新：ConflictAlgorithm.Replace  
8.                     mainDB.update(u1, cv,ConflictAlgorithm.Replace);  
9.                       
10.                     //更新指定ID所有数据  
11.                     u1.setUserPhone("188888888");  
12.                     u1.setUserName("小白杨");  
13.                     mainDB.update(u1, ConflictAlgorithm.Fail);  
14.                       
15.                     //当然了,save也可以用来修改数据,类似于更改指定ID的所有数据  

没错，你看到的结果就是小编所说的那样。嘻嘻

3.查询所有数据，上面也提到了获取所有数据，当然也可以判断数据库中到底有多少条数据。

但是很多时候我们只需要判断有多少条数据，并不用取出所有数据，那么有没有方法完成呢？

而且，我们能不能进行模糊查询,按条件查询呢?

恭喜，这些都有！

[java] view plain copy

1. //如果这样去获取数据库中有多少条数据,是不是有点蠢呢？嘻嘻  
2.                     //有提供这样的方法:  
3.                     long count = mainDB.queryCount(Users.class);  
4.                       
5.                     Log.i("data", count);  
6.                       
7.                     //那么,如果想要按照条件查询呢？  
8.                     //请看如下：  
9.                     QueryBuilder qb = new QueryBuilder(Users.class)  
10.                     .columns(new String[] { "_id" })  
11.                     .appendOrderAscBy("_id")  
12.                     .appendOrderDescBy("userPhone")  
13.                     .distinct(true)  
14.                     .where("userName" + " like ?",  
15.                             new String[] { "%杨" });  
16.   
17.                     count = mainDB.queryCount(qb);  
18.                     Log.i("data", "查询出UserName中带\"杨\"字的共有"+count+"条");  

到这里，单表操作也就算完成得差不多了，最后，在退出、或者不使用数据库的时候，关闭数据库释放内存就好了

上文作者提供jar下载：http://download.csdn.net/detail/napoleonbai/8265407(使用的框架jar包)

  开源项目地址：https://github.com/litesuits/android-lite-orm