- 首先需要导入ORMLite的依赖:在build.gradle中加入以下代码:
implementation 'com.j256.ormlite:ormlite-android:5.1'
implementation 'com.j256.ormlite:ormlite-core:5.1'
- 建立Bean类(以OneTableBean为例)
import com.j256.ormlite.field.DatabaseField;
import com.j256.ormlite.table.DatabaseTable;
@DatabaseTable(tableName = "onetable")
public class OneTableBean {
@DatabaseField(generatedId = true, columnName = "messageId", unique = true)
private int messageId;//主键
@DatabaseField(columnName = "batchNo")
private String batchNo;//批次号码 3
@DatabaseField(columnName = "title")
private String title;//标题 zzzz
@DatabaseField(columnName = "content")
private String content;//内容 zzz
public int getMessageId() {
return messageId;
}
public void setMessageId(int messageId) {
this.messageId = messageId;
}
public String getBatchNo() {
return batchNo;
}
public void setBatchNo(String batchNo) {
this.batchNo = batchNo;
}
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;
}
@Override
public String toString() {
return "OneTableBean{" +
"messageId=" + messageId +
", batchNo='" + batchNo + '\'' +
", title='" + title + '\'' +
", content='" + content + '\'' +
'}';
}
}
数据库中字段注解设置说明:
- 构建DatabaseHelper对DAO进行了统一的管理
import android.annotation.SuppressLint;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.util.ArrayMap;
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 cn.tsou.ormlite.bean.ArticleBean;
import cn.tsou.ormlite.bean.OneTableBean;
import cn.tsou.ormlite.bean.UserBean;
/**
* 数据库操作管理工具类
* <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集合
@SuppressLint("NewApi")
private ArrayMap<String, Dao> daos = new ArrayMap<>();
// 获取本类单例对象的方法
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, OneTableBean.class);
} catch (SQLException e) {
e.printStackTrace();
}
}
@Override // 数据库版本更新时调用的方法
public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
try {
TableUtils.dropTable(connectionSource, OneTableBean.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;
}
}
}
注:新表建立必须在onCreate创建
- 构建Bean对应的dao
import android.content.Context;
import com.j256.ormlite.dao.Dao;
import com.j256.ormlite.stmt.QueryBuilder;
import java.sql.SQLException;
import java.util.List;
import cn.tsou.ormlite.bean.OneTableBean;
import cn.tsou.ormlite.manager.DatabaseHelper;
/**
* 操作OneTableBean数据表的Dao类,封装这操作OneTableBean表的所有操作
* 通过DatabaseHelper类中的方法获取ORMLite内置的DAO类进行数据库中数据的操作
* <p>
* 调用dao的create()方法向表中添加数据
* 调用dao的delete()方法删除表中的数据
* 调用dao的update()方法修改表中的数据
* 调用dao的queryForAll()方法查询表中的所有数据
*/
public class OneTableDao {
// ORMLite提供的DAO类对象,第一个泛型是要操作的数据表映射成的实体类;第二个泛型是这个实体类中ID的数据类型
private Dao<OneTableBean, Integer> dao;
public OneTableDao(Context context) {
try {
this.dao = DatabaseHelper.getInstance(context).getDao(OneTableBean.class);
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 创建数据
*
* @param data
*/
public void create(OneTableBean data) {
try {
dao.createOrUpdate(data);
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 创建数据集合
*
* @param datas
*/
public void createList(List<OneTableBean> datas) {
try {
dao.create(datas);
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 向user表中添加一条数据
* <p>
* create:插入一条数据或集合
* <p>
* createIfNotExists:如果不存在则插入
* <p>
* createOrUpdate:如果指定id则更新
*
* @param data
*/
public void insert(OneTableBean data) {
try {
dao.createIfNotExists(data);
} catch (SQLException e) {
e.printStackTrace();
}
}
// 通过id删除指定数据
public void delete(int id) {
try {
dao.deleteById(id);
} catch (SQLException e) {
}
}
// 删除表中的一条数据
public void delete(OneTableBean data) {
try {
dao.delete(data);
} catch (SQLException e) {
e.printStackTrace();
}
}
// 删除数据集合
public void deleteList(List<OneTableBean> datas) {
try {
dao.delete(datas);
} catch (SQLException e) {
e.printStackTrace();
}
}
//清空数据
public void deleteAll() {
try {
dao.delete(dao.queryForAll());
} catch (Exception e) {
}
}
// 修改表中的一条数据
public void update(OneTableBean data) {
try {
dao.update(data);
} catch (SQLException e) {
e.printStackTrace();
}
}
// 查询表中的所有数据
public List<OneTableBean> queryAll() {
List<OneTableBean> users = null;
try {
users = dao.queryForAll();
} catch (SQLException e) {
e.printStackTrace();
}
return users;
}
// 根据ID取出用户信息
public OneTableBean queryById(int id) {
OneTableBean user = null;
try {
user = dao.queryForId(id);
} catch (SQLException e) {
e.printStackTrace();
}
return user;
}
// 通过条件查询集合(例如:通过messageId和title)
public List<OneTableBean> queryByMessageIdAndTitle(int messageId, String title) {
try {
QueryBuilder<OneTableBean, Integer> builder = dao.queryBuilder();
builder
.where()
.eq("messageId", messageId)
.and()
.eq("title", title);
builder.orderBy("messageId", false);
return builder.query();
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
// 通过条件查询集合(例如:通过content)
public List<OneTableBean> queryByContent(String content) {
try {
QueryBuilder<OneTableBean, Integer> builder = dao.queryBuilder();
builder
.where()
.eq("content", content);
builder.orderBy("title", false);
return builder.query();
} catch (SQLException e) {
e.printStackTrace();
}
return null;
}
}
- 测试
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import java.util.ArrayList;
import java.util.List;
import cn.tsou.ormlite.bean.OneTableBean;
import cn.tsou.ormlite.dao.OneTableDao;
public class MainActivity extends AppCompatActivity {
private int position;
private OneTableDao oneTableDao;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
position = 0;
oneTableDao = new OneTableDao(this);
}
/**
* 创建数据集合
*
* @param view
*/
public void createList(View view) {
ArrayList<OneTableBean> oneTableBeans = new ArrayList<>();
for (int i = 0; i < 10; i++) {
OneTableBean oneTableBean = new OneTableBean();
oneTableBean.setTitle("创建数据集合" + i);
oneTableBean.setBatchNo("yes");
oneTableBean.setContent("哎呀");
oneTableBeans.add(oneTableBean);
}
oneTableDao.createList(oneTableBeans);
}
/**
* 创建数据
*
* @param view
*/
public void create(View view) {
OneTableBean oneTableBean = new OneTableBean();
oneTableBean.setTitle("huangxiaoguo" + position);
oneTableBean.setBatchNo("yes");
oneTableBean.setContent("大大");
oneTableDao.create(oneTableBean);
OneTableBean oneTableBean1 = new OneTableBean();
oneTableBean1.setTitle("huangxiaoguo" + position);
oneTableBean1.setBatchNo("大大");
oneTableDao.create(oneTableBean1);
position++;
}
/**
* 添加一条数据
*
* @param view
*/
public void add(View view) {
OneTableBean oneTableBean = new OneTableBean();
if (position == 6) {
oneTableBean.setTitle("huangxiaoguo" + position);
oneTableBean.setBatchNo("154546");
oneTableBean.setContent("dadiouahddjaopdja");
} else if (position == 8) {
oneTableBean.setTitle("huangxiaoguo" + position);
} else {
oneTableBean.setTitle("huangxiaoguo" + position);
oneTableBean.setBatchNo("no");
oneTableBean.setContent("大大");
}
oneTableDao.insert(oneTableBean);
position++;
}
/**
* 通过id删除指定数据
*
* @param view
*/
public void deleteByID(View view) {
oneTableDao.delete(1);
}
/**
* 删除user表中的一条数据
*
* @param view
*/
public void delete(View view) {
oneTableDao.delete(oneTableDao.queryById(2));
}
/**
* 删除数据集合
*
* @param view
*/
public void deleteList(View view) {
oneTableDao.deleteList(oneTableDao.queryByContent("大大"));
}
/**
* 清空数据
*
* @param view
*/
public void deleteAll(View view) {
oneTableDao.deleteAll();
}
/**
* 更新
*
* @param view
*/
public void updata(View view) {
OneTableBean oneTableBean = oneTableDao.queryById(5);
if (oneTableBean != null) {
oneTableBean.setTitle("我被更新了");
oneTableDao.update(oneTableBean);
}
}
/**
* 查询user表中的所有数据
*
* @param view
*/
public void queryAll(View view) {
Log.d("huangxiaoguo", "-----------------------------------------------");
List<OneTableBean> oneTableBeans = oneTableDao.queryAll();
for (int i = 0; i < oneTableBeans.size(); i++) {
Log.d("huangxiaoguo", oneTableBeans.get(i).toString());
}
}
/**
* 根据ID取出用户信息
*
* @param view
*/
public void queryById(View view) {
OneTableBean oneTableBean = oneTableDao.queryById(5);
Log.d("huangxiaoguo", "-----------------------------------------------");
if (oneTableBean != null)
Log.d("huangxiaoguo", oneTableBean.toString());
}
/**
* 通过条件查询集合
*
* @param view
*/
public void queryOther(View view) {
List<OneTableBean> huangxiaoguo6 = oneTableDao.queryByMessageIdAndTitle(6, "huangxiaoguo0");
Log.d("huangxiaoguo", "-----------------------------------------------");
Log.d("huangxiaoguo", huangxiaoguo6.toString());
List<OneTableBean> huangxiaoguo61 = oneTableDao.queryByContent("大大");
Log.d("huangxiaoguo", "-----------------------------------------------");
Log.d("huangxiaoguo", huangxiaoguo61.toString());
}
}
-
效果展示
-
Builder说明
queryBuilder() 创建一个查询生成器:进行复杂查询 deleteBuilder() 创建一个删除生成器,进程复杂条件删除 updateBuilder() 创建修条件生成器,进行复杂条件修改 条件查找器DeleteBuilder,QueryBuilder,UpdateBuilder
在SQL语句中,经常会用到where语句,where 进行条件筛选。
dao.queryBuilder.()where()方法返回一个where对象,where中提供了很多方法来进行条件筛选,下边逐个讲where中的方法。
方法 :eq(columnName,value) 等于(=)equals
使用示范:mDao.queryBuilder().where().eq("id", 2).query();
对应SQL:SELECT * FROM t_person WHERE id = 2
方法 :lt(columnName,value) 小于(<) less than
使用示范:mDao.queryBuilder().where().lt("id", 2).query();
对应SQL:SELECT * FROM t_person WHERE id < 2
方法 :gt(columnName,value) 大于(>) greater than
使用示范:mDao.queryBuilder().where().gt("id", 2).query();
对应SQL:SELECT * FROM t_person WHERE id > 2
方法 :ge(columnName,value) 大于等于(>=)greater-than or equals-to
使用示范:mDao.queryBuilder().where().ge("id", 2).query();
对应SQL:SELECT * FROM t_person WHERE id >= 2
方法 :le(columnName,value) 小于等于(<=)less than or equals-to
使用示范:mDao.queryBuilder().where().le("id", 2).query();
对应SQL:SELECT * FROM t_person WHERE id <= 2
方法 :ne(columnName,value) 不等于(<>)not-equal-to
使用示范:mDao.queryBuilder().where().ne("id", 2).query();
对应SQL:SELECT * FROM t_person WHERE id <> 2
方法 :in(columnName,object…) 在指定列中匹配object数组所对应的值,返回匹配到的结果行集合,in还有几个重载方法,需要的话可以去看文档或源码
使用示范:mDao.queryBuilder().where().in("id", 1,2).query();
对应SQL:SELECT * FROM t_person WHERE id IN (1,2 )
方法 :notIn(columnName,object…) 在指定列中匹配object数组所对应的值,返回没有匹配到的结果行集合notIn还有几个重载方法,需要的话可以去看文档或源码
使用示范:mDao.queryBuilder().where().notIn("id",1,2).query();
对应SQL:SELECT * FROM t_person WHERE id NOT IN (1 ,2 )
方法 :like(columnName,pattern) 使用%通配符来匹配,指定行数据,返回匹配到的结果
使用示范:mDao.queryBuilder().where().like("LastName", "A%").query(); 匹配A开头的LastName
mDao.queryBuilder().where().like("LastName", “%s").query(); 匹配s结尾的LastName
mDao.queryBuilder().where().like("LastName", “%art%").query(); 匹配中间为art的LastName
对应SQL:SELECT * FROM `t_person` WHERE `LastName` LIKE 'A%'
方法 :between(columnName,low,high) 获取指定范围内的结果
使用示范:mDao.queryBuilder().where().between("id", 1, 2).query(); 获取id是1到2之间的结果
对应SQL:SELECT * FROM `t_person` WHERE `id` BETWEEN 1 AND 2
方法and(),or()用来组合上述where子语句。进行与,或操作。
方法 :and() where子句与操作
使用示范:mDao.queryBuilder().where().lt("id", 3).and().gt("id", 1).query();
对应SQL:SELECT * FROM `t_person` WHERE (`id` < 3 AND `id` > 1 )
方法 :or() where子句或操作
使用示范:mDao.queryBuilder().where().eq("id", 1).or().eq("id", 2).query();
对应SQL:SELECT * FROM `t_person` WHERE (`id` = 1 OR `id` = 2 )
ORDER BY
根据指定列名排序,降序,升序
使用示范:mDao.queryBuilder().orderBy("id", false).query(); //参数false表示降序,true表示升序。
对应SQL:SELECT * FROM `t_person` ORDER BY `id` DESC(降序)
DISTINCT
过滤指定列不重复数据行,重复的只返回一次。
使用示范:mDao.queryBuilder().selectColumns("City").distinct().query();
对应SQL:SELECT DISTINCT `City` FROM `t_person`
GROUP BY
按照指定列分组
使用示范:mDao.queryBuilder().groupBy("city").query();
对应SQL:SELECT * FROM t_person GROUP BY city
offset Limit
offset跳过指定的行数
limit限制获取指定行数
使用示范:mDao.queryBuilder().offset(2).limit(2).query(); 可以用来分页
对应SQL:SELECT * FROM t_person LIMIT 2 OFFSET 2
Having
等同于sql中的Having,针对分组数据,进行聚合函数(SUM, COUNT, MAX, AVG)运算。
使用示范:mPersonList = mDao.queryBuilder().groupBy("City").having("SUM(id)>4").query()
对应SQL:SELECT * FROM t_person GROUP BY City HAVING SUM(id)>4
countOf
返回查询结果的总数
使用示范:mDao.queryBuilder().countOf()
对应SQL:SELECT COUNT(*) FROM t_person
iterator
返回一个结果集的迭代器。
使用示范:Iterator<Person> iterator = mDao.queryBuilder().iterator();
queryForFirst
返回所有行的第一行。
使用示范:mDao.queryBuilder().queryForFirst();