Ormlite基本使用

版权声明：本文为博主原创文章，转载请注明地址。 https://blog.csdn.net/huangxiaoguo1/article/details/89180064

• 首先需要导入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

扫描二维码关注公众号，回复： 5836180 查看本文章

使用示范：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();