0

Android 快速开发系列 ORMLite 框架最佳实践

转载请标明出处:http://blog.csdn.net/lmj623565791/article/details/39122981,本文出自【张鸿洋的博客】

上一篇已经对ORMLite框架做了简单的介绍:Android ORMLite 框架的入门用法~~本篇将介绍项目可能会使用到的一些用法,也为我们的使用ORMLite框架总结出一个较合理的用法。

通过上一篇的了解,我们使用ORMLite,需要自己写一个DatabaseHelper去继承OrmLiteSqliteOpenHelper,下面我们首先给出一个我认为比较靠谱的Helper的写法:

1、DatabaseHelper

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

1、整个DatabaseHelper使用单例只对外公布出一个对象,保证app中只存在一个SQLite Connection , 参考文章:http://www.touchlab.co/2011/10/single-sqlite-connection/

2、我们对每个Bean创建一个XXXDao来处理当前Bean的数据库操作,当然真正去和数据库打交道的对象,通过上面代码中的getDao(T t)进行获取

getDao为一个泛型方法,会根据传入Class对象进行创建Dao,并且使用一个Map来保持所有的Dao对象,只有第一次调用时才会去调用底层的getDao()。

2、Bean的Dao

  1. package com.zhy.zhy_ormlite.db;
  2. import java.sql.SQLException;
  3. import android.content.Context;
  4. import com.j256.ormlite.dao.Dao;
  5. import com.zhy.zhy_ormlite.bean.User;
  6. public class UserDao
  7. {
  8.     private Context context;
  9.     private Dao<User, Integer> userDaoOpe;
  10.     private DatabaseHelper helper;
  11.     public UserDao(Context context)
  12.     {
  13.         this.context = context;
  14.         try
  15.         {
  16.             helper = DatabaseHelper.getHelper(context);
  17.             userDaoOpe = helper.getDao(User.class);
  18.         } catch (SQLException e)
  19.         {
  20.             e.printStackTrace();
  21.         }
  22.     }
  23.     /**
  24.      * 增加一个用户
  25.      * @param user
  26.      */
  27.     public void add(User user)
  28.     {
  29.         try
  30.         {
  31.             userDaoOpe.create(user);
  32.         } catch (SQLException e)
  33.         {
  34.             e.printStackTrace();
  35.         }
  36.     }//…other operations
  37. }

我们的所有的XXXDao遵循以上的风格~

好了,基本了解了我们的代码的结构~~ps:如果觉得不合理可以留言指出,如果觉得不能接收,直接忽略。。。

3、ORMLite外键引用

现在我们有两张表一张User,一张Article;

Article中当然需要存储User的主键,作为关联~~那么在ORMLite中如何做到呢?

可能有人会直接在Article中声明一个int类型userId属性,当作普通属性处理搞定,这种做法并没有做,但是没有体现出面向对象的思想。

面向对象是这样的:Article属于某个User

类这么定义:

  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_article”)
  5. public class Article
  6. {
  7.     @DatabaseField(generatedId = true)
  8.     private int id;
  9.     @DatabaseField
  10.     private String title;
  11.     @DatabaseField(canBeNull = true, foreign = true, columnName = “user_id”)
  12.     private User user;
  13.     public int getId()
  14.     {
  15.         return id;
  16.     }
  17.     public void setId(int id)
  18.     {
  19.         this.id = id;
  20.     }
  21.     public String getTitle()
  22.     {
  23.         return title;
  24.     }
  25.     public void setTitle(String title)
  26.     {
  27.         this.title = title;
  28.     }
  29.     public User getUser()
  30.     {
  31.         return user;
  32.     }
  33.     public void setUser(User user)
  34.     {
  35.         this.user = user;
  36.     }
  37.     @Override
  38.     public String toString()
  39.     {
  40.         return “Article [id=” + id + “, title=” + title + “, user=” + user
  41.                 + “]”;
  42.     }
  43. }

不会去定义一个int类型的userId,而是直接定义一个User成员变量,表示本Article属于该User;

然后在User user属性上添加: @DatabaseField(canBeNull = true, foreign = true, columnName = “user_id”)

canBeNull -表示不能为null;foreign=true表示是一个外键;columnName 列名

User类暂且就两个属性:

  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.     public User()
  12.     {
  13.     }
  14.     public int getId()
  15.     {
  16.         return id;
  17.     }
  18.     public void setId(int id)
  19.     {
  20.         this.id = id;
  21.     }
  22.     public String getName()
  23.     {
  24.         return name;
  25.     }
  26.     public void setName(String name)
  27.     {
  28.         this.name = name;
  29.     }
  30.     @Override
  31.     public String toString()
  32.     {
  33.         return “User [id=” + id + “, name=” + name
  34.                 + “]”;
  35.     }
  36. }

现在看我们的ArticleDao

  1. package com.zhy.zhy_ormlite.db;
  2. import java.sql.SQLException;
  3. import java.util.List;
  4. import android.content.Context;
  5. import com.j256.ormlite.dao.Dao;
  6. import com.zhy.zhy_ormlite.bean.Article;
  7. import com.zhy.zhy_ormlite.bean.User;
  8. public class ArticleDao
  9. {
  10.     private Dao<Article, Integer> articleDaoOpe;
  11.     private DatabaseHelper helper;
  12.     @SuppressWarnings(“unchecked”)
  13.     public ArticleDao(Context context)
  14.     {
  15.         try
  16.         {
  17.             helper = DatabaseHelper.getHelper(context);
  18.             articleDaoOpe = helper.getDao(Article.class);
  19.         } catch (SQLException e)
  20.         {
  21.             e.printStackTrace();
  22.         }
  23.     }
  24.     /**
  25.      * 添加一个Article
  26.      * @param article
  27.      */
  28.     public void add(Article article)
  29.     {
  30.         try
  31.         {
  32.             articleDaoOpe.create(article);
  33.         } catch (SQLException e)
  34.         {
  35.             e.printStackTrace();
  36.         }
  37.     }
  38.     /**
  39.      * 通过Id得到一个Article
  40.      * @param id
  41.      * @return
  42.      */
  43.     @SuppressWarnings(“unchecked”)
  44.     public Article getArticleWithUser(int id)
  45.     {
  46.         Article article = null;
  47.         try
  48.         {
  49.             article = articleDaoOpe.queryForId(id);
  50.             helper.getDao(User.class).refresh(article.getUser());
  51.         } catch (SQLException e)
  52.         {
  53.             e.printStackTrace();
  54.         }
  55.         return article;
  56.     }
  57.     /**
  58.      * 通过Id得到一篇文章
  59.      * @param id
  60.      * @return
  61.      */
  62.     public Article get(int id)
  63.     {
  64.         Article article = null;
  65.         try
  66.         {
  67.             article = articleDaoOpe.queryForId(id);
  68.         } catch (SQLException e)
  69.         {
  70.             e.printStackTrace();
  71.         }
  72.         return article;
  73.     }
  74.     /**
  75.      * 通过UserId获取所有的文章
  76.      * @param userId
  77.      * @return
  78.      */
  79.     public List<Article> listByUserId(int userId)
  80.     {
  81.         try
  82.         {
  83.             return articleDaoOpe.queryBuilder().where().eq(“user_id”, userId)
  84.                     .query();
  85.         } catch (SQLException e)
  86.         {
  87.             e.printStackTrace();
  88.         }
  89.         return null;
  90.     }
  91. }

接下来看我们的测试类:

  1. public class OrmLiteDbTest extends AndroidTestCase
  2. {
  3.     public void testAddArticle()
  4.     {
  5.         User u = new User();
  6.         u.setName(“张鸿洋”);
  7.         new UserDao(getContext()).add(u);
  8.         Article article = new Article();
  9.         article.setTitle(“ORMLite的使用”);
  10.         article.setUser(u);
  11.         new ArticleDao(getContext()).add(article);
  12.     }
  13.     public void testGetArticleById()
  14.     {
  15.         Article article = new ArticleDao(getContext()).get(1);
  16.         L.e(article.getUser() + ” , “ + article.getTitle());
  17.     }
  18.     public void testGetArticleWithUser()
  19.     {
  20.         Article article = new ArticleDao(getContext()).getArticleWithUser(1);
  21.         L.e(article.getUser() + ” , “ + article.getTitle());
  22.     }
  23.     public void testListArticlesByUserId()
  24.     {
  25.         List<Article> articles = new ArticleDao(getContext()).listByUserId(1);
  26.         L.e(articles.toString());
  27.     }

分别测试,添加一个Article;通过Id获取一个Article;通过Id获取一个Article且携带User;通过userId获取所有的Article;

主要看第三个:通过Id获取一个Article且携带User,testGetArticleWithUser(id)

如何值传一个Article的Id,然后能够拿到Article对象,且内部的user属性直接赋值呢?

两种方式:

1、即上述写法

  1. article = articleDaoOpe.queryForId(id);
  2.             helper.getDao(User.class).refresh(article.getUser());

2、在user属性的注解上:@DatabaseField(canBeNull = true, foreign = true, columnName = “user_id”, foreignAutoRefresh = true)

添加foreignAutoRefresh =true,这样;当调用queryForId时,拿到Article对象则直接携带了user;

4、关联一个集合

每个User关联一个或多个Article,如果我在User中声明一个Collection<Article> articles,我能否在查询User的时候,一并能够获取到articles的值呢?

答案是可以的。在User中添加如下属性,且注解如下:

@ForeignCollectionField
private Collection<Article> articles;

我们在UserDao中书写查询User的代码:

  1. public User get(int id)
  2.     {
  3.         try
  4.         {
  5.             return userDaoOpe.queryForId(id);
  6.         } catch (SQLException e)
  7.         {
  8.             e.printStackTrace();
  9.         }
  10.         return null ;
  11.     }

测试代码:

  1. public void testGetUserById()
  2.     {
  3.         User user = new UserDao(getContext()).get(1);
  4.         L.e(user.getName());
  5.         if (user.getArticles() != null)
  6.             for (Article article : user.getArticles())
  7.             {
  8.                 L.e(article.toString());
  9.             }
  10.     }

输出:

  1. 0907 22:49:06.484: E/zhy(7293): 张鸿洋
  2. 0907 22:49:06.484: E/zhy(7293): Article [id=1, title=ORMLite的使用]

可以看到,我们通过一个queryForId,成功的获取了User,以及User关联的所有的Articles;

5、条件查询QueryBuilder的使用

上述代码其实已经用到了简单的条件查询了:

1、简单的where等于

articleDaoOpe.queryBuilder().where().eq(“user_id”, userId).query();直接返回Article的列表

2、where and

  1. QueryBuilder<Article, Integer> queryBuilder = articleDaoOpe
  2.                 .queryBuilder();
  3.         Where<Article, Integer> where = queryBuilder.where();
  4.         where.eq(“user_id”1);
  5.         where.and();
  6.         where.eq(“name”“xxx”);
  7.         //或者
  8.         articleDaoOpe.queryBuilder().//
  9.                 where().//
  10.                 eq(“user_id”1).and().//
  11.                 eq(“name”“xxx”);

上述两种都相当与:select * from tb_article where user_id = 1 and name = ‘xxx’ ;

3、更复杂的查询

  1. where.or(
  2.                     //
  3.                     where.and(//
  4.                             where.eq(“user_id”1), where.eq(“name”“xxx”)),
  5.                     where.and(//
  6.                             where.eq(“user_id”2), where.eq(“name”“yyy”)));

select * from tb_article where ( user_id = 1 and name = ‘xxx’ )  or ( user_id = 2 and name = ‘yyy’ )  ;

好了,再复杂的查询估计也能够凑出来了~~

6、updateBuilder、deleteBuilder

使用queryBuilder是因为我们希望执行完成查询直接返回List<Bean>集合;

对于Update我们并不关注返回值,直接使用

articleDaoOpe.updateRaw(statement, arguments);传入sql和参数即可~~

何必在那articleDaoOpe.updateBuilder().updateColumnValue(“name”,”zzz”).where().eq(“user_id”, 1);这样的痛苦呢~~~

同理还有deleteBuilder还是建议直接拼写sql,当然很简单的除外,直接使用它的API~

7、事务操作

在我们的Dao中直接写如下代码:

  1. //事务操作
  2.         TransactionManager.callInTransaction(helper.getConnectionSource(),
  3.                 new Callable<Void>()
  4.                 {
  5.                     @Override
  6.                     public Void call() throws Exception
  7.                     {
  8.                         return null;
  9.                     }
  10.                 });

 

8、其他操作

1、当Bean继承BaseDaoEnabled时,可以使用bean.create(bean);bean.update(bean)一类操作

例如:

Student extends BaseDaoEnabled<Student, Integer>

Dao dao = DatabaseHelper.getHelper(getContext()).getDao(Student.class);
Student student = new Student();
student.setDao(dao);
student.setName(“张鸿洋”);
student.create();

前提dao需要手动设置,如果dao为null会报错,尼玛,我觉得一点用没有。。。

2、Join

  1. QueryBuilder<Article, Integer> articleBuilder = articleDaoOpe
  2.                     .queryBuilder();
  3.             QueryBuilder userBuilder = helper.getDao(User.class).queryBuilder();
  4.             articleBuilder.join(userBuilder);

Article与User做Join操作;

本篇主要想介绍在项目中如何写DataBaseHelper已经如何写BeanDao,以及列出了在项目中可能会用到的ORMLite的功能,如果需要详细了解,还请看ORMLite官方文档,源码中也会提供~~

源码点击下载

 

 

天边的星星