Android快速开发OrmLite数据库封装详解

Android移动开发之数据库——OrmLite详解

随着开源框架的广泛，对于Android开发者越来越有优势，极大的提高了开发效率和开发周期。android系统的sqlite轻量级数据库操作SQL语句较为麻烦，如果不熟悉Web开发的朋友可能对SQL语句还比较陌生。

一、本文可以让你学到的内容：

1.使用第三方框架OrmLite数据库开发Android移动应用程序；
2.不再使用SQL语句实现增删查改，直接一对一传参操作数据库；
3.提高开发周期和效率，剩余时间可以泡吧和泡牛~

二、OrmLite认识：

Ormlite官网： http://ormlite.com/ 开发文档下载（pdf）。 但是是英文文档哦，不要一看到是英文的就害怕了，其实里面单词比较简单，能够看得懂的，多看看英文文档还是挺有帮助的。

三、OrmLite使用：

1.要使用ormlite很简单，只需要下载相应的两个jar包（目前最新的jar包 ormlite-android-4.48.jar，ormlite-core-4.48.jar下载 ）并导入工程即可。
2.新建DBOpenHelper：

package com.cb.db;

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

import com.cb.model.BaseModel;
import com.cb.model.parameters.Friend;
import com.cb.model.parameters.Group;
import com.cb.model.parameters.User;
import com.cb.util.MyLogger;
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;

public class DBOpenHelper extends OrmLiteSqliteOpenHelper {

    public static final int DB_VERSION = 1; // 更新时候只需要修改这里就可以了

    public DBOpenHelper(Context context) {
        super(context, "cdy.db", null, DB_VERSION);
        MyLogger.CLog().e("创建数据库cdy.db");
    }

    @Override
    public void onCreate(SQLiteDatabase sqLiteDatabase,
            ConnectionSource connectionSource) {
        try {
            TableUtils
                    .createTableIfNotExists(connectionSource, BaseModel.class);
            TableUtils
                    .createTableIfNotExists(connectionSource, User.class);
            TableUtils
                    .createTableIfNotExists(connectionSource, Friend.class);
            TableUtils
                    .createTableIfNotExists(connectionSource, Group.class);
            sqLiteDatabase.setVersion(DB_VERSION);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onUpgrade(SQLiteDatabase sqLiteDatabase,
            ConnectionSource connectionSource, int oldVersion, int newVersion) {
        try {
            updateVersion(connectionSource, oldVersion);
            sqLiteDatabase.setVersion(newVersion);
        } catch (Exception e) {
            MyLogger.CLog().e(e.getMessage(), e);
        }
    }

    /**
     * 数据库表新增字段时使用
     * @param sqLiteDatabase
     * @param oldVersion
     * @throws SQLException
     */
    private void update2Version(SQLiteDatabase sqLiteDatabase,int oldVersion) throws SQLException {
        if(oldVersion < DB_VERSION){
            if (!checkColumnExist(sqLiteDatabase, "friend", "read")) {
                Dao<Friend, String> childOne = getDao(Friend.class);
                childOne.executeRaw("ALTER TABLE 'friend' ADD COLUMN friendName varchar;");
            }
        }
    }


    /**
     * 更新数据库操作：先删除，在创建
     * @param connectionSource
     * @param oldVersion
     */
    private void updateVersion(ConnectionSource connectionSource,int oldVersion) {
        if (oldVersion < DB_VERSION) {
            //删除表
            try {
                TableUtils
                        .dropTable(connectionSource, BaseModel.class, true);
                TableUtils
                        .dropTable(connectionSource, User.class, true);
                TableUtils
                        .dropTable(connectionSource, Friend.class, true);
                TableUtils
                        .dropTable(connectionSource, Group.class, true);
            } catch (Exception e) {
                MyLogger.CLog().e(e.getMessage(),e);
            }
            //创建表
            try {
                TableUtils
                        .createTableIfNotExists(connectionSource, BaseModel.class);
                TableUtils
                        .createTableIfNotExists(connectionSource, User.class);
                TableUtils
                        .createTableIfNotExists(connectionSource, Friend.class);
                TableUtils
                        .createTableIfNotExists(connectionSource, Group.class);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }


    private boolean checkColumnExist(SQLiteDatabase db, String tableName,
                                     String columnName) {
        boolean result = false;
        Cursor cursor = null;
        try {
            // 查询一行
            cursor = db.rawQuery("SELECT * FROM " + tableName + " LIMIT 0",
                    null);
            result = cursor != null && cursor.getColumnIndex(columnName) != -1;
        } catch (Exception e) {
        } finally {
            if (null != cursor && !cursor.isClosed()) {
                cursor.close();
            }
        }

        return result;
    }


    @Override
    public void close() {
        super.close();
    }
}

该类主要是应用程序启动后新建数据库和后期更新数据库，这里面的操作跟SqLite操作基本一致。
3.数据库管理类：BaseModelManager封装。以下只贴部分代码，具体代码可以参考下面Demo：

package com.cb.manager;

import android.content.Context;
import android.text.TextUtils;

import com.cb.model.BaseModel;
import com.cb.util.MyLogger;
import com.j256.ormlite.android.apptools.OpenHelperManager;
import com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper;
import com.j256.ormlite.dao.Dao;
import com.j256.ormlite.stmt.DeleteBuilder;
import com.j256.ormlite.stmt.QueryBuilder;
import com.j256.ormlite.stmt.UpdateBuilder;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;

public class BaseModelManager {
    public static String currentUser;
    private static BaseModelManager baseModelManager = null;

    protected BaseModelManager() {
    }

    public static BaseModelManager getInstance() {
        if (baseModelManager == null) {
            baseModelManager = new BaseModelManager();
        }
        return baseModelManager;
    }

    /**
     * 
     * @param clazz
     * @param context
     * @param dbHelperClass 数据帮助类，继承自OrmLiteSqliteOpenHelper
     * @return
     */
    @SuppressWarnings({ "rawtypes", "unchecked" })
    protected <T extends BaseModel> Dao<T, String> getDao(Class<T> clazz,
            Context context, Class dbHelperClass) {
        Dao<T, String> baseModelDao = null;
        OrmLiteSqliteOpenHelper dbOpenHelper = OpenHelperManager.getHelper(
                context, dbHelperClass);
        try {
            baseModelDao = dbOpenHelper.getDao(clazz);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return baseModelDao;
    }

    /**
     * 
     * 保存 or 更新BaseModel
     * 
     * @param clazz <T>
     * @param dbHelperClass 数据帮助类，继承自OrmLiteSqliteOpenHelper
     * @param context
     * @param <T>
     */
    @SuppressWarnings("rawtypes")
    public <T extends BaseModel> void saveOrUpdateModel(Class<T> clazz,
            Context context, T model, Class dbHelperClass) {
        try {
            Dao<T, String> baseModelDao = getDao(clazz, context, dbHelperClass);
            model.setCurrentUser(currentUser);
            if (baseModelDao.idExists(model.getId())) {
                baseModelDao.update(model);
            } else {
                baseModelDao.create(model);
            }
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取当前账户下所有对象
     * 
     * @param clazz <T>
     * @param dbHelperClass 数据帮助类，继承自OrmLiteSqliteOpenHelper
     * @param context
     * @return
     */
    @SuppressWarnings("rawtypes")
    public <T extends BaseModel> List<T> getAllModels(Class<T> clazz,Class dbHelperClass
            ,Context context) {
        List<T> list = new ArrayList<T>();
        try {
            Dao<T, String> baseModelDao = getDao(clazz, context,dbHelperClass);
            QueryBuilder<T, String> builder = baseModelDao.queryBuilder();
            builder.where().eq("currentUser", currentUser);
            list = baseModelDao.query(builder.prepare());
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return list;
    }

    /**
     * 查找model
     * 
     * @param clazz <T>
     * @param dbHelperClass 数据帮助类，继承自OrmLiteSqliteOpenHelper
     * @param context
     * @param id
     * @return
     */
    @SuppressWarnings("rawtypes")
    public <T extends BaseModel> T getModelById(Class<T> clazz,Class dbHelperClass,
            Context context, String id) {
        if (TextUtils.isEmpty(id)) {
            return null;
        }
        T model = null;
        try {
            Dao<T, String> baseModelDao = getDao(clazz, context,dbHelperClass);
            model = baseModelDao.queryForId(id);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return model;
    }
    /**
     * 
     * @param clazz
     * @param dbHelperClass 数据帮助类，继承自OrmLiteSqliteOpenHelper
     * @param context
     * @param columnName
     * @param attribute
     * @param orderColumn
     * @param ascending
     * @return
     */
    @SuppressWarnings("rawtypes")
    public <T extends BaseModel> List<T> getModelsByAttribute(Class<T> clazz,Class dbHelperClass,
            Context context, String columnName, String attribute,
            String orderColumn, boolean ascending) {
        List<T> models = new ArrayList<T>();
        try {
            Dao<T, String> baseModelDao = getDao(clazz, context,dbHelperClass);
            QueryBuilder<T, String> builder = baseModelDao.queryBuilder();
            builder.where().eq(columnName, attribute).and()
                    .eq("currentUser", currentUser);
            models = baseModelDao.query(builder.prepare());
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return models;
    }

    /**
     * 
     * @param clazz
     * @param dbHelperClass 数据帮助类，继承自OrmLiteSqliteOpenHelper
     * @param context
     * @param columnName
     * @param attribute
     * @param orderColumn
     * @param ascending
     * @return
     */
    @SuppressWarnings("rawtypes")
    public <T extends BaseModel> List<T> getOrderModelsByAttribute(
            Class<T> clazz,Class dbHelperClass, Context context, String columnName, int attribute,
            String orderColumn, boolean ascending) {
        List<T> models = new ArrayList<T>();
        try {
            Dao<T, String> baseModelDao = getDao(clazz, context,dbHelperClass);
            QueryBuilder<T, String> builder = baseModelDao.queryBuilder();
            builder.where().eq(columnName, attribute).and()
                    .eq("currentUser", currentUser);
            models = baseModelDao.query(builder.prepare());
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return models;
    }

    /**
     * 
     * @param clazz
     * @param dbHelperClass 数据帮助类，继承自OrmLiteSqliteOpenHelper
     * @param context
     * @param orderColumn
     * @param ascending
     * @return
     */
    @SuppressWarnings("rawtypes")
    public <T extends BaseModel> List<T> getOrderModels(
            Class<T> clazz,Class dbHelperClass, Context context, 
                String orderColumn, boolean ascending) {
        List<T> models = new ArrayList<T>();
        try {
            Dao<T, String> baseModelDao = getDao(clazz, context,dbHelperClass);
            QueryBuilder<T, String> builder = baseModelDao.queryBuilder();
            builder.where().eq("currentUser", currentUser);
            models = baseModelDao.query(builder.prepare());
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return models;
    }

    /**
     * 
     * @param clazz
     * @param dbHelperClass 数据帮助类，继承自OrmLiteSqliteOpenHelper
     * @param context
     * @param columnName1
     * @param attribute1
     * @param columnName2
     * @param attribute2
     * @return
     */
    public <T extends BaseModel> List<T> getModelsByAttributes(Class<T> clazz,@SuppressWarnings("rawtypes") Class dbHelperClass,
            Context context, String columnName1, String attribute1,
            String columnName2, String attribute2) {
        List<T> models = new ArrayList<T>();
        try {
            Dao<T, String> baseModelDao = getDao(clazz, context,dbHelperClass);
            QueryBuilder<T, String> builder = baseModelDao.queryBuilder();
            builder.where().eq(columnName1, attribute1).and()
                    .eq(columnName2, attribute2).and()
                    .eq("currentUser", currentUser);
            models = baseModelDao.query(builder.prepare());
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return models;
    }

    /**
     * 删除baseMode
     * 
     * @param clazz <T>
     * @param dbHelperClass 数据帮助类，继承自OrmLiteSqliteOpenHelper
     * @param context
     * @param id
     * @return
     */
    @SuppressWarnings("rawtypes")
    public <T extends BaseModel> void delModel(Class<T> clazz,Class dbHelperClass, Context context,
            String id) {
        if (TextUtils.isEmpty(id)) {
            return;
        }
        try {
            Dao<T, String> baseModelDao = getDao(clazz, context,dbHelperClass);
            baseModelDao.deleteById(id);
        } catch (SQLException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

该类主要对数据库增、删、查、改的封装，如果有特殊查询条件，即可自己写一个子类继承重写父类方法修改即可。轻轻松松完成增删查改各种操作。
以下自己写了一个子类Friend来继承BaseModelManager，重写操作数据库对应的方法，实现自己想要的操作，如果无变化即可调用父类super.(…相应方法)。

package com.cb.manager;

import android.content.Context;
import android.text.TextUtils;

import com.cb.db.DBOpenHelper;
import com.cb.model.parameters.Friend;
import com.cb.model.parameters.User;
import com.cb.util.MyLogger;

import java.util.List;

/**
 * Created by Daasan on 2015/11/30.
 */
public class FriendManager extends BaseModelManager {
    private static FriendManager userManager;

    public FriendManager() {
    }

    public static FriendManager getInstance() {
        if (userManager == null) {
            userManager = new FriendManager();
        }
        return userManager;
    }


    /**
     * 根据用户名查找当前登陆用户
     *
     * @param context
     * @param attribute
     */
    public Friend getModelsByName(Context context, String attribute) {
        if (TextUtils.isEmpty(attribute)) {
            return null;
        }
        Friend friend = null;
        List<Friend> friends = getModelsByAttribute(Friend.class, DBOpenHelper.class, context,
                "friendName", attribute);
        MyLogger.CLog().e("cb friendName = " + friends.size());
        if (friends != null && friends.size() > 0) {
            friend = friends.get(0);
        }
        return friend;
    }

    /**
     * 根据用户名查找当前登陆用户
     *
     * @param context
     * @param attribute
     */
    public void delecteByName(Context context, String attribute) {
        super.delModels(Friend.class, DBOpenHelper.class, context,"friendName",attribute);
    }


    public List<Friend> getModelsByGroupId(Context context, String groupId) {
        return super.getModelsByAttribute(Friend.class, DBOpenHelper.class, context,
                "groupId", groupId);
    }


    public void updateByName(Context context, String friendName ,String attribute){
        super.updateModels(Friend.class, DBOpenHelper.class, context,"friendName",friendName , "nick",attribute);
    }

}

以上子类FriendManager中getModelsByName()方法,根据用户名查找相应用户信息，就是调用父类getModelsByAttribute()方法查询后在进行细分。

以下是我平时整理出来一些Android开发常见效果：

以下主要截取OrmLite数据库操作模块展示：
模块描述：主要模拟好友分组列表
**功能描述：**1.添加好友、2、添加分组、3.删除好友、4.删除分组、5.查找好友、6.退出当前账号
模块流程：如果没有登录过的用户首次进入登录账号，即可展示好友分组界面，以后进入便可直接进入分组列表！
备注：由于模拟器无法输入中文，效果不佳。
“我的好友”为默认分组，其余操作均有OrmLite数据库完成！

注意：代码中用到很多工具类，界面也是白版，主要展示OrmLite数据库操作，有好的意见和见解欢迎讨论！

Demo下载地址：

http://download.csdn.net/detail/jaynm/9459163

原创博文，转载时请附上原文地址！