Android(安卓)使用ORMLite打造万能泛型Dao简化数据持久化层

前面的一篇文章Android ORM系列之ActiveAndroid 介绍了ActiveAndroid的使用方法，但是ActiveAndroid有一个很明显的缺点，就是所有的实体类必须继承Model类才能进行CRUD，这是典型的php中的ActiveRecord方式的数据库操作。这时候我们会想一下，在Java Web中，hibernate或者mybatis就很好，其实在android中也有这么一个框架，但是这个框架是java的，只不过它支持Android而已，它就是ORMLite。这篇文章不会过度介绍ORMlite本身的一些操作。如果感兴趣的话可以阅读下面的几篇翻译的文章.
- Android数据库ORMlite框架翻译系列（第一章）
- Android数据库ORMlite框架翻译系列（第二章：part 1）
- Android数据库ORMlite框架翻译系列（第二章：part 2）
- Android数据库ORMlite框架翻译系列（第二章：part 3）

然而ormlite提供给我们的还不够使用，我们能不能打造一个类似java web那样的dao层的完全分离，其实ORMLite已经为我们提供了这么一个类，它就是com.j256.ormlite.dao.BaseDaoImpl，但是这个类在我写这个dao前还没发现，后来发现有这个类，简直想撞豆腐，不过呢，这个类也不是那么完美，我们还是自己来实现一遍。

我们写的这个dao，如果你对事务要求有较高的要求，建议将dao层中的事务操作提取到service层中去。一个很简单的例子见这篇文章 (android)初探ormlite实现仿web那样写dao,service。这里我为了方便起见，将事务操作都扔到了dao中，建议还是单独提到service层中。下面贴出整个dao的代码，代码很简单。具体内容见注释把。

在使用前加入依赖

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

我们首先要提供一个Helper类。就是完成数据库的初始化或者更新。然后提供一个helper的单例。

/** * Helper类，提供单例Helper * User:lizhangqu([email protected]) * Date:2015-08-26 * Time: 12:04 */public class DatabaseHelper extends OrmLiteSqliteOpenHelper {    private static final String DB_NAME = "sc.db";    //数据库名    private static final int DB_VERSION = 1;    //数据库版本    private static DatabaseHelper instance;    //Helper单例    public DatabaseHelper(Context context) {        super(context, DB_NAME, null, DB_VERSION);    }    @Override    public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {        //创建表        try {            TableUtils.createTable(connectionSource, Student.class);            TableUtils.createTable(connectionSource, Course.class);            TableUtils.createTable(connectionSource, StudentCourse.class);        } catch (SQLException e) {            e.printStackTrace();        }    }    @Override    public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {        //更新表        try {            TableUtils.dropTable(connectionSource, StudentCourse.class, true);            TableUtils.dropTable(connectionSource, Student.class, true);            TableUtils.dropTable(connectionSource, Course.class, true);            onCreate(database, connectionSource);        } catch (SQLException e) {            e.printStackTrace();        }    }    /** * 双重加锁检查 * * @param context 上下文 * @return 单例 */    public static synchronized DatabaseHelper getInstance(Context context) {        if (instance == null) {            synchronized (DatabaseHelper.class) {                if (instance == null) {                    instance = new DatabaseHelper(context);                }            }        }        return instance;    }}

接下来就是这个通用的dao，一个抽象类，抽象方法是getDao，交给子类实现。其实你也可以直接在本类实现，实际差别不会太大。这个dao的主键是Integer类型的，如果你需要其他类型，请自行修改。

/** * 数据库CRUD操作的Dao，子类继承实现抽象方法，也提供一个简单的泛型实现类 * User:lizhangqu(513163535@qq.com) * Date:2015-08-26 * Time: 12:25 */public abstract class BaseDao<T, Integer> {    protected DatabaseHelper mDatabaseHelper;    //helper    protected Context mContext;    //上下文    public BaseDao(Context context) {        if (context == null) {            throw new IllegalArgumentException("Context can't be null!");            //如果为空，则扔出非法参数异常        }        mContext = context.getApplicationContext();        //避免产生内存泄露，使用getApplicationContext()        mDatabaseHelper = DatabaseHelper.getInstance(mContext);        //获得单例helper    }    /** * 抽象方法，重写提供Dao,在BaseDaoImpl里提供了简单的泛型实现，传递实体类Class即可 * * @return Dao类 * @throws SQLException SQLException异常 */    public abstract Dao<T, Integer> getDao() throws SQLException;    /** * 增，带事务操作 * * @param t 泛型实体类 * @return 影响的行数 * @throws SQLException SQLException异常 */    public int save(T t) throws SQLException {        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            int save = dao.create(t);            dao.commit(databaseConnection);            return save;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return 0;    }    /** * 增或更新，带事务操作 * @param t 泛型实体类 * @return Dao.CreateOrUpdateStatus * @throws SQLException SQLException异常 */    public Dao.CreateOrUpdateStatus saveOrUpdate(T t) throws SQLException {        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            Dao.CreateOrUpdateStatus orUpdate = dao.createOrUpdate(t);            dao.commit(databaseConnection);            return orUpdate;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return null;    }    /** * 增，带事务操作 * @param t 泛型实体类集合 * @return 影响的行数 * @throws SQLException SQLException异常 */    public int save(List<T> t) throws SQLException {        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            for (T item : t) {                dao.create(item);            }            dao.commit(databaseConnection);            return t.size();        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return 0;    }    /** * 删，带事务操作 * * @param t 泛型实体类 * @return 影响的行数 * @throws SQLException SQLException异常 */    public int delete(T t) throws SQLException {        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            int delete = dao.delete(t);            dao.commit(databaseConnection);            return delete;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return 0;    }    /** * 删，带事务操作 * * @param list 泛型实体类集合 * @return 影响的行数 * @throws SQLException SQLException异常 */    public int delete(List<T> list) throws SQLException {        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            int delete = dao.delete(list);            dao.commit(databaseConnection);            return delete;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return 0;    }    /** * 删，带事务操作 * * @param columnNames 列名数组 * @param columnValues 列名对应值数组 * @return 影响的行数 * @throws SQLException SQLException异常 * @throws InvalidParameterException InvalidParameterException异常 */    public int delete(String[] columnNames, Object[] columnValues) throws SQLException, InvalidParameterException {        List<T> list = query(columnNames, columnValues);        if (null != list && !list.isEmpty()) {            Dao<T, Integer> dao = getDao();            DatabaseConnection databaseConnection = null;            try {                databaseConnection = dao.startThreadConnection();                dao.setAutoCommit(databaseConnection, false);                int delete = dao.delete(list);                dao.commit(databaseConnection);                return delete;            } catch (SQLException e) {                dao.rollBack(databaseConnection);                e.printStackTrace();            } finally {                dao.endThreadConnection(databaseConnection);            }        }        return 0;    }    /** * 删，带事务操作 * * @param id id值 * @return 影响的行数 * @throws SQLException SQLException异常 */    public int deleteById(Integer id) throws SQLException {        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            int delete = dao.deleteById(id);            dao.commit(databaseConnection);            return delete;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return 0;    }    /** * 删，带事务操作 * @param ids id集合 * @return 影响的行数 * @throws SQLException SQLException异常 */    public int deleteByIds(List<Integer> ids) throws SQLException {        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            int delete = dao.deleteIds(ids);            dao.commit(databaseConnection);            return delete;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return 0;    }    /** * 删，带事务操作 * * @param preparedDelete PreparedDelete类 * @return 影响的行数 * @throws SQLException SQLException异常 */    public int delete(PreparedDelete<T> preparedDelete) throws SQLException {        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            int delete = dao.delete(preparedDelete);            dao.commit(databaseConnection);            return delete;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return 0;    }    /** * 改，带事务操作 * * @param t 泛型实体类 * @return 影响的行数 * @throws SQLException SQLException异常 */    public int update(T t) throws SQLException {        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            int update = dao.update(t);            dao.commit(databaseConnection);            return update;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return 0;    }    /** * 改，带事务操作 * @param preparedUpdate PreparedUpdate对象 * @return 影响的行数 * @throws SQLException SQLException异常 */    public int update(PreparedUpdate<T> preparedUpdate) throws SQLException {        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            int update = dao.update(preparedUpdate);            dao.commit(databaseConnection);            return update;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return 0;    }    /** * 查，带事务操作 * * @return 查询结果集合 * @throws SQLException SQLException异常 */    public List<T> queryAll() throws SQLException {        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            List<T> query = dao.queryForAll();            dao.commit(databaseConnection);            return query;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return null;    }    /** * 查，带事务操作 * * @param preparedQuery PreparedQuery对象 * @return 查询结果集合 * @throws SQLException SQLException异常 */    public List<T> query(PreparedQuery<T> preparedQuery) throws SQLException {        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            List<T> query = dao.query(preparedQuery);            dao.commit(databaseConnection);            return query;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return null;    }    /** * 查，带事务操作 * * @param columnName 列名 * @param columnValue 列名对应值 * @return 查询结果集合 * @throws SQLException SQLException异常 */    public List<T> query(String columnName, String columnValue) throws SQLException {        QueryBuilder<T, Integer> queryBuilder = getDao().queryBuilder();        queryBuilder.where().eq(columnName, columnValue);        PreparedQuery<T> preparedQuery = queryBuilder.prepare();        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            List<T> query = dao.query(preparedQuery);            //also can use dao.queryForEq(columnName,columnValue);            dao.commit(databaseConnection);            return query;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return null;    }    /** * 查，带事务操作 * * @param columnNames * @param columnValues * @return 查询结果集合 * @throws SQLException SQLException异常 */    public List<T> query(String[] columnNames, Object[] columnValues) throws SQLException {        if (columnNames.length != columnNames.length) {            throw new InvalidParameterException("params size is not equal");        }        QueryBuilder<T, Integer> queryBuilder = getDao().queryBuilder();        Where<T, Integer> wheres = queryBuilder.where();        for (int i = 0; i < columnNames.length; i++) {            if (i==0){                wheres.eq(columnNames[i], columnValues[i]);            }else{                wheres.and().eq(columnNames[i], columnValues[i]);            }        }        PreparedQuery<T> preparedQuery = queryBuilder.prepare();        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            List<T> query = dao.query(preparedQuery);            dao.commit(databaseConnection);            return query;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return null;    }    /** * 查，带事务操作 * * @param map 列名与值组成的map * @return 查询结果集合 * @throws SQLException SQLException异常 */    public List<T> query(Map<String, Object> map) throws SQLException {        QueryBuilder<T, Integer> queryBuilder = getDao().queryBuilder();        if (!map.isEmpty()) {            Where<T, Integer> wheres = queryBuilder.where();            Iterator<Map.Entry<String, Object>> iterator = map.entrySet().iterator();            String key = null;            Object value = null;            for (int i = 0; iterator.hasNext(); i++) {                Map.Entry<String, Object> next = iterator.next();                key = next.getKey();                value = next.getValue();                if (i == 0) {                    wheres.eq(key, value);                } else {                    wheres.and().eq(key, value);                }            }        }        PreparedQuery<T> preparedQuery = queryBuilder.prepare();        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            List<T> query = dao.query(preparedQuery);            dao.commit(databaseConnection);            return query;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return null;    }    /** * 查，带事务操作 * * @param id id值 * @return 查询结果集合 * @throws SQLException SQLException异常 */    public T queryById(Integer id) throws SQLException {        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            T t = dao.queryForId(id);            dao.commit(databaseConnection);            return t;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return null;    }    /** * 判断表是否存在 * * @return 表是否存在 * @throws SQLException SQLException异常 */    public boolean isTableExists() throws SQLException {        return getDao().isTableExists();    }    /** * 获得记录数 * * @return 记录数 * @throws SQLException SQLException异常 */    public long count() throws SQLException {        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            long count = dao.countOf();            dao.commit(databaseConnection);            return count;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return 0;    }    /** * 获得记录数 * * @param preparedQuery PreparedQuery类 * @return 记录数 * @throws SQLException SQLException异常 */    public long count(PreparedQuery<T> preparedQuery) throws SQLException {        Dao<T, Integer> dao = getDao();        DatabaseConnection databaseConnection = null;        try {            databaseConnection = dao.startThreadConnection();            dao.setAutoCommit(databaseConnection, false);            long count = dao.countOf(preparedQuery);            dao.commit(databaseConnection);            return count;        } catch (SQLException e) {            dao.rollBack(databaseConnection);            e.printStackTrace();        } finally {            dao.endThreadConnection(databaseConnection);        }        return 0;    }}

一个简单的泛型实现类，带缓存。

/** * BaseDao泛型实现类 * User:lizhangqu(513163535@qq.com) * Date:2015-08-26 * Time: 13:51 */public class BaseDaoImpl<T,Integer> extends BaseDao<T,Integer> {    private Class<T> clazz;    private Map<Class<T>,Dao<T,Integer>> mDaoMap=new HashMap<Class<T>,Dao<T,Integer>>();    //缓存泛型Dao    public BaseDaoImpl(Context context,Class<T> clazz) {        super(context);        this.clazz=clazz;    }    @Override    public Dao<T, Integer> getDao() throws SQLException {        Dao<T,Integer> dao=mDaoMap.get(clazz);        if (null==dao){            dao=mDatabaseHelper.getDao(clazz);            mDaoMap.put(clazz,dao);        }        return dao;    }}

如果你要增加一些操作，直接继承BaseDao实现抽象方法再加入你要增加的操作，或者直接继承BaseDaoImpl再增加操作即可。

整体代码没有什么难度，而怎么使用呢，这里写了几个测试用例。测试用例中涉及到的实体类就不贴了。

public class ApplicationTest extends ApplicationTestCase<Application> {    private BaseDao<Student,Integer> mStudentDao;    private BaseDao<Course,Integer> mCourseDao;    private BaseDao<StudentCourse,Integer> mStudentCourseDao;    public ApplicationTest() {        super(Application.class);    }    @Override    protected void setUp() throws Exception {        super.setUp();        mStudentDao=new BaseDaoImpl<>(getContext(),Student.class);        mCourseDao=new BaseDaoImpl<>(getContext(),Course.class);        mStudentCourseDao=new BaseDaoImpl<>(getContext(),StudentCourse.class);    }    public void testAddStudent() throws SQLException {        Student student=new Student();        student.setStudentName("张三");        student.setAge(18);        student.setSex(true);        student.setAddress("杭州市");        mStudentDao.save(student);    }    public void testAddOrUpdateStudent() throws SQLException {        Student student=new Student();        student.setStudentName("张三1111");        student.setAge(18);        student.setSex(true);        student.setAddress("杭州市");        Dao.CreateOrUpdateStatus createOrUpdateStatus = mStudentDao.saveOrUpdate(student);        Log.e("TAG", createOrUpdateStatus.isCreated() + " " + createOrUpdateStatus.isUpdated() + " " + createOrUpdateStatus.getNumLinesChanged());        student.setAge(19);        createOrUpdateStatus = mStudentDao.saveOrUpdate(student);        Log.e("TAG", createOrUpdateStatus.isCreated() + " " + createOrUpdateStatus.isUpdated() + " " + createOrUpdateStatus.getNumLinesChanged());    }    public void testAddStudents() throws SQLException {        Student student=new Student();        student.setStudentName("李四");        student.setAge(19);        student.setSex(false);        student.setAddress("温州市");        Student student1=new Student();        student1.setStudentName("王五");        student1.setAge(21);        student1.setSex(true);        student1.setAddress("嘉兴市");        List<Student> list=new ArrayList<Student>();        list.add(student);        list.add(student1);        mStudentDao.save(list);    }    public void testDeleteStudent() throws SQLException {        Student student=new Student();        student.setStudentName("1111");        student.setAge(11);        student.setSex(true);        student.setAddress("22222");        mStudentDao.save(student);        mStudentDao.delete(student);    }    public void testDeleteStudents() throws SQLException {        Student student=new Student();        student.setStudentName("李四");        student.setAge(19);        student.setSex(false);        student.setAddress("温州市");        Student student1=new Student();        student1.setStudentName("王五");        student1.setAge(21);        student1.setSex(true);        student1.setAddress("嘉兴市");        List<Student> list=new ArrayList<Student>();        list.add(student);        list.add(student1);        mStudentDao.save(list);        mStudentDao.delete(list);    }    public void testDeleteStudentByColumns() throws SQLException {        Student student=new Student();        student.setStudentName("李四11");        student.setAge(19);        student.setSex(false);        student.setAddress("温州市");        mStudentDao.save(student);        mStudentDao.delete(new String[]{"studentName","studentAge"},new String[]{"李四11","19"});    }    public void testDeleteStudentById() throws SQLException {        Student student=new Student();        student.setStudentName("李四22");        student.setAge(19);        student.setSex(false);        student.setAddress("温州市");        mStudentDao.save(student);        mStudentDao.deleteById(student.getId());    }    public void testDeleteStudentByIds() throws SQLException {        Student student=new Student();        student.setStudentName("李四22");        student.setAge(19);        student.setSex(false);        student.setAddress("温州市");        mStudentDao.save(student);        Student student1=new Student();        student1.setStudentName("李四333");        student1.setAge(19);        student1.setSex(false);        student1.setAddress("温州市");        List<Student> list=new ArrayList<Student>();        mStudentDao.save(list);        mStudentDao.deleteByIds(Arrays.asList(student.getId(),student1.getId()));    }    public void testDeleteStudentByPreparedDelete() throws SQLException {        Student student=new Student();        student.setStudentName("李四33");        student.setAge(19);        student.setSex(false);        student.setAddress("温州市");        mStudentDao.save(student);        DeleteBuilder<Student, Integer> studentIntegerDeleteBuilder = mStudentDao.getDao().deleteBuilder();        studentIntegerDeleteBuilder.where().eq("studentName","李四33").and().eq("studentAddress", "温州市");        PreparedDelete<Student> prepare = studentIntegerDeleteBuilder.prepare();        mStudentDao.delete(prepare);    }    public void testUpdateStudent() throws SQLException {        Student student=new Student();        student.setStudentName("赵六");        student.setAge(19);        student.setSex(false);        student.setAddress("温州市");        mStudentDao.save(student);        student.setAddress("临安市");        mStudentDao.update(student);    }    public void testUpdateStudentByPreparedUpdate() throws SQLException {        Student student=new Student();        student.setStudentName("赵六");        student.setAge(19);        student.setSex(false);        student.setAddress("温州市");        mStudentDao.save(student);        student.setAddress("临安市");        UpdateBuilder<Student, Integer> studentIntegerUpdateBuilder = mStudentDao.getDao().updateBuilder();        studentIntegerUpdateBuilder.updateColumnValue("studentName","赵六六").where().eq("studentName", "赵六").and().eq("studentAddress", "温州市");        PreparedUpdate<Student> prepare = studentIntegerUpdateBuilder.prepare();        mStudentDao.update(prepare);    }    public void testQueryStudentAll() throws SQLException {        List<Student> students = mStudentDao.queryAll();        Log.e("TAG", students + "");    }    public void testQueryStudentByPreparedQuery() throws SQLException {        QueryBuilder<Student, Integer> studentIntegerQueryBuilder = mStudentDao.getDao().queryBuilder();        studentIntegerQueryBuilder.where().eq("studentAddress","温州市");        PreparedQuery<Student> prepare = studentIntegerQueryBuilder.prepare();        List<Student> students = mStudentDao.query(prepare);        Log.e("TAG",students+"");    }    public void testQueryStudentByColumn() throws SQLException {        List<Student> students = mStudentDao.query("studentName","赵六六");        Log.e("TAG",students+"");    }    public void testQueryStudentByColumns() throws SQLException {        List<Student> students = mStudentDao.query(new String[]{"studentName","studentAge","studentSex"},new Object[]{"李四",19,false});        Log.e("TAG",students+"");    }    public void testQueryStudentByMap() throws SQLException {        Map<String, Object> map=new HashMap<String, Object>();        map.put("studentName","李四");        map.put("studentAge",19);        map.put("studentSex",false);        List<Student> students = mStudentDao.query(map);        Log.e("TAG",students+"");    }    public void testQueryStudentById() throws SQLException {        Student student = mStudentDao.queryById(1);        Log.e("TAG",student+"");    }    public void testIsTableExists() throws SQLException {        Log.e("TAG",mStudentDao.isTableExists()+"");    }    public void testCount() throws SQLException {        Log.e("TAG",mStudentDao.count()+"");    }    public void testCountByPreparedQuery() throws SQLException {        PreparedQuery<Student> prepare = mStudentDao.getDao().queryBuilder().setCountOf(true).where().eq("studentAddress", "温州市").prepare();        Log.e("TAG",mStudentDao.count(prepare)+"");    }

最后给出源码下载地址

http://download.csdn.net/detail/sbsujjbcy/9053725

更多相关文章

随机推荐