ORMLite完全解析(一)

在android中使用原始的SQLiteOpenHelper操作数据库显得过于繁琐,而且对于不是很熟悉数据库操作的人来说比较容易出现一些隐藏的漏洞。所以一般都会想到使用相关的ORMLite框架完成开发,类似于J2EE开发中的Hibernate和Mybatis等等,在提高开发效率的同时,也可以有效避免数据库操作对应用带来的潜在影响。

到现在为止,Android中ORM框架也已经有很多,比如ORMLite,Litepal,  androrm,SugarORM, GreenDAO,ActiveAndroid, Realm等等。对于他们之间的对比,可能各有长短,所谓存在即为合理。其中,ORMLite应该是使用较为广泛的一个,接下来我将通过几篇文章,结合ORMLIte的官方文档和源代码对这个框架进行分析。才疏学浅,如果有不足的地方,还请批评指正。

ORMLite官网: http://ormlite.com/,下载jar包和实例。将jar包加入项目中。

第一篇,我先结合官方实例和自己的demo让大家感受一下ORMLite的魅力,并熟悉整个流程。

尊重原创,转载请说明出处,谢谢! http://blog.csdn.net/oyangyujun

一、定义实体类

1. 注解属性和类名,对应数据库字段和表明。

2. 给定一个无参构造函数,以便查询返回实体对象。

[java] view plaincopy

<EMBED id=ZeroClipboardMovie_1 name=ZeroClipboardMovie_1 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer height=18 width=18 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=1&width=18&height=18" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">

  1. @DatabaseTable(tableName = "person")
  2. public class Person implements Serializable{
  3. private static final long serialVersionUID = 1L;
  4. @DatabaseField(generatedId = true)
  5. int id;
  6. @DatabaseField(canBeNull = true, defaultValue = "name")
  7. String name;
  8. @DatabaseField(canBeNull = true, defaultValue = "sex")
  9. String sex;
  10. @DatabaseField(canBeNull = true, defaultValue = "age")
  11. String age;
  12. @DatabaseField(canBeNull = true, defaultValue = "address")
  13. String address;
  14. @DatabaseField(canBeNull = true, defaultValue = "phone")
  15. String phone;
  16. @DatabaseField(canBeNull = true, defaultValue = "qq")
  17. String qq;
  18. @DatabaseField(canBeNull = true, defaultValue = "testField")
  19. String testField;
  20. @DatabaseField(canBeNull = true, defaultValue = "testField2")
  21. String testField2;
  22. public Person(){
  23. }

二、生成数据库配置文件

1.  先在res/raw下创建文件ormlite_config.txt

2.  继承OrmLiteCongifUtil类创建DatabaseConfigUtil工具了类,这个工具类用于生成数据库结构信息。

[java] view plaincopy

<EMBED id=ZeroClipboardMovie_2 name=ZeroClipboardMovie_2 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer height=18 width=18 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=2&width=18&height=18" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">

  1. public class DatabaseConfigUtil extends OrmLiteConfigUtil {
  2. public static void main(String[] args) throws SQLException, IOException {
  3. writeConfigFile("ormlite_config.txt");
  4. }
  5. }

3.  在java本地环境下运行该类,不能直接运行android项目。本地环境配置的方法是,右键-》Run Configurations进入运行配置面板如下,注意看是否为当前项目的该工具类。

4.  选择JRE,选中Alternate JRE,指定使用的JRE版本,官方文档中说1.5或者1.6,当然,高版本也是可以的。

5.  选择Classpath,选中Bootstrap Entries下的android,remove掉。切记保留User Entries下的文件。否则会报NoClassDefFoundError, 这里其实就是取消android应用程序的入口,直接将上面的工具类作为程序入口。

6. 最后直接run,运行完成后会在ormlite_config.txt中生成下面的配置文件内容。

这个文件是数据库升级更新的依据。这样做的原因是,运行时注解是非常号资源的过程,程序运行时通过反射获取数据表结构维护数据库信息会严重影响效率,虽然OrmLite说明其注解比Java自身的注解机制速度提高了近20倍,不过还是推荐使用这种配置文件的方式。

三、创建数据库辅助类OrmLiteSqliteOpenHelper

1.  创建OrmLite数据库的方式和通过SqliteOpenHelper的维护数据库的方式基本相同,因为OrmLiteSqliteOpenHelper是SqliteOpenHelper的直接子类。我们在项目中使用时需要继承OrmLiteSqliteOpenHelper,重写onCreate和onUpgrade方法。不过OrmLiteSqliteOpenHelper类中这两个方法都比SqliteOpenHelper中多了一个ConnectionSource参数。从字面量理解这个参数主要是用于数据库的升级更新和创建DAO。注意,每次数据模型有变化是,都必须运行OrmLiteCongifUtil工具类更新配置文件和升级数据库版本号,并在onUpgrade中完成相关操作。

[java] view plaincopy

<EMBED id=ZeroClipboardMovie_3 name=ZeroClipboardMovie_3 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer height=18 width=18 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=3&width=18&height=18" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">

  1. public class DatabaseHelper extends OrmLiteSqliteOpenHelper {
  2. // name of the database file for your application -- change to something appropriate for your app
  3. private static final String DATABASE_NAME = "helloAndroid.db";
  4. // any time you make changes to your database objects, you may have to increase the database version
  5. private static final int DATABASE_VERSION = 3;
  6. // the DAO object we use to access the SimpleData table
  7. private Dao<SimpleData, Integer> simpleDao = null;
  8. private RuntimeExceptionDao<SimpleData, Integer> simpleRuntimeDao = null;
  9. public DatabaseHelper(Context context) {
  10. super(context, DATABASE_NAME, null, DATABASE_VERSION, R.raw.ormlite_config);
  11. }
  12. /**
  13. * This is called when the database is first created. Usually you should call createTable statements here to create
  14. * the tables that will store your data.
  15. */
  16. @Override
  17. public void onCreate(SQLiteDatabase db, ConnectionSource connectionSource) {
  18. try {
  19. Log.i(DatabaseHelper.class.getName(), "onCreate");
  20. TableUtils.createTable(connectionSource, SimpleData.class);
  21. } catch (SQLException e) {
  22. Log.e(DatabaseHelper.class.getName(), "Can‘t create database", e);
  23. throw new RuntimeException(e);
  24. }
  25. // here we try inserting data in the on-create as a test
  26. RuntimeExceptionDao<SimpleData, Integer> dao = getSimpleDataDao();
  27. long millis = System.currentTimeMillis();
  28. // create some entries in the onCreate
  29. SimpleData simple = new SimpleData(millis);
  30. dao.create(simple);
  31. simple = new SimpleData(millis + 1);
  32. dao.create(simple);
  33. Log.i(DatabaseHelper.class.getName(), "created new entries in onCreate: " + millis);
  34. }
  35. /**
  36. * This is called when your application is upgraded and it has a higher version number. This allows you to adjust
  37. * the various data to match the new version number.
  38. */
  39. @Override
  40. public void onUpgrade(SQLiteDatabase db, ConnectionSource connectionSource, int oldVersion, int newVersion) {
  41. try {
  42. Log.i(DatabaseHelper.class.getName(), "onUpgrade");
  43. TableUtils.dropTable(connectionSource, SimpleData.class, true);
  44. // after we drop the old databases, we create the new ones
  45. onCreate(db, connectionSource);
  46. } catch (SQLException e) {
  47. Log.e(DatabaseHelper.class.getName(), "Can‘t drop databases", e);
  48. throw new RuntimeException(e);
  49. }
  50. }
  51. /**
  52. * Returns the Database Access Object (DAO) for our SimpleData class. It will create it or just give the cached
  53. * value.
  54. */
  55. public Dao<SimpleData, Integer> getDao() throws SQLException {
  56. if (simpleDao == null) {
  57. simpleDao = getDao(SimpleData.class);
  58. }
  59. return simpleDao;
  60. }
  61. /**
  62. * Returns the RuntimeExceptionDao (Database Access Object) version of a Dao for our SimpleData class. It will
  63. * create it or just give the cached value. RuntimeExceptionDao only through RuntimeExceptions.
  64. */
  65. public RuntimeExceptionDao<SimpleData, Integer> getSimpleDataDao() {
  66. if (simpleRuntimeDao == null) {
  67. simpleRuntimeDao = getRuntimeExceptionDao(SimpleData.class);
  68. }
  69. return simpleRuntimeDao;
  70. }
  71. /**
  72. * Close the database connections and clear any cached DAOs.
  73. */
  74. @Override
  75. public void close() {
  76. super.close();
  77. simpleDao = null;
  78. simpleRuntimeDao = null;
  79. }
  80. }

表升级对数据库数据的影响怎么解决?目前是什么情况?

四、获得DAO对象

获得DAO的方式有两种。

1.   通过OrmLiteSqliteOpenHelper暴露接口获得,OrmLiteSqliteOpenHelper中默认封装了getDao(Class<T> clazz)方法和getRuntimeExceptionDao(Class<T> clazz)方法便于获得DAO对象。这两个方法本质上是一样的都是通过DAOManage获得对应的DAO对象:

[java] view plaincopy

<EMBED id=ZeroClipboardMovie_4 name=ZeroClipboardMovie_4 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer height=18 width=18 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=4&width=18&height=18" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">

  1. /**
  2. * Get a DAO for our class. This uses the {@link DaoManager} to cache the DAO for future gets.
  3. *
  4. * <p>
  5. * NOTE: This routing does not return Dao<T, ID> because of casting issues if we are assigning it to a custom DAO.
  6. * Grumble.
  7. * </p>
  8. */
  9. public <D extends Dao<T, ?>, T> D getDao(Class<T> clazz) throws SQLException {
  10. // special reflection fu is now handled internally by create dao calling the database type
  11. Dao<T, ?> dao = DaoManager.createDao(getConnectionSource(), clazz);
  12. @SuppressWarnings("unchecked")
  13. D castDao = (D) dao;
  14. return castDao;
  15. }
  16. /**
  17. * Get a RuntimeExceptionDao for our class. This uses the {@link DaoManager} to cache the DAO for future gets.
  18. *
  19. * <p>
  20. * NOTE: This routing does not return RuntimeExceptionDao<T, ID> because of casting issues if we are assigning it to
  21. * a custom DAO. Grumble.
  22. * </p>
  23. */
  24. public <D extends RuntimeExceptionDao<T, ?>, T> D getRuntimeExceptionDao(Class<T> clazz) {
  25. try {
  26. Dao<T, ?> dao = getDao(clazz);
  27. @SuppressWarnings({ "unchecked", "rawtypes" })
  28. D castDao = (D) new RuntimeExceptionDao(dao);
  29. return castDao;
  30. } catch (SQLException e) {
  31. throw new RuntimeException("Could not create RuntimeExcepitionDao for class " + clazz, e);
  32. }
  33. }

他们的区别在于对处理异常的方式不一样。如RuntimeExceptionDao的类注释所述,RuntimeExceptionDao只是对异常信息进行了包装处理,并将其作为运行时异常重新抛出。

[java] view plaincopy

<EMBED id=ZeroClipboardMovie_5 name=ZeroClipboardMovie_5 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer height=18 width=18 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=5&width=18&height=18" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">

  1. /**
  2. * Proxy to a {@link Dao} that wraps each Exception and rethrows it as RuntimeException. You can use this if your usage
  3. * pattern is to ignore all exceptions. That‘s not a pattern that I like so it‘s not the default.
  4. *
  5. * <p>
  6. *
  7. * <pre>
  8. * RuntimeExceptionDao<Account, String> accountDao = RuntimeExceptionDao.createDao(connectionSource, Account.class);
  9. * </pre>
  10. *
  11. * </p>
  12. *
  13. * @author graywatson
  14. */
  15. public class RuntimeExceptionDao<T, ID> implements CloseableIterable<T> {

如果我们应用中的组件是通过继承OrmLiteBaseActivity等类的方式来使用ORMLite的话,可以使用派生出来的组件已有的getHelper()方法直接获得OrmLiteSqliteOpenHelper对象,然后调用我们在OrmLiteSqliteOpenHelper中暴露的接口获取对应的DAO对象。如下:

[java] view plaincopy

<EMBED id=ZeroClipboardMovie_6 name=ZeroClipboardMovie_6 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer height=18 width=18 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=6&width=18&height=18" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">

  1. RuntimeExceptionDao<SimpleData, Integer> simpleDao = getHelper().getSimpleDataDao();

2.  第二种获得DAO的方式是直接通过DAOManager获得。使用这种方式需要一个ConnectionSource参数,和实体类的Class对象,ConnectionSource参数可以通过OrmLiteSqliteOpenHelper的getConnectionSource()方法获得。这两个方法定义如下。

DAOManager中的createDAO方法。

[java] view plaincopy

<EMBED id=ZeroClipboardMovie_7 name=ZeroClipboardMovie_7 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer height=18 width=18 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=7&width=18&height=18" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">

  1. /**
  2. * Helper method to create a DAO object without having to define a class. This checks to see if the DAO has already
  3. * been created. If not then it is a call through to {@link BaseDaoImpl#createDao(ConnectionSource, Class)}.
  4. */
  5. public synchronized static <D extends Dao<T, ?>, T> D createDao(ConnectionSource connectionSource, Class<T> clazz)
  6. throws SQLException {

OrmLiteSqliteOpenHelper中的getConnectionSource方法。

[html] view plaincopy

<EMBED id=ZeroClipboardMovie_8 name=ZeroClipboardMovie_8 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer height=18 width=18 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=8&width=18&height=18" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">

  1. protected AndroidConnectionSource connectionSource = new AndroidConnectionSource(this);
  2. /**
  3. * Get the connection source associated with the helper.
  4. */
  5. public ConnectionSource getConnectionSource() {
  6. if (!isOpen) {
  7. // we don‘t throw this exception, but log it for debugging purposes
  8. logger.warn(new IllegalStateException(), "Getting connectionSource was called after closed");
  9. }
  10. return connectionSource;
  11. }

五、在Activity中使用DAO操作数据库。

1.  获得Helper对象

通过上面的分析可知,DAO可以通过Helper对象获得,也建议使用这种方式。而且使用DAO操作数据库才是我们的想要的过程,对于这一点,ORMLite本身也考虑的非常周到,他给我们提供了一些相应的快捷实现类,包括OrmLiteBaseActivity, OrmLiteBaseActivityGroup, OrmLiteBaseListActivity, OrmLiteBaseService, OrmLiteBaseTabActivity等。仔细分析其源码,发现实现方式都是一样的,这里以OrmLiteBaseActivity为例。完整源代码如下:

[java] view plaincopy

<EMBED id=ZeroClipboardMovie_9 name=ZeroClipboardMovie_9 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer height=18 width=18 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=9&width=18&height=18" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">

  1. /**
  2. * Base class to use for activities in Android.
  3. *
  4. * You can simply call {@link #getHelper()} to get your helper class, or {@link #getConnectionSource()} to get a
  5. * {@link ConnectionSource}.
  6. *
  7. * The method {@link #getHelper()} assumes you are using the default helper factory -- see {@link OpenHelperManager}. If
  8. * not, you‘ll need to provide your own helper instances which will need to implement a reference counting scheme. This
  9. * method will only be called if you use the database, and only called once for this activity‘s life-cycle. ‘close‘ will
  10. * also be called once for each call to createInstance.
  11. *
  12. * @author graywatson, kevingalligan
  13. */
  14. public abstract class OrmLiteBaseActivity<H extends OrmLiteSqliteOpenHelper> extends Activity {
  15. private volatile H helper;
  16. private volatile boolean created = false;
  17. private volatile boolean destroyed = false;
  18. private static Logger logger = LoggerFactory.getLogger(OrmLiteBaseActivity.class);
  19. /**
  20. * Get a helper for this action.
  21. */
  22. public H getHelper() {
  23. if (helper == null) {
  24. if (!created) {
  25. throw new IllegalStateException("A call has not been made to onCreate() yet so the helper is null");
  26. } else if (destroyed) {
  27. throw new IllegalStateException(
  28. "A call to onDestroy has already been made and the helper cannot be used after that point");
  29. } else {
  30. throw new IllegalStateException("Helper is null for some unknown reason");
  31. }
  32. } else {
  33. return helper;
  34. }
  35. }
  36. /**
  37. * Get a connection source for this action.
  38. */
  39. public ConnectionSource getConnectionSource() {
  40. return getHelper().getConnectionSource();
  41. }
  42. @Override
  43. protected void onCreate(Bundle savedInstanceState) {
  44. if (helper == null) {
  45. helper = getHelperInternal(this);
  46. created = true;
  47. }
  48. super.onCreate(savedInstanceState);
  49. }
  50. @Override
  51. protected void onDestroy() {
  52. super.onDestroy();
  53. releaseHelper(helper);
  54. destroyed = true;
  55. }
  56. /**
  57. * This is called internally by the class to populate the helper object instance. This should not be called directly
  58. * by client code unless you know what you are doing. Use {@link #getHelper()} to get a helper instance. If you are
  59. * managing your own helper creation, override this method to supply this activity with a helper instance.
  60. *
  61. * <p>
  62. * <b> NOTE: </b> If you override this method, you most likely will need to override the
  63. * {@link #releaseHelper(OrmLiteSqliteOpenHelper)} method as well.
  64. * </p>
  65. */
  66. protected H getHelperInternal(Context context) {
  67. @SuppressWarnings({ "unchecked", "deprecation" })
  68. H newHelper = (H) OpenHelperManager.getHelper(context);
  69. logger.trace("{}: got new helper {} from OpenHelperManager", this, newHelper);
  70. return newHelper;
  71. }
  72. /**
  73. * Release the helper instance created in {@link #getHelperInternal(Context)}. You most likely will not need to call
  74. * this directly since {@link #onDestroy()} does it for you.
  75. *
  76. * <p>
  77. * <b> NOTE: </b> If you override this method, you most likely will need to override the
  78. * {@link #getHelperInternal(Context)} method as well.
  79. * </p>
  80. */
  81. protected void releaseHelper(H helper) {
  82. OpenHelperManager.releaseHelper();
  83. logger.trace("{}: helper {} was released, set to null", this, helper);
  84. this.helper = null;
  85. }
  86. @Override
  87. public String toString() {
  88. return getClass().getSimpleName() + "@" + Integer.toHexString(super.hashCode());
  89. }
  90. }

通过源码可以知道,这些扩展类,都是内部持有了一个对应的OrmLiteSqliteOpenHelper对象。并在Activity的onCreate方法中初始化,在onDestroyed方法中销毁释放资源。

这里涉及到一个OpenHelperManager类,这个类是OrmLiteSqliteOpenHelper的工具类,用于管理数据库连接。完整的解释如下:

[java] view plaincopy

<EMBED id=ZeroClipboardMovie_10 name=ZeroClipboardMovie_10 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer height=18 width=18 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=10&width=18&height=18" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">

  1. /**
  2. * This helps organize and access database connections to optimize connection sharing. There are several schemes to
  3. * manage the database connections in an Android app, but as an app gets more complicated, there are many potential
  4. * places where database locks can occur. This class allows database connection sharing between multiple threads in a
  5. * single app.
  6. *
  7. * This gets injected or called with the {@link OrmLiteSqliteOpenHelper} class that is used to manage the database
  8. * connection. The helper instance will be kept in a static field and only released once its internal usage count goes
  9. * to 0.
  10. *
  11. * The {@link SQLiteOpenHelper} and database classes maintain one connection under the hood, and prevent locks in the
  12. * java code. Creating multiple connections can potentially be a source of trouble. This class shares the same
  13. * connection instance between multiple clients, which will allow multiple activities and services to run at the same
  14. * time.
  15. *
  16. * Every time you use the helper, you should call {@link #getHelper(Context)} or {@link #getHelper(Context, Class)}.
  17. * When you are done with the helper you should call {@link #releaseHelper()}.
  18. *
  19. * @author graywatson, kevingalligan
  20. */
  21. public class OpenHelperManager {

翻译:这个类用于组织和获取数据库连接,优化连接共享。在一个app中,可能有多个模式来管理数据库连接,但是当app变得愈加复杂时,就会存在很多潜在的数据库锁发生点。这个类允许数据库连接在同一app的多个线程中共享。

这个用于注入OrmLiteSqliteOpenHelper,之后,OrmLiteSqliteOpenHelper的实例会作为一个静态属性被持有。只有当其内部的使用数变为0时才会被释放。

SQLiteOpenHelper和数据库类在这个引擎下持有一个连接,并且防止java代码中发生死锁。创建多个连接可能会存在潜在的安全问题。这个类在多个客户端中持有相同的连接实例, 并允许多个Activity和service在同一时刻运行。

每次使用这个Helper是,你应该调用getHelper(Context)或者getHelper(Context,Class),操作完成时,应该调用releaseHelper()进行释放。

处理上面的解释外,可以注意到,OrmLiteBaseActivity中的OrmLiteSqliteOpenHelper对象被修饰为volatile。这个修饰符的作用是修饰被不同线程访问和修改的变量。如果没有volatile,基本上会导致这样的结果:要么无法编写多线程程序,要么编译器失去大量优化的机会。

同时也可以想到,如果我们不想让自己的Activity继承OrmLite中的基类,大可按照其内部实现方式,将写代码迁移到我们自己的BaseActivity中。

2.  通过Helper获得的DAO对象操作数据库

到此为止,我们知道了怎么获得Helper并通过Helper获得DAO,或者RuntimeExceptionDao,下面是对数据库进行操作的基本方式。

官方的HelloAndroid中使用到了三种基本操作,插入,查询,删除。

方式如下: 插入数据的代码在Helper类的onCreate中,当然在其他地方是毫无疑问的可以的。创建对象,给对象赋值,然后直接通过DAO进行create即可(看上面Helper类的实现)。

其次是查询,官方实例中查询和删除在HelloAndroid中进行的,都是直接通过Dao的实例调用响应的方法:

[java] view plaincopy

<EMBED id=ZeroClipboardMovie_11 name=ZeroClipboardMovie_11 type=application/x-shockwave-flash align=middle pluginspage=http://www.macromedia.com/go/getflashplayer height=18 width=18 src=http://static.blog.csdn.net/scripts/ZeroClipboard/ZeroClipboard.swf wmode="transparent" flashvars="id=11&width=18&height=18" allowfullscreen="false" allowscriptaccess="always" bgcolor="#ffffff" quality="best" menu="false" loop="false">

  1. // get our dao
  2. RuntimeExceptionDao<SimpleData, Integer> simpleDao = getHelper().getSimpleDataDao();
  3. // query for all of the data objects in the database
  4. List<SimpleData> list = simpleDao.queryForAll();
  5. // our string builder for building the content-view
  6. StringBuilder sb = new StringBuilder();
  7. sb.append("got ").append(list.size()).append(" entries in ").append(action).append("\n");
  8. // if we already have items in the database
  9. int simpleC = 0;
  10. for (SimpleData simple : list) {
  11. sb.append("------------------------------------------\n");
  12. sb.append("[").append(simpleC).append("] = ").append(simple).append("\n");
  13. simpleC++;
  14. }
  15. sb.append("------------------------------------------\n");
  16. for (SimpleData simple : list) {
  17. simpleDao.delete(simple);
  18. sb.append("deleted id ").append(simple.id).append("\n");
  19. Log.i(LOG_TAG, "deleting simple(" + simple.id + ")");
  20. simpleC++;
  21. }

当然快捷操作方法还有很多,使用方式都是类似的,后面再分析。

时间: 2024-10-05 04:55:13

ORMLite完全解析(一)的相关文章

orm查询语法参考文章

1.参考博客 http://blog.csdn.net/OyangYujun/article/details/45938905 ORMLite完全解析(三)官方文档第三章.自定义查询构造器 Custom Query Builder 实现()括号查询功能.上面的三种调用方式会生成相同的sql语句.对于混合mixANDs和ORs的复杂查询而言,最后一种格式必须正确组装 ,如下面这个查询: Where<Account, String> where = queryBuilder.where(); wh

谈谈我的入门级实体框架Loogn.OrmLite

每次看到有新的ORM的时候,我总会留意一下,因为自己也写过一个这样的框架,人总是有比较之心的.我可能会down下来跑一跑,也可能不会这么做,这个取决于跑起来的难易程度.我是很懒的,有XML配置或其他稍微不直观的设置的,我总是懒得看.每当笔者谈论自己的ORM的时候,总会拿EF和Dapper说事儿,EF算官方的吧,Dapper则以效率著称.但是我很奇怪为什么ServiceStack.OrmLite这么NB的一个ORM却鲜为人提.我真想为它说一句话:.net的ORM框架中有一个非常优秀的成员叫Serv

Android 开源项目android-open-project工具库解析之(一) 依赖注入,图片缓存,网络相关,数据库orm工具包,Android公共库

一.依赖注入DI 通过依赖注入减少View.服务.资源简化初始化,事件绑定等重复繁琐工作 AndroidAnnotations(Code Diet) android快速开发框架 项目地址:https://github.com/excilys/androidannotations 文档介绍:https://github.com/excilys/androidannotations/wiki 官网网址:http://androidannotations.org/ 特点:(1) 依赖注入:包括view

Android 数据库框架ormlite 使用精要

Android 数据库框架ormlite 使用精要 前言 本篇博客记录一下笔者在实际开发中使用到的一个数据库框架,这个可以让我们快速实现数据库操作,避免频繁手写sql,提高我们的开发效率,减少出错的机率. ormlite是什么? 首先可以去它的官网看看www.ormlite.com,它的英文全称是Object Relational Mapping,意思是对象关系映射:如果接触过Java EE开发的,一定知道Java Web开发就有一个类似的数据库映射框架--Hibernate.简单来说,就是我们

C++工程编译之“error LNK2001: 无法解析的外部符号”

今天一整天都在折腾“error LNK2001: 无法解析的外部符号”,就在头疼不已的时候,总算是找到问题原因了:各个动态链接库的编译方式必须统一才行,要不然很容易对库函数的引用产生冲突.简单来说就是,如果使用的第三方函数库编译方式采用/MD,那么主工程也应该使用/MD.我使用了libevent,而主工程默认采用/MT,所以需要忽略一大堆的函数库,我还纳闷呢,怎么会这么奇怪!!今天总算是解决了长久以来的困惑了. 下面引用一篇文章的描述:[Z]VC运行库版本不同导致链接.LIB静态库时发生重复定义

防止恶意解析——禁止通过IP直接访问网站

一.什么是恶意解析 一般情况下,要使域名能访问到网站需要两步,第一步,将域名解析到网站所在的主机,第二步,在web服务器中将域名与相应的网站绑定.但是,如果通过主机IP能直接访问某网站,那么把域名解析到这个IP也将能访问到该网站,而无需在主机上绑定,也就是说任何人将任何域名解析到这个IP就能访问到这个网站.可能您并不介意通过别人的域名访问到您的网站,但是如果这个域名是未备案域名呢?一旦被查出,封IP.拔线甚至罚款的后果都是需要您来承担的.某些别有用心的人,通过将未备案域名解析到别人的主机上,使其

.NET深入解析LINQ框架(五:IQueryable、IQueryProvider接口详解)

阅读目录: 1.环路执行对象模型.碎片化执行模型(假递归式调用) 2.N层对象执行模型(纵横向对比链式扩展方法) 3.LINQ查询表达式和链式查询方法其实都是空壳子 4.详细的对象结构图(对象的执行原理) 5.IQueryable<T>与IQueryProvider一对一的关系能否改成一对多的关系 6.完整的自定义查询 1]. 环路执行对象模型.碎片化执行模型(假递归式调用) 这个主题扯的可能有点远,但是它关系着整个LINQ框架的设计结构,至少在我还没有搞懂LINQ的本意之前,在我脑海里一直频

.NET深入解析LINQ框架(一:LINQ优雅的前奏)

阅读目录: 1.LINQ简述 2.LINQ优雅前奏的音符 2.1.隐式类型 (由编辑器自动根据表达式推断出对象的最终类型) 2.2.对象初始化器 (简化了对象的创建及初始化的过程) 2.3.Lambda表达式 (对匿名方法的改进,加入了委托签名的类型推断并很好的与表达式树的结合) 2.4.扩展方法 (允许在不修改类型的内部代码的情况下为类型添加独立的行为) 2.5.匿名类型 (由对象初始化器推断得出的类型,该类型在编译后自动创建) 2.6.表达式目录树(用数据结构表示程序逻辑代码) 3.LINQ

.NET深入解析LINQ框架(二:LINQ优雅的前奏)

阅读目录: 1.LINQ框架的主要设计模型 1.1.链式设计模式 (以流水线般的链接方式设计系统逻辑) 1.2.链式查询方法(逐步加工查询表达式中的每一个工作点) 2.LINQ框架的核心设计原理 2.1.托管语言之上的语言(LINQ查询表达式) 2.2.托管语言构造的基础(LINQ依附通用接口与查询操作符对应的方法对接) 2.3.深入IEnumerable.IEnumerable<T>.Enumerable(LINQ to Object框架的入口) 2.4.深入IQueryable.IQuer