Android ORMLite 框架的入门用法

大家在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

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

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

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

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

3、编写DAO类

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

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

这里我们需要继承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的获取：

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、测试

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

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

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

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

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

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

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

源码点击下载