Android ORMLite 框架的入门用法

时间：2023-09-30 10:06:50

大家在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 框架的使用 将对其用法进行深入的介绍。

源码点击下载

相关文章