Android ORMLite 框架的入门用法

Posted 2020-07-25 taoboy

转载请标明出处：http://blog.csdn.net/lmj623565791/article/details/39121377

大家在Android项目中或多或少的都会使用数据库，为了提高我们的开发效率，当然少不了数据库ORM框架了，尤其是某些数据库操作特别频繁的app；本篇博客将详细介绍ORMLite的简易用法。

下面开始介绍ORMLite的入门用法~

1、下载 ORMLite Jar

首先去ORMLite官网下载jar包，对于android为：ormlite-android-4.48.jar 和 ormlite-core-4.48.jar ；

ps:访问不了的朋友，文章末尾会把jar、源码、doc与本篇博客例子一起打包提供给大家下载。

2、配置Bean类

有了jar,我们直接新建一个项目为：zhy_ormlite，然后把jar拷贝到libs下。

然后新建一个包：com.zhy.zhy_ormlite.bean专门用于存放项目中的Bean，首先新建一个User.Java

 

[java] view plain copy

 

 

1. package com.zhy.zhy_ormlite.bean;  
2.   
3. import com.j256.ormlite.field.DatabaseField;  
4. import com.j256.ormlite.table.DatabaseTable;  
5.   
6. @DatabaseTable(tableName = "tb_user")  
7. public class User  
8. {  
9.     @DatabaseField(generatedId = true)  
10.     private int id;  
11.     @DatabaseField(columnName = "name")  
12.     private String name;  
13.     @DatabaseField(columnName = "desc")  
14.     private String desc;  
15.   
16.     public User()  
17.     {  
18.     }  
19.   
20.     public User(String name, String desc)  
21.     {  
22.         this.name = name;  
23.         this.desc = desc;  
24.     }  
25.   
26.     public int getId()  
27.     {  
28.         return id;  
29.     }  
30.   
31.     public void setId(int id)  
32.     {  
33.         this.id = id;  
34.     }  
35.   
36.     public String getName()  
37.     {  
38.         return name;  
39.     }  
40.   
41.     public void setName(String name)  
42.     {  
43.         this.name = name;  
44.     }  
45.   
46.     public String getDesc()  
47.     {  
48.         return desc;  
49.     }  
50.   
51.     public void setDesc(String desc)  
52.     {  
53.         this.desc = desc;  
54.     }  
55.   
56. }  

首先在User类上添加@DatabaseTable(tableName = "tb_user")，标明这是数据库中的一张表，标明为tb_user

 

然后分别在属性上添加@DatabaseField(columnName = "name") ，columnName的值为该字段在数据中的列名

@DatabaseField(generatedId = true) ，generatedId 表示id为主键且自动生成

3、编写DAO类

原生的数据库操作，需要继承SQLiteOpenHelper，这里我们需要继承OrmLiteSqliteOpenHelper，看代码：

 

[java] view plain copy

 

 

1. package com.zhy.zhy_ormlite.db;  
2.   
3. import java.sql.SQLException;  
4.   
5. import android.content.Context;  
6. import android.database.sqlite.SQLiteDatabase;  
7.   
8. import com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper;  
9. import com.j256.ormlite.dao.Dao;  
10. import com.j256.ormlite.support.ConnectionSource;  
11. import com.j256.ormlite.table.TableUtils;  
12. import com.zhy.zhy_ormlite.bean.User;  
13.   
14. public class DatabaseHelper extends OrmLiteSqliteOpenHelper  
15. {  
16.   
17.     private static final String TABLE_NAME = "sqlite-test.db";  
18.     /** 
19.      * userDao ，每张表对于一个 
20.      */  
21.     private Dao<User, Integer> userDao;  
22.   
23.     private DatabaseHelper(Context context)  
24.     {  
25.         super(context, TABLE_NAME, null, 2);  
26.     }  
27.   
28.     @Override  
29.     public void onCreate(SQLiteDatabase database,  
30.             ConnectionSource connectionSource)  
31.     {  
32.         try  
33.         {  
34.             TableUtils.createTable(connectionSource, User.class);  
35.         } catch (SQLException e)  
36.         {  
37.             e.printStackTrace();  
38.         }  
39.     }  
40.   
41.     @Override  
42.     public void onUpgrade(SQLiteDatabase database,  
43.             ConnectionSource connectionSource, int oldVersion, int newVersion)  
44.     {  
45.         try  
46.         {  
47.             TableUtils.dropTable(connectionSource, User.class, true);  
48.             onCreate(database, connectionSource);  
49.         } catch (SQLException e)  
50.         {  
51.             e.printStackTrace();  
52.         }  
53.     }  
54.   
55.     private static DatabaseHelper instance;  
56.   
57.     /** 
58.      * 单例获取该Helper 
59.      *  
60.      * @param context 
61.      * @return 
62.      */  
63.     public static synchronized DatabaseHelper getHelper(Context context)  
64.     {  
65.         if (instance == null)  
66.         {  
67.             synchronized (DatabaseHelper.class)  
68.             {  
69.                 if (instance == null)  
70.                     instance = new DatabaseHelper(context);  
71.             }  
72.         }  
73.   
74.         return instance;  
75.     }  
76.   
77.     /** 
78.      * 获得userDao 
79.      *  
80.      * @return 
81.      * @throws SQLException 
82.      */  
83.     public Dao<User, Integer> getUserDao() throws SQLException  
84.     {  
85.         if (userDao == null)  
86.         {  
87.             userDao = getDao(User.class);  
88.         }  
89.         return userDao;  
90.     }  
91.   
92.     /** 
93.      * 释放资源 
94.      */  
95.     @Override  
96.     public void close()  
97.     {  
98.         super.close();  
99.         userDao = null;  
100.     }  
101.   
102. }  

 

这里我们需要继承OrmLiteSqliteOpenHelper，其实就是间接继承了SQLiteOpenHelper

然后需要实现两个方法：

1、onCreate(SQLiteDatabase database,ConnectionSource connectionSource)

创建表，我们直接使用ormlite提供的TableUtils.createTable(connectionSource, User.class);进行创建~

2、onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion)

更新表，使用ormlite提供的TableUtils.dropTable(connectionSource, User.class, true);进行删除操作~

删除完成后，别忘了，创建操作：onCreate(database, connectionSource);

 

然后使用单例公布出一个创建实例的方法，getHelper用于获取我们的help实例；

最后我们可能会有很多表嘛，每个表一般我们都会单独写个Dao用于操作，这里为了简单我并没有抽取出来，直接写在helper中：

比如UserDao的获取：

 

[java] view plain copy

 

 

1. /** 
2.      * 获得userDao 
3.      *  
4.      * @return 
5.      * @throws SQLException 
6.      */  
7.     public Dao<User, Integer> getUserDao() throws SQLException  
8.     {  
9.         if (userDao == null)  
10.         {  
11.             userDao = getDao(User.class);  
12.         }  
13.         return userDao;  
14.     }  

然后通过获取到的Dao就可以进行User的一些常用的操作了。

 

4、测试

最后是测试，我们直接创建了一个测试类进行测试~~~

 

[java] view plain copy

 

 

1. package com.zhy.zhy_ormlite.test;  
2.   
3. import java.sql.SQLException;  
4. import java.util.List;  
5.   
6. import com.zhy.zhy_ormlite.bean.User;  
7. import com.zhy.zhy_ormlite.db.DatabaseHelper;  
8.   
9. import android.test.AndroidTestCase;  
10. import android.util.Log;  
11.   
12. public class OrmLiteDbTest extends AndroidTestCase  
13. {  
14.   
15.     public void testAddUser()  
16.     {  
17.   
18.         User u1 = new User("zhy", "2B青年");  
19.         DatabaseHelper helper = DatabaseHelper.getHelper(getContext());  
20.         try  
21.         {  
22.             helper.getUserDao().create(u1);  
23.             u1 = new User("zhy2", "2B青年");  
24.             helper.getUserDao().create(u1);  
25.             u1 = new User("zhy3", "2B青年");  
26.             helper.getUserDao().create(u1);  
27.             u1 = new User("zhy4", "2B青年");  
28.             helper.getUserDao().create(u1);  
29.             u1 = new User("zhy5", "2B青年");  
30.             helper.getUserDao().create(u1);  
31.             u1 = new User("zhy6", "2B青年");  
32.             helper.getUserDao().create(u1);  
33.               
34.             testList();  
35.               
36.               
37.         } catch (SQLException e)  
38.         {  
39.             e.printStackTrace();  
40.         }  
41.     }  
42.   
43.     public void testDeleteUser()  
44.     {  
45.         DatabaseHelper helper = DatabaseHelper.getHelper(getContext());  
46.         try  
47.         {  
48.             helper.getUserDao().deleteById(2);  
49.         } catch (SQLException e)  
50.         {  
51.             e.printStackTrace();  
52.         }  
53.     }  
54.   
55.     public void testUpdateUser()  
56.     {  
57.         DatabaseHelper helper = DatabaseHelper.getHelper(getContext());  
58.         try  
59.         {  
60.             User u1 = new User("zhy-android", "2B青年");  
61.             u1.setId(3);  
62.             helper.getUserDao().update(u1);  
63.               
64.         } catch (SQLException e)  
65.         {  
66.             e.printStackTrace();  
67.         }  
68.     }  
69.   
70.     public void testList()  
71.     {  
72.         DatabaseHelper helper = DatabaseHelper.getHelper(getContext());  
73.         try  
74.         {  
75.             User u1 = new User("zhy-android", "2B青年");  
76.             u1.setId(2);  
77.             List<User> users = helper.getUserDao().queryForAll();  
78.             Log.e("TAG", users.toString());  
79.         } catch (SQLException e)  
80.         {  
81.             e.printStackTrace();  
82.         }  
83.     }  
84.   
85. }  

简单测试了下CURD，使用AndroidTestCase记得配置下环境~~~

 

用起来是不是还是非常方便的，不过还是建议大家例如User的数据库操作，单独抽取出来为UserDao，如下：

 

[java] view plain copy

 

 

1. package com.zhy.zhy_ormlite.db;  
2.   
3. import java.sql.SQLException;  
4.   
5. import android.content.Context;  
6.   
7. import com.zhy.zhy_ormlite.bean.User;  
8.   
9. public class UserDao  
10. {  
11.     private Context context;  
12.   
13.     public UserDao(Context context)  
14.     {  
15.         this.context = context;  
16.     }  
17.   
18.     public void add(User user)  
19.     {  
20.         try  
21.         {  
22.             DatabaseHelper.getHelper(context).getUserDao().create(user);  
23.         } catch (SQLException e)  
24.         {  
25.         }  
26.     }//......  
27.   
28. }  

注：ORMLite还提供了一些基类ORMLiteBaseActivity，ORMLiteBaseService之类的，便于数据库操作的，这里不做考虑，毕竟项目中很大可能自己也需要继承自己的BaseActvity之类的。

 

 

上面简单介绍了如何使用ORMLite框架，Android 快速开发系列 ORMLite 框架的使用 将对其用法进行深入的介绍。

 

 

源码点击下载