OrmLite 数据库使用大全

本文介绍OrmLite的数据库表的使用以及在项目中选择他的原因。

1. 选用 OrmLite 数据库的原因

目前用的最多的就是GreenDAO 和 OrmLite 了，两者各有优缺点。

GreenDAO

性能高，号称Android最快的关系型数据库；内存占用较小；支持数据库加密；

OrmLite

通过注解和反射将对象映射到数据库中的表，效率上相对来说，低些（实测，感觉还可以）；相对GreenDAO 使用起来比较方便；

两者都是ORM（对象关系数据库）；下面是从其他网站上盗用的一张图

2. 如何使用

2.1. 下载jar包

可以到官网去下载ormlite的jar包 下载地址
我这里使用的是ormlite-core-5.0.jar 和 ormlite-android-5.0.jar

2.2. 创建数据库管理类（DatabaseHelper.java）

final class DatabaseHelper extends OrmLiteSqliteOpenHelper {

    private static final String TABLE_NAME = SDCardUtils.getDbPath();
    // any time you make changes to your database objects, you may have to increase the database version
    private static final int DATABASE_VERSION = 6;

    private static final Class<?>[] tableClasses = new Class[]{
        Account.class
    };


    private Map<String, Dao> daos = new HashMap<String, Dao>();

    private static DatabaseHelper instance;


    private DatabaseHelper(Context context) {
        super(context, TABLE_NAME, null, DATABASE_VERSION);
    }
    /** context:上下文对象   
      * DATABASE_NAME：数据库名称
      * factory：游标工厂  
      * DATABASE_VERSION:数据库版本号
      */
    public DatabaseHelper(Context context, String databaseName, SQLiteDatabase.CursorFactory factory, int databaseVersion, File configFile) {
        super(context, TABLE_NAME, null, DATABASE_VERSION);
    }


    /**
     * 单例获取该Helper
     * @return return
     */
    public static synchronized DatabaseHelper getInstance() {
        if (instance == null) {
            synchronized (DatabaseHelper.class) {
                if (instance == null) {
                    instance = new DatabaseHelper(MainApp.getInstance());
                }
            }
        }
        return instance;
    }

    @Override
    public void onCreate(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource) {
        try {
            for (Class<?> clazz : tableClasses) {
                TableUtils.createTable(connectionSource, clazz);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onUpgrade(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource, int i, int i1) {
        try {
            for (Class<?> clazz : tableClasses) {
                TableUtils.dropTable(connectionSource, clazz,true);
            }
            onCreate(sqLiteDatabase,connectionSource);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public synchronized Dao getDao(Class clazz) {
        Dao dao = null;
        String className = clazz.getSimpleName();
        if (daos.containsKey(className)) {
            dao = daos.get(className);
        }
        if (dao == null) {
            try {
                dao = super.getDao(clazz);
            } catch (SQLException e) {
                e.printStackTrace();
            }
            daos.put(className, dao);
        }
        return dao;
    }
 }

2.3. 创建表结构（相应的实体类Account.java）

@DatabaseTable(tableName = "accounts")
public class Account {

    @DatabaseField(id = true)
    private String name;
    @DatabaseField
    private String password;

    public Account() {
        // ORMLite needs a no-arg constructor 
    }
    public Account(String name, String password) {
        this.name = name;
        this.password = password;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
}

注解

@DatabaseTable: 表明是一张表，表明默认为类名小写，也可以通过 tableName 指定 @DatabaseTable(tableName = "AccountTable")；
@DatabaseField: 表明是表中的一个字段，默认为变量名小写，也可以通过columnName 指定@DatabaseField（columnName=""|generatedId=true|foreign=true|foreignColumnName=""）分别可指定表中字段名、该字段是否为主键、是否为外键、关联表的外键名； 也可以这样指定主键 @DatabaseField(id = true)

变量含义

2.4. 创建DAO（相应的实体类AccountDAO.java）

AccountDAO 中通过相应的Dao 条用 update create delete query 方法操作数据库，也可以拿到相应的updateBuilder deleteBuilder queryBuilder 之后再操作数据库；两种方法的区别是拿到相应的Builder 可以添加更多的条件。
创建DAO的开销比较大，尽量将DAO重复利用。DaoManager具有缓存功能，可以将创建的DAO缓存下来，避免重复创建，因此尽量使用DaoManager创建DAO。

public class AccountDAO {
    private static volatile AccountDAO instance;

    private AccountDAO() {
    }

    public static AccountDAO getInstance() {
        if (instance == null) {
            synchronized (AccountDAO.class) {
                if (instance == null) {
                    instance = new AccountDAO();
                }
            }
        }
        return instance;
    }


    public void update(Account account) {
        try {
            getDao().update(account);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public void addAccount(Account account) {
        try {
            getDao().create(account);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }


    public void deleteAccount(List<Account> accountList) {
        try {
            getDao().delete(accountList);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public Account queryById(String id) {
        Account ret = null;
        try {
            ret = getDao().queryForId(id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return ret;
    }

    public Dao<Account, Object> getDao() {
        return DatabaseHelper.getInstance().getDao(Account.class);
    }

}

其他常用方法

1.getDao().createOrUpdate(account): 在操作数据库时，会根据account的id查询，如果存在则执行 update 方法，否则执行create 方法；
2.getDao().queryForFirst():
3.getDao().queryForSameId():
4.getDao().queryForEq():
5.getDao().updateRaw():

2.5. 使用

之后就可以直接在需要调用的地方拿到DAO实例，在调用相应的工具方法对数据库进行增删改差操作就可以了。

WEHRE子句

在SQL语句中，经常会用到where语句，where 进行条件筛选。dao.queryBuilder.()where()方法返回一个where对象，where中提供了很多方法来进行条件筛选,下边逐个讲where中的方法。

查询语句
eq(=)

方法 ：eq(columnName,value) 等于（=）equals
使用示范：DatabaseHelper.getDao().queryBuilder().where().eq(“id”, 2).query();
对应SQL：SELECT * FROM t_account WHERE id = 2

it(<)

方法 ：lt(columnName,value) 小于（<） less than
使用示范：DatabaseHelper.getDao().queryBuilder().where().lt(“id”, 2).query();
对应SQL：SELECT * FROM t_account WHERE id < 2

gt(>)

方法 ：gt(columnName,value) 大于（>） greater than
使用示范：DatabaseHelper.getDao().queryBuilder().where().gt(“id”, 2).query();
对应SQL：SELECT * FROM t_account WHERE id > 2

ge(>=)

方法 ：ge(columnName,value) 大于等于（>=）greater-than or equals-to
使用示范：DatabaseHelper.getDao().queryBuilder().where().ge(“id”, 2).query();
对应SQL：SELECT * FROM t_account WHERE id >= 2

le(<=)

方法 ：le(columnName,value) 小于等于（<=）less than or equals-to
使用示范：DatabaseHelper.getDao().queryBuilder().where().le(“id”, 2).query();
对应SQL：SELECT * FROM t_account WHERE id <= 2

ne(<>)

方法 ：ne(columnName,value) 不等于（<>）not-equal-to
使用示范：DatabaseHelper.getDao().queryBuilder().where().ne(“id”, 2).query();
对应SQL：SELECT * FROM t_account WHERE id <> 2

in（匹配相应的结果集）

方法 ：in(columnName,object…) 在指定列中匹配object数组所对应的值，返回匹配到的结果行集合,
in还有几个重载方法.
使用示范：DatabaseHelper.getDao().queryBuilder().where().in(“id”, 1，2).query();
对应SQL：SELECT * FROM t_account WHERE id IN (1，2 )

notIn(in 取到的相反集合)

方法 ：notIn(columnName,object…) 在指定列中匹配object数组所对应的值，返回没有匹配到的结果行集合，notIn还有几个重载方法
使用示范：DatabaseHelper.getDao().queryBuilder().where().notIn(“id”,1,2).query();
对应SQL：SELECT * FROM t_account WHERE id NOT IN (1 ,2 )

like（含有相应的字符的结果集）

方法 ：like(columnName,pattern) 使用%通配符来匹配，指定行数据，返回匹配到的结果
使用示范：DatabaseHelper.getDao().queryBuilder().where().like(“LastName”, “A%”).query(); 匹配A开头的LastName
DatabaseHelper.getDao().queryBuilder().where().like(“LastName”, “%s”).query(); 匹配s结尾的LastName
DatabaseHelper.getDao().queryBuilder().where().like(“LastName”, “%art%”).query(); 匹配中间为art的LastName
对应SQL：SELECT * FROM t_account WHERE LastName LIKE ‘A%’

between(指定字段在响应的范围内)

方法 ：between(columnName,low,high) 获取指定范围内的结果
使用示范：DatabaseHelper.getDao().queryBuilder().where().between(“id”, 1, 2).query(); 获取id是1到2之间的结果
对应SQL：SELECT * FROM t_account WHERE id BETWEEN 1 AND 2

and or (并且 和 或 的关系)

and() or() where子句或操作
使用示范：DatabaseHelper.getDao().queryBuilder().where().eq(“id”, 1).or().eq(“id”, 2).query();
使用示范：DatabaseHelper.getDao().queryBuilder().where().eq(“id”, 1).and().eq(“id”, 2).query();
对应SQL：SELECT * FROM t_account WHERE (id = 1 OR id = 2 )
对应SQL：SELECT * FROM t_account WHERE (id < 3 AND id > 1 )

ORDER BY（根据指定列名排序，降序，升序）

使用示范：DatabaseHelper.getDao().queryBuilder().orderBy(“id”, false).query(); //参数false表示降序，true表示升序。
对应SQL：SELECT * FROM t_account ORDER BY id DESC（降序）

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

DISTINCT (过滤指定列不重复数据行，重复的只返回一次。)

使用示范：DatabaseHelper.getDao().queryBuilder().selectColumns(“City”).distinct().query();
对应SQL：SELECT DISTINCT t_account FROM t_person

countOf(返回查询结果的总数)

使用示范：DatabaseHelper.getDao().queryBuilder().countOf()
对应SQL：SELECT COUNT(*) FROM t_account

offset Limit

offset跳过指定的行数
limit限制获取指定行数
使用示范：mDao.queryBuilder().offset(2).limit(2).query(); 可以用来分页
对应SQL：SELECT * FROM t_account LIMIT 2 OFFSET 2

3. ORMLite进行联合查询

之前的操作都是在单一的表中进行操作的，开发中也经常遇到表与表之间存在关联的, 下面介绍多表之间的操作

User表

@DatabaseTable(tableName = "User")
public class UserBean
    @DatabaseField(columnName = INTOID, generatedId = true)
        private Long id;

        @DatabaseField(columnName = ACTID, foreign = true)
        private String actId;
    }

Account 表

@DatabaseTable(tableName = "Account")
public class AccountBean {
        @DatabaseField(columnName = ACTID, generatedId = true)
        private String actId;
    }

具体操作：

QueryBuilder<User, Object> userQb = userDao.queryBuilder();
userQb.where().ge("id", 10);
QueryBuilder<Account, Object> accountQb = accountDao.queryBuilder();
// join with the order query
List<Account> results = accountQb.join(userQb).query();