Android OrmLite 数据库框架使用

最新推荐文章于 2022-11-09 17:42:05 发布

chongbianpang0485

最新推荐文章于 2022-11-09 17:42:05 发布

阅读量252

点赞数 1

文章标签：移动开发数据库 java

原文链接：https://my.oschina.net/Forever2019/blog/3028972

版权

简介：

Ormlite框架是第三方对数据库操作的封装框架，它是一个非常轻量级的数据库操作框架，底层是根据反射机制来实现的。

优缺点

优点：文档较全面，社区活跃，有好的维护，使用简单，易上手

缺点：基于反射和注解的原理，效率较低

下载：

官网地址，指南和API文档：http://ormlite.com

下载地址：http://ormlite.com/releases/

也可以直接添加依赖：

compile 'com.j256.ormlite:ormlite-android:4.48'

准备：

流程：创建数据库辅助类 -> 创建DAO类 -> 自定义实体类然后就可以使用了！

1. 创建数据库辅助类

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;

import com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper;
import com.j256.ormlite.support.ConnectionSource;
import com.j256.ormlite.table.TableUtils;

import java.sql.SQLException;

public class DBHelper extends OrmLiteSqliteOpenHelper {
    // 数据库名称，会在程序的目录中生成sqlite-test.db数据库文件
    private static final String TABLE_NAME = "sqlite-test.db";
    // 数据库版本 更新用
    private static final int DATABASE_VERSION = 1;
    //单例对象
    private static DBHelper instance;

    private DBHelper(Context context) {
        super(context, TABLE_NAME, null, DATABASE_VERSION);
    }

    // 初次运行程序会执行该onCreate方法,如果不是初次运行程序则不会执行该方法,防止重复建表。
    @Override
    public void onCreate(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource) {
        try {
            //建立 User 表
            TableUtils.createTable(connectionSource, User.class);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    //如果不是初次运行并且DATABASE_VERSION数值增加的时候，则会执行该方法，可以在该方法中删除原来的表并建立新表，在要修改数据表结构的时候使用。
    @Override
    public void onUpgrade(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource, int oldVersion, int newVersion) {
/*
        if (oldVersion < DATABASE_VERSION) {
            try {
                //删除表..
                TableUtils.dropTable(connectionSource, User.class, true);
                onCreate(sqLiteDatabase, connectionSource);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
*/
    }

    /**
     * 获取单例
     *
     * @param context
     * @return
     */
    public static synchronized DBHelper getHelper(Context context) {
        context = context.getApplicationContext();
        if (instance == null) {
            synchronized (DBHelper.class) {
                if (instance == null) {
                    instance = new DBHelper(context);
                }
            }
        }
        return instance;
    }
}

2.创建DAO类

import android.content.Context;
import android.util.Log;

import com.j256.ormlite.dao.Dao;
import com.j256.ormlite.stmt.DeleteBuilder;
import com.j256.ormlite.stmt.QueryBuilder;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
/**
 * 通用DAO方法
 */
public class TDao<T> {
    private Dao mDao;
    private DBHelper helper;
    private final String TAG = "DB.TDao";

    /**
     * @param context
     * @param clazz   通用DAO方法对应的POJO类
     */
    public TDao(Context context, Class clazz) {
        try {
            helper = DBHelper.getHelper(context);
            mDao = helper.getDao(clazz);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 插入单条数据,在没有ID字段的情况下使用最好
     *
     * @param tableBean 表单条映射数据实体
     * @return int
     */
    public int insert(T tableBean) {
        int result = -1;
        try {
            result = mDao.create(tableBean);
        } catch (SQLException e) {
            e.printStackTrace();
            Log.e(TAG, String.format(Locale.CHINESE, "数据添加失败,原因：%s", e.getMessage()));
        }
        return result;
    }
    /**
     * 插入List一批数据
     * 在没有ID字段的情况下使用最好
     * @param tableBean 表单条映射数据实体List
     * @return int
     */
    public int insertList(List<T> tableBean) {
        int result = -1;
        try {
            result = mDao.create(tableBean);
        } catch (SQLException e) {
            e.printStackTrace();
            Log.e(TAG, String.format(Locale.CHINESE, "数据添加失败,原因：%s", e.getMessage()));
        }
        return result;
    }

    /**
     * 新增或者更新一条记录（新增时如果存在，就会更新）
     * eg:是否需要更新，通过对比ID来判断  id=true 这个字段如果相等，进行更新
     *
     * @param t
     * @return
     */
    public int insertOrUpdate(T t) {
        try {
            return mDao.createOrUpdate(t).getNumLinesChanged();
        } catch (SQLException e) {
            e.printStackTrace();
            Log.e(TAG, String.format(Locale.CHINESE, "数据添加失败,原因：%s", e.getMessage()));
            return 0;
        }
    }

    /**
     * 删除表中指定数据(可用于无ID 参数情况下删除)
     *
     * @param tableBean 数据映射实体
     * @return int
     */
    public int delete(T tableBean) {
        int result = -1;
        try {
            result = mDao.delete(tableBean);
        } catch (SQLException e) {
            e.printStackTrace();
            Log.e(TAG, String.format(Locale.CHINESE, "删除表中 %s 数据失败,原因：%s", tableBean.getClass().getSimpleName(), e.getMessage()));
        }
        return result;
    }

    /**
     * 通过id进行数据删除
     *
     * @param idValue 该表指定为ID的字段值
     * @return int
     */
    public int deleteById(String idValue) {
        int result = -1;
        try {
            result = mDao.deleteById(idValue);

        } catch (SQLException e) {
            e.printStackTrace();
            Log.e(TAG, String.format(Locale.CHINESE, "通过ID %s 删除数据失败,原因：%s", String.valueOf(idValue), e.getMessage()));
        }
        return result;
    }

    /**
     * 指定列及该列值,删除该条数据
     *
     * @param columnName  列名
     * @param columnValue 列值
     * @return int
     */
    public int deleteByColumn(String columnName, Object columnValue) {
        int result = -1;
        try {
            DeleteBuilder builder = mDao.deleteBuilder();
            builder.where().eq(columnName, columnValue);
            result = builder.delete();
        } catch (SQLException e) {
            e.printStackTrace();
            Log.e(TAG, String.format(Locale.CHINESE, "自定义删除指定列数据失败,原因：%s", e.getMessage()));
        }
        return result;
    }

    /**
     * 删除表中所有数据
     *
     * @return int
     */
    public int deleteAll() {
        int result = -1;
        try {
            result = mDao.deleteBuilder().delete();
        } catch (SQLException e) {
            e.printStackTrace();
            Log.e(TAG, String.format(Locale.CHINESE, "删除所有数据失败,原因：%s", e.getMessage()));
        }
        return result;
    }


    /**
     * 更新表中数据
     *
     * @param tableBean 数据映射实体
     * @return int
     */
    public int update(T tableBean) {
        int result = -1;
        try {
            result = mDao.update(tableBean);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 查询表中所有数据
     *
     * @return List<T>
     */
    public List<T> queryAll() {
        List<T> tableBeans = new ArrayList<>();
        try {
            tableBeans.addAll(mDao.queryForAll());
        } catch (Exception e) {
            e.printStackTrace();
            Log.e(TAG, String.format(Locale.CHINESE, "查询所有数据失败,原因：%s", e.getMessage()));
        }
        return tableBeans;
    }

    /**
     * 通过ID查询指定数据
     *
     * @param idValue 该表指定为ID的字段值
     * @return T
     */
    public T queryById(String idValue) {
        T tableBean = null;
        try {
            tableBean = (T) mDao.queryForId(idValue);
        } catch (SQLException e) {
            e.printStackTrace();
            Log.e(TAG, String.format(Locale.CHINESE, "通过ID %s 查询数据失败,原因：%s", String.valueOf(idValue), e.getMessage()));
        }
        return tableBean;
    }


    /**
     * 指定列、列值查询该条数据
     *
     * @param columnName  列名
     * @param columnValue 列值
     * @return List<T>
     */
    public List<T> queryByColumn(String columnName, Object columnValue) {
        List<T> tableBeans = new ArrayList<>();
        try {
            QueryBuilder builder = mDao.queryBuilder();
            builder.where().eq(columnName, columnValue);
            tableBeans = builder.query();
        } catch (SQLException e) {
            e.printStackTrace();
            Log.e(TAG, String.format(Locale.CHINESE, "查询所有数据失败,原因：%s", e.getMessage()));
        }
        return tableBeans;
    }


    /**
     * 查询表中数据总条数
     *
     * @return
     */
    public long count() {
        long result = 0;
        try {
            result = mDao.countOf();
        } catch (SQLException e) {
            e.printStackTrace();
            Log.e(TAG, String.format(Locale.CHINESE, "查询数据总条数失败,原因：%s", e.getMessage()));
        }
        return result;
    }


}

3.自定义实体类

//用注解标示该类和表user来映射，如果不写tableName则会默认用该类的类名来当做表名。
@DatabaseTable(tableName = "tb_user")
public class User {
    /**
     * @DatabaseTable：表示定义了一个数据表，如果不指定名字，在Android中会以类名作为表名，如packageInfo就是SQLite数据库中的表名，我们也可以指定表名，
     * @DatabaseField：表示定义了数据中的一个字段
     * -> id （唯一）表示数据中的一个主键，Id字段唯一标识一行，如果要使用ID方法的查询，更新，刷新和删除，则需要这些字段。
     * -> generatedId（唯一）表示自动增长id，我们不需要给它赋值。其他字段，可以使用
     *
     * -> columnName 包含此字段的数据库中列的字符串名称。如果未设置，则使用带有规范化大小写的字段名称
     * -> canBeNull表示是否可为空
     * -> defaultValue = "0" 默认值
     * -> unique 在表中的所有行中必须是唯一的。
     * eg: （id = true, canBeNull = false）
     * eg: generatedId和id=true 不能共存
     * 官网解释地址：http://ormlite.com/javadoc/ormlite-core/doc-files/ormlite_2.html#Using
     */

    // 用注解标示字段和表中的字段来对应，id=true表示该字段为主键。
    @DatabaseField(generatedId = true)
    private String id;

    //普通列名
    @DatabaseField(columnName = "name")
    private String name;

    //必须有空构造函数
    public User() {
    }


    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

使用：

1.这边咱们在通用DAO方法已经写好方法.. 使用就很方便了，比如

    //用法
    TDao<User> tdao = new TDao<User>(context, User.class);

    //直接调用查询
    tdao.queryAll();

具体使用方法，在通用DAO类新增就可以啦。是不是非常简单！

扩展：

创建实体类注解

@DatabaseTable 设置表名

@DatabaseField 设置字段

字段常用参数

columnName 字段名

dataType 数据类型

defaultValue 字符串默认值

canBeNull 可否为空

id 主键

generatedId 自增主键

foreign 外联

unique 唯一

dataType 常用数据类型

STRING(StringType.getSingleton()),

BOOLEAN(BooleanType.getSingleton()),

DATE(DateType.getSingleton()),

DATE_LONG(DateLongType.getSingleton()),

CHAR(CharType.getSingleton()),

BYTE(ByteType.getSingleton()),

SHORT(ShortType.getSingleton()),

INTEGER(IntType.getSingleton()),

LONG(LongType.getSingleton()),

FLOAT(FloatType.getSingleton()),

DOUBLE(DoubleType.getSingleton()),

SERIALIZABLE(SerializableType.getSingleton()),

TIME_STAMP(TimeStampType.getSingleton()),

例子：

        @DatabaseField(columnName = "_id", dataType = DataType.INTEGER, generatedId = true)

         private int id;

        @DatabaseField(columnName = "name", dataType = DataType.STRING, canBeNull = false)

         private String name;

持续更新~

参考文章：https://www.jianshu.com/p/09f4c50c934d

转载于:https://my.oschina.net/Forever2019/blog/3028972