Android中有很多操作SQLite数据库的框架,现在最常见、最常用的是ORMLite和GreenDAO。ORMLite相比与GreenDAO来说是一个轻量级的框架,而且学习成本相对较低。所以这个帖子中先介绍ORMLite,下个帖子再介绍GreenDAO。

  要使用ORMLite,首先需要导入ORMLite的依赖:在build.gradle中加入以下代码:

    compile 'com.j256.ormlite:ormlite-android:5.0'
compile 'com.j256.ormlite:ormlite-core:5.0'

  ORMLite需要我们自己实现一个类似原生操作SQLite数据库的DatabaseHelper,但必须继承自ORMLite为我们提供的OrmLiteSqliteOpenHelper。以下是一个功能比较齐全,性能相对也比较好的实例,这个实例不仅仅起到了创建数据库和更新数据库的操作,还对自身对象进行了单例、对DAO进行了统一的管理。代码如下:

import android.content.Context;
import android.database.sqlite.SQLiteDatabase; import com.example.itgungnir.testormlite.entity.ArticleBean;
import com.example.itgungnir.testormlite.entity.UserBean;
import com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper;
import com.j256.ormlite.dao.Dao;
import com.j256.ormlite.support.ConnectionSource;
import com.j256.ormlite.table.TableUtils; import java.sql.SQLException;
import java.util.HashMap;
import java.util.Map; /**
* 数据库操作管理工具类
* <p>
* 我们需要自定义一个类继承自ORMlite给我们提供的OrmLiteSqliteOpenHelper,创建一个构造方法,重写两个方法onCreate()和onUpgrade()
* 在onCreate()方法中使用TableUtils类中的createTable()方法初始化数据表
* 在onUpgrade()方法中我们可以先删除所有表,然后调用onCreate()方法中的代码重新创建表
* <p>
* 我们需要对这个类进行单例,保证整个APP中只有一个SQLite Connection对象
* <p>
* 这个类通过一个Map集合来管理APP中所有的DAO,只有当第一次调用这个DAO类时才会创建这个对象(并存入Map集合中)
* 其他时候都是直接根据实体类的路径从Map集合中取出DAO对象直接调用
*/
public class DatabaseHelper extends OrmLiteSqliteOpenHelper {
// 数据库名称
public static final String DATABASE_NAME = "mydb.db"; // 本类的单例实例
private static DatabaseHelper instance; // 存储APP中所有的DAO对象的Map集合
private Map<String, Dao> daos = new HashMap<>(); // 获取本类单例对象的方法
public static synchronized DatabaseHelper getInstance(Context context) {
if (instance == null) {
synchronized (DatabaseHelper.class) {
if (instance == null) {
instance = new DatabaseHelper(context);
}
}
}
return instance;
} // 私有的构造方法
private DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, 1);
} // 根据传入的DAO的路径获取到这个DAO的单例对象(要么从daos这个Map中获取,要么新创建一个并存入daos)
public synchronized Dao getDao(Class clazz) throws SQLException {
Dao dao = null;
String className = clazz.getSimpleName();
if (daos.containsKey(className)) {
dao = daos.get(className);
}
if (dao == null) {
dao = super.getDao(clazz);
daos.put(className, dao);
}
return dao;
} @Override // 创建数据库时调用的方法
public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
try {
TableUtils.createTable(connectionSource, UserBean.class);
TableUtils.createTable(connectionSource, ArticleBean.class);
} catch (SQLException e) {
e.printStackTrace();
}
} @Override // 数据库版本更新时调用的方法
public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
try {
TableUtils.dropTable(connectionSource, UserBean.class, true);
TableUtils.dropTable(connectionSource, ArticleBean.class, true);
onCreate(database, connectionSource);
} catch (SQLException e) {
e.printStackTrace();
}
} // 释放资源
@Override
public void close() {
super.close();
for (String key : daos.keySet()) {
Dao dao = daos.get(key);
dao = null;
}
}
}

  在这个帖子中,我们通过这样一个例子来了解ORMLite:数据库中有两个表,一个是user表,其中存储用户的信息;另一个是article表,存储文章信息,一个用户可以关良多篇文章,一篇文章只能关联一个用户。

  有了上面的需求,下面我们来写两个实体类:

  UserBean类中的代码如下:

import com.j256.ormlite.dao.ForeignCollection;
import com.j256.ormlite.field.DatabaseField;
import com.j256.ormlite.field.ForeignCollectionField;
import com.j256.ormlite.table.DatabaseTable; import java.util.Date; /**
* UserBean实体类,存储数据库中user表中的数据
* <p>
* 注解:
* DatabaseTable:通过其中的tableName属性指定数据库名称
* DatabaseField:代表数据表中的一个字段
* ForeignCollectionField:一对多关联,表示一个UserBean关联着多个ArticleBean(必须使用ForeignCollection集合)
* <p>
* 属性:
* id:当前字段是不是id字段(一个实体类中只能设置一个id字段)
* columnName:表示当前属性在表中代表哪个字段
* generatedId:设置属性值在数据表中的数据是否自增
* useGetSet:是否使用Getter/Setter方法来访问这个字段
* canBeNull:字段是否可以为空,默认值是true
* unique:是否唯一
* defaultValue:设置这个字段的默认值
*/
@DatabaseTable(tableName = "user") // 指定数据表的名称
public class UserBean {
// 定义字段在数据库中的字段名
public static final String COLUMNNAME_ID = "id";
public static final String COLUMNNAME_NAME = "name";
public static final String COLUMNNAME_SEX = "sex";
public static final String COLUMNNAME_BIRTHDAY = "birthday";
public static final String COLUMNNAME_ADDRESS = "address"; @DatabaseField(generatedId = true, columnName = COLUMNNAME_ID, useGetSet = true)
private int id;
@DatabaseField(columnName = COLUMNNAME_NAME, useGetSet = true, canBeNull = false, unique = true)
private String name;
@DatabaseField(columnName = COLUMNNAME_SEX, useGetSet = true, defaultValue = "1")
private char sex;
@DatabaseField(columnName = COLUMNNAME_BIRTHDAY, useGetSet = true)
private Date birthday;
@DatabaseField(columnName = COLUMNNAME_ADDRESS, useGetSet = true)
private String address;
@ForeignCollectionField(eager = true)
private ForeignCollection<ArticleBean> articles; public UserBean() {
} public UserBean(String name, char sex, Date birthday, String address) {
this.name = name;
this.sex = sex;
this.birthday = birthday;
this.address = address;
} public int getId() {
return id;
} public void setId(int id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public char getSex() {
return sex;
} public void setSex(char sex) {
this.sex = sex;
} public Date getBirthday() {
return birthday;
} public void setBirthday(Date birthday) {
this.birthday = birthday;
} public String getAddress() {
return address;
} public void setAddress(String address) {
this.address = address;
} public ForeignCollection<ArticleBean> getArticles() {
return articles;
} public void setArticles(ForeignCollection<ArticleBean> articles) {
this.articles = articles;
} @Override
public String toString() {
return "UserBean{" +
"id=" + id +
", name='" + name + '\'' +
", sex=" + sex +
", birthday=" + birthday +
", address='" + address + '\'' +
", articles=" + articles +
'}';
}
}

  ArticleBean类中的代码如下:

import com.j256.ormlite.field.DatabaseField;
import com.j256.ormlite.table.DatabaseTable; /**
* ArticleBean实体类,存储article数据表中的数据
* 数据库中的article表和user表是关联的,因此我们需要在article表中配置外键
* <p>
* foreignColumnName:外键约束指向的类中的属性名
* foreign:当前字段是否是外键
* foreignAutoRefresh:如果这个属性设置为true,在关联查询的时候就不需要再调用refresh()方法了
*/
@DatabaseTable(tableName = "article")
public class ArticleBean {
// article表中各个字段的名称
public static final String COLUMNNAME_ID = "id";
public static final String COLUMNNAME_TITLE = "title";
public static final String COLUMNNAME_CONTENT = "content";
public static final String COLUMNNAME_USER = "user_id"; @DatabaseField(generatedId = true, columnName = COLUMNNAME_ID, useGetSet = true)
private int id;
@DatabaseField(columnName = COLUMNNAME_TITLE, useGetSet = true, canBeNull = false, unique = true)
private String title;
@DatabaseField(columnName = COLUMNNAME_CONTENT, useGetSet = true)
private String content;
@DatabaseField(columnName = COLUMNNAME_USER, foreign = true, foreignAutoRefresh = true, foreignAutoCreate = true,
foreignColumnName = UserBean.COLUMNNAME_ID)
private UserBean user_id; public ArticleBean() {
} public ArticleBean(String title, String content, UserBean user) {
this.title = title;
this.content = content;
this.user_id = user;
} public int getId() {
return id;
} public void setId(int id) {
this.id = id;
} public String getTitle() {
return title;
} public void setTitle(String title) {
this.title = title;
} public String getContent() {
return content;
} public void setContent(String content) {
this.content = content;
} public UserBean getUser() {
return user_id;
} public void setUser(UserBean user) {
this.user_id = user;
} @Override
public String toString() {
return "ArticleBean{" +
"id=" + id +
", title='" + title + '\'' +
", content='" + content + '\'' +
", user=" + user_id +
'}';
}
}

  从两个实体类中的代码来看,ORMLite和JavaWeb框架中的Hibernate相似,都是使用注解的方式来标注数据库中的表、字段、关联关系的,这也是ORMLite的工作原理:ORMLite是基于反射机制工作的,然而这也成为了ORMLite的一个非常致命的缺点,性能不好。因此,如果是对想能要求不高的项目,我们可以考虑使用ORMLite,而如果项目对性能要求较高,我们可以考虑使用GreenDAO。

  至于各个标签、各个属性的用途,将在本贴的最后贴出。

  现在让我们再来看ORMLite中的另一个比较重要的东西——DAO。DAO是用来将操作某张表的方法(增、删、改、查)封装起来的工具类。下面来看代码:

  UserDao类中的代码:

import android.content.Context;

import com.example.itgungnir.testormlite.db.DatabaseHelper;
import com.example.itgungnir.testormlite.entity.UserBean;
import com.j256.ormlite.dao.Dao; import java.sql.SQLException;
import java.util.List; /**
* 操作User数据表的Dao类,封装这操作User表的所有操作
* 通过DatabaseHelper类中的方法获取ORMLite内置的DAO类进行数据库中数据的操作
* <p>
* 调用dao的create()方法向表中添加数据
* 调用dao的delete()方法删除表中的数据
* 调用dao的update()方法修改表中的数据
* 调用dao的queryForAll()方法查询表中的所有数据
*/
public class UserDao {
private Context context;
// ORMLite提供的DAO类对象,第一个泛型是要操作的数据表映射成的实体类;第二个泛型是这个实体类中ID的数据类型
private Dao<UserBean, Integer> dao; public UserDao(Context context) {
this.context = context;
try {
this.dao = DatabaseHelper.getInstance(context).getDao(UserBean.class);
} catch (SQLException e) {
e.printStackTrace();
}
} // 向user表中添加一条数据
public void insert(UserBean data) {
try {
dao.create(data);
} catch (SQLException e) {
e.printStackTrace();
}
} // 删除user表中的一条数据
public void delete(UserBean data) {
try {
dao.delete(data);
} catch (SQLException e) {
e.printStackTrace();
}
} // 修改user表中的一条数据
public void update(UserBean data) {
try {
dao.update(data);
} catch (SQLException e) {
e.printStackTrace();
}
} // 查询user表中的所有数据
public List<UserBean> selectAll() {
List<UserBean> users = null;
try {
users = dao.queryForAll();
} catch (SQLException e) {
e.printStackTrace();
}
return users;
} // 根据ID取出用户信息
public UserBean queryById(int id) {
UserBean user = null;
try {
user = dao.queryForId(id);
} catch (SQLException e) {
e.printStackTrace();
}
return user;
}
}

  ArticleDao类中的代码:

import android.content.Context;

import com.example.itgungnir.testormlite.db.DatabaseHelper;
import com.example.itgungnir.testormlite.entity.ArticleBean;
import com.j256.ormlite.dao.Dao; import java.sql.SQLException;
import java.util.List; /**
* 操作article表的DAO类
*/
public class ArticleDao {
private Context context;
// ORMLite提供的DAO类对象,第一个泛型是要操作的数据表映射成的实体类;第二个泛型是这个实体类中ID的数据类型
private Dao<ArticleBean, Integer> dao; public ArticleDao(Context context) {
this.context = context;
try {
this.dao = DatabaseHelper.getInstance(context).getDao(ArticleBean.class);
} catch (SQLException e) {
e.printStackTrace();
}
} // 添加数据
public void insert(ArticleBean data) {
try {
dao.create(data);
} catch (SQLException e) {
e.printStackTrace();
}
} // 删除数据
public void delete(ArticleBean data) {
try {
dao.delete(data);
} catch (SQLException e) {
e.printStackTrace();
}
} // 修改数据
public void update(ArticleBean data) {
try {
dao.update(data);
} catch (SQLException e) {
e.printStackTrace();
}
} // 通过ID查询一条数据
public ArticleBean queryById(int id) {
ArticleBean article = null;
try {
article = dao.queryForId(id);
} catch (SQLException e) {
e.printStackTrace();
}
return article;
} // 通过条件查询文章集合(通过用户ID查找)
public List<ArticleBean> queryByUserId(int user_id) {
try {
return dao.queryBuilder().where().eq(ArticleBean.COLUMNNAME_USER, user_id).query();
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
}

  最后就是测试代码了。我们直接在MainActivity中写代码,然后运行看结果。在MainActivity中,我们首先创建两张表并向表中添加数据,然后从数据表中分别取出数据,展示到TextView中。代码如下:

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.widget.TextView; import com.example.itgungnir.testormlite.dao.ArticleDao;
import com.example.itgungnir.testormlite.dao.UserDao;
import com.example.itgungnir.testormlite.entity.ArticleBean;
import com.example.itgungnir.testormlite.entity.UserBean;
import com.j256.ormlite.dao.ForeignCollection; import java.util.Date;
import java.util.Iterator; public class MainActivity extends AppCompatActivity {
private TextView tv; private StringBuffer contentBuffer; @Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
tv = (TextView) findViewById(R.id.tv);
contentBuffer = new StringBuffer();
initData();
initView();
} // 初始化数据
private void initData() {
// 添加用户数据
UserBean userData = new UserBean("张三", '1', new Date(), "北京");
new UserDao(MainActivity.this).insert(userData);
// 添加文章数据
ArticleBean articleData = new ArticleBean("标题", "内容内容内容内容内容内容", userData);
new ArticleDao(MainActivity.this).insert(articleData);
} // 初始化视图
private void initView() {
// 从数据库中根据ID取出文章信息
ArticleBean articleBean = new ArticleDao(MainActivity.this).queryById(1);
contentBuffer.append(articleBean.toString());
// 根据取出的用户id查询用户信息
UserBean userBean = new UserDao(MainActivity.this).queryById(articleBean.getUser().getId());
contentBuffer.append("\n\n" + userBean.toString());
// 从用户信息中取出关联的文章列表信息
ForeignCollection<ArticleBean> articles = userBean.getArticles();
Iterator<ArticleBean> iterator = articles.iterator();
contentBuffer.append("\n\n");
while (iterator.hasNext()) {
ArticleBean article = iterator.next();
contentBuffer.append(article.toString() + "\n");
}
// 设置TextView的文本
tv.setText(contentBuffer.toString());
}
}

  运行结果如下图所示:

  最后,贴出ORMLite中常用标签和各个属性代表的意义:

  常见标签:

 DatabaseTable:通过其中的tableName属性指定数据库名称
DatabaseField:代表数据表中的一个字段
ForeignCollectionField:一对多关联,表示一个UserBean关联着多个ArticleBean(必须使用ForeignCollection集合)

  常见属性:

id:当前字段是不是id字段(一个实体类中只能设置一个id字段)
columnName:表示当前属性在表中代表哪个字段
generatedId:设置属性值在数据表中的数据是否自增
useGetSet:是否使用Getter/Setter方法来访问这个字段
canBeNull:字段是否可以为空,默认值是true
unique:是否唯一
defaultValue:设置这个字段的默认值
foreignColumnName:外键约束指向的类中的属性名
foreign:当前字段是否是外键
foreignAutoRefresh:如果这个属性设置为true,在关联查询的时候就不需要再调用refresh()方法了

  以上就是对ORMLite框架的基本使用了,希望对大家有帮助~~~~

【Android - 框架】之ORMLite的使用的更多相关文章

  1. 【Android - 框架】之GreenDao的使用

    上一篇博客([Android - 框架]之ORMLite的使用)中介绍了ORMLite的基本使用,今天我们来研究以下GreenDao的使用. GreenDao和ORMLite一样,都是基于ORM(Ob ...

  2. ORM数据库框架 SQLite ORMLite MD

    Markdown版本笔记 我的GitHub首页 我的博客 我的微信 我的邮箱 MyAndroidBlogs baiqiantao baiqiantao bqt20094 baiqiantao@sina ...

  3. Android 框架简介--Java环境(转)

    ==========================上=========================== 这里简单的介绍了Android的java环境基础,在后面一节中会结合具体的实例来理解这一节 ...

  4. 【Android - 框架】之Retrofit+RxJava的使用

    前几天分别对Retrofit和RxJava进行了总结,这个帖子打算把Retrofit结合RxJava使用的方法总结以下.有还不了解Retrofit或RxJava的朋友可以参考下面的帖子学习~ [And ...

  5. IOS 与ANDROID框架及应用开发模式对照一

    IOS 和ANDROID操作系统都是眼下流行的移动操作系统,被移动终端和智能设备大量採用,两者都採用了先进的软件技术进行设计,为了方便应用开发两者都採用了先进的设计模式. 两者在框架设计上都採用了什么 ...

  6. Kotlin的扩展函数:扩展Android框架(KAD 08)

    作者:Antonio Leiva 时间:Jan 11, 2017 原文链接:https://antonioleiva.com/extension-functions-kotlin/ 扩展函数是Kotl ...

  7. App 组件化/模块化之路——Android 框架组件(Android Architecture Components)使用指南

    面对越来越复杂的 App 需求,Google 官方发布了Android 框架组件库(Android Architecture Components ).为开发者更好的开发 App 提供了非常好的样本. ...

  8. 【Android 系统开发】Android框架 与 源码结构

    一. Android 框架 Android框架层级 : Android 自下 而 上 分为 4层; -- Linux内核层; -- 各种库 和 Android运行环境层; -- 应用框架层; -- 应 ...

  9. IOS 与ANDROID框架及应用开发模式对比一

    IOS 和ANDROID操作系统都是目前流行的移动操作系统,被移动终端和智能设备大量采用,两者都采用了先进的软件技术进行设计,为了方便应用开发两者都采用了先进的设计模式.两者在框架设计上都采用了什么技 ...

  10. Android 框架式编程 —— 起篇

    一般的,在开发的时候,写过的代码在需求变更后,发现需要改动非常多的地方,那么说明之前的代码的架构肯定是存在问题的. 下面我们结合面向对象的六大基本原则谈Android 框架式编程.首先先介绍一下面向对 ...

随机推荐

  1. 总结shell

    总结shell里面一些初学者不容易懂得点,因为我本身就是初学者,所以有一些知识点是不容易通过字面意思理解的,下面写在这里. (便于理解的一个方法就是举例子)举个例子就是哪些容易学,哪些不容易理解:丁是 ...

  2. 小白学Linux--虚拟机下安装Ubuntu16

    最近接收到任务,说是下半年可能要搞全文检索.听到后顿时炸锅了,一方面是对新技术的兴奋(当然主要还是这技术比较值钱),另一方面,我TM连Linux都不会玩,怎么搞全文检索.怀揣着对开源世界的无线向往(恐 ...

  3. Matlab中的括号()[]{}

    Matlab中的括号()[]{} Matlab中经常会用到括号去引用某Array或者是cell的内容,但三者有什么具体区别呢?[ ] 中括号用来构建向量(Vectors)或者是矩阵(Matrices) ...

  4. nyoj 28 大数阶乘

    题目链接:nyoj 28 就是个简单的高精度,只是一开始我打表超内存了,然后用了各种技巧硬是把内存缩到了题目要求以下(5w+kb),感觉挺爽的,代码如下: #include<cstdio> ...

  5. 转:Grunt:任务自动管理工具

    Grunt:任务自动管理工具 来自<JavaScript 标准参考教程(alpha)>,by 阮一峰 目录 安装 命令脚本文件Gruntfile.js Gruntfile.js实例:gru ...

  6. Android 调试native的crash和anr

    1. 于trace找到相应的库.例如 liba.so和相应的地址信息 2. 采用addr2line 查看 addr2line 住址 -e liba.so -f 要么 arm-eabi-addr2lin ...

  7. sudoku--SE第二次作业

    git传送门 编译环境: windows10.vs2017 所用语言: c++ 首先作为一个晚上闭眼的玩家,我先来讲一下我的心路历程: 最开始接到作业的时候心里是拒绝的,刚出了一趟小远门就这样,就很难 ...

  8. promql查询表达式

    Basics 即时矢量选择器 =:匹配与标签相等的内容!=:不匹配与标签相等的内容=~: 根据正则表达式匹配与标签符合的内容!~:根据正则表达式不匹配与标签符合的内容 示例: http_request ...

  9. Python内置模块与标准库

    Python内置模块就是标准库(模块)吗?或者说Python的自带string模块是内置模块吗? 答案是:string不是内置模块,它是标准库.也就是说Python内置模块和标准库并不是同一种东西. ...

  10. Codeforces Round #361 (Div. 2) D. Friends and Subsequences 二分

    D. Friends and Subsequences 题目连接: http://www.codeforces.com/contest/689/problem/D Description Mike a ...