Android数据库LiteOrm的使用

1.介绍

LiteOrm 是一个数据库 ORM 框架，自动化存储实体和处理关系映射，比系统自带API速度 「 快1倍」！

LiteOrm 是一个速度快、小巧却强大的 Android ORM 框架类库，速度快、体积小、性能高，开发者基本一行代码实现数据库的增删改查操作，以及实体关系的持久化和自动映射。 自动化且比系统自带数据库操作快1倍！

有兴趣的人可以去看看他的其他项目。
https://litesuits.com/?form=gorm
另外推荐两篇详细版的使用博客
http://blog.csdn.net/u014099894/article/details/51586500
http://www.jianshu.com/p/0d72226ef434 

 

2.接入

首先，从他的GitHub库地址上下载LiteOrm的jar包，复制到libs目录。 
然后在项目结构里面，选择添加jar包为依赖，找到我们复制进去的jar包，按确定即可。

3.基本使用

1.数据库工具类

package com.anrongcheck.db;

import android.annotation.SuppressLint;
import android.content.Context;

import com.anrongcheck.JLApp;
import com.anrongcheck.util.LogUtil;
import com.litesuits.orm.LiteOrm;
import com.litesuits.orm.db.assit.QueryBuilder;
import com.litesuits.orm.db.assit.WhereBuilder;
import com.litesuits.orm.db.model.ColumnsValue;
import com.litesuits.orm.db.model.ConflictAlgorithm;

import java.util.Collection;
import java.util.List;

/**
 * 数据库工具类
 *
 * @author mazhanzhu
 */
public class LiteOrmDBUtil {

    public static String DB_NAME;
    private static LiteOrm liteOrm;
    public static Context mContext;

    /**
     * 数据库名称
     *
     * @return
     */
    private static String getUserDatabaseName() {
        return "ocall_info";
    }

    /**
     * 创建级联数据库
     *
     * @param context
     */
    public static boolean createCascadeDB(Context context) {
        mContext = context.getApplicationContext();
        DB_NAME = getUserDatabaseName();
        liteOrm = LiteOrm.newCascadeInstance(mContext, DB_NAME);
        liteOrm.setDebugged(LogUtil.isDebuggable());
        return true;
    }

    public static LiteOrm getLiteOrm() {
        if (liteOrm == null) {
            if (mContext == null) {
                mContext = JLApp.getContext();
            }
            DB_NAME = getUserDatabaseName();
            liteOrm = LiteOrm.newCascadeInstance(mContext, DB_NAME);
            liteOrm.setDebugged(LogUtil.isDebuggable());
        }
        return liteOrm;
    }

    /**
     * 插入一条记录
     *
     * @param t
     */
    public static <T> long insert(T t) {
        return getLiteOrm().save(t);
    }

    /**
     * 插入所有记录
     *
     * @param list
     */
    public static <T> int insertAll(List<T> list) {
        return getLiteOrm().save(list);
    }

    /**
     * 以某种条件作为插入标准
     *
     * @param
     * @return
     */
    public static <T> long insertAll(Collection<T> t, ConflictAlgorithm config) {
        return getLiteOrm().insert(t, config);
    }

    /**
     * 以某种条件作为插入标准
     *
     * @param
     * @return
     */
    public static <T> long insertAll(List<T> t, ConflictAlgorithm config) {
        return getLiteOrm().insert(t, config);
    }


    /**
     * 查询所有
     *
     * @param cla
     * @return
     */
    public static <T> List<T> getQueryAll(Class<T> cla) {
        return getLiteOrm().query(cla);
    }

    /**
     * 根据ID查询
     *
     * @param cla
     * @return
     */
    public static <T> T getInfoById(String id, Class<T> cla) {
        return getLiteOrm().queryById(id, cla);
    }

    /**
     * 根据ID查询
     *
     * @param cla
     * @return
     */
    public static <T> T getInfoById(long id, Class<T> cla) {
        return getLiteOrm().queryById(id, cla);
    }

    /**
     * 查询 某字段 等于 Value的值
     *
     * @param cla
     * @param field
     * @param value
     * @return
     */
    @SuppressWarnings({"unchecked", "rawtypes"})
    public static <T> List<T> getQueryByWhere(Class<T> cla, String field, Object[] value) {
        return getLiteOrm().<T>query(new QueryBuilder(cla).where(field + "=?", value));
    }

    /**
     * 模糊查询
     *
     * @param cla
     * @param field
     * @param value
     * @param <T>
     * @return
     */
    public static <T> List<T> getQueryByTime(Class<T> cla, String field, Object[] value) {
        return getLiteOrm().<T>query(new QueryBuilder(cla).where(field + " LIKE ?", value));
    }

    /**
     * 查询 某字段 等于 Value的值 可以指定从1-20，就是分页
     *
     * @param cla
     * @param field
     * @param value
     * @param start
     * @param length
     * @return
     */
    public static <T> List<T> getQueryByWhereLength(Class<T> cla, String field, String[] value, int start, int length) {
        return getLiteOrm().<T>query(new QueryBuilder(cla).where(field + "=?", value).limit(start, length));
    }

    /**
     * 删除所有 某字段等于 Vlaue的值
     *
     * @param cla
     * @param field
     * @param value
     */
    @SuppressWarnings("deprecation")
    public static <T> int deleteWhere(Class<T> cla, String field, String[] value) {
        return getLiteOrm().delete(cla, WhereBuilder.create(cla, field + "=?", value));
    }

    /**
     * 删除所有 某字段等于 Vlaue的值
     *
     * @param cla
     * @param field
     * @param value
     */
    public static <T> int deleteWhere(Class<T> cla, String field, Object[] value) {
        return getLiteOrm().delete(cla, WhereBuilder.create(cla, field + "=?", value));
    }

    /**
     * 删除所有
     *
     * @param cla
     */
    public static <T> int deleteAll(Class<T> cla) {
        return getLiteOrm().deleteAll(cla);
    }

    /**
     * 仅在以存在时更新
     *
     * @param t
     */
    public static <T> int update(T t) {
        return getLiteOrm().update(t, ConflictAlgorithm.Replace);
    }

    /**
     * 以某种条件来整体更新
     *
     * @param list
     * @param config
     * @return
     */
    public static <T> int updateAll(List<T> list, ConflictAlgorithm config) {
        return getLiteOrm().update(list, config);
    }

    public static <T> int updateALL(List<T> list) {
        return getLiteOrm().update(list);
    }

    public static <T> void update(Class<T> cla, String queryCol,
                                  String queryValue, String updateCol, String updateValue) {
        getLiteOrm().update(
                new WhereBuilder(cla).where(queryCol + " = ?",
                        new String[]{queryValue}),
                new ColumnsValue(new String[]{updateCol},
                        new Object[]{updateValue}), ConflictAlgorithm.None);

    }

    @SuppressLint("NewApi")
    public void closeDB() {
        if (liteOrm != null) {
            liteOrm.close();
        }
    }
}

如果整个app只有一个数据库，建议保持单例，不然可能会出问题。

2.建立一个类

一开始我不明白啥意思，后来发现，这就是你要保存的那个类，只是要加入一个自增长的id以及一些注解就行。我这里就做了个简单的类，get和set之类的就不写进来了。。

public class PerPhotoInfo implements Parcelable {

	@PrimaryKey(AssignType.AUTO_INCREMENT)
	private int primary_id;

	private String id;
	private String gmsfhm;// 人员身份证号
	private String xp;// 照片
	private String sex;//性别
	private String nation;//名族
	private String birthday;//出生日期
	private String address;//地址
	private String hc_address;//核查地址
	private String name;//核查地址
	private String hc_time;//核查时间
......}

4.总结

好像没啥好说的，估计大多数人用的都还是一些比较基础的功能，这个库其实能做很多事情，联级操作之类的；慢慢用着就会很熟练了。祝大家生活愉快~~