Ormlite的拓展使用

1、数据库保存位置，一般数据库默认是保存在APP的缓存中，卸载APP后数据库的数据也没有了，所以有了把数据库数据保存在本地SD卡上，

public DatabaseHelper(Context context) {
    //把数据库放到sd卡上面
    super(context, PathUtils.getFilePath(PathUtils.FNG_YU,PathUtils.DB_NAME), null, 1);
}

public static String getFilePath(String dir,String path){
    StringBuilder sb = new StringBuilder();
    sb.append(getSDCardPath())
            .append(File.separator)
            .append(dir);
    File dirFile = new File(sb.toString());
    if(!dirFile.exists()){
        dirFile.mkdirs();
    }
    Log.e("xys", "sb.toString = " + sb.toString());
    sb.setLength(0);
    return sb.append(dirFile.getAbsoluteFile()).append(File.separator).append(path).toString();
}

2、当数据库已经创建，但是要插入其他的表的操作，调用如下的方法：

public void onInsertOtherTable(){
    try {
        TableUtils.createTableIfNotExists(connectionSource,Article.class);
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

3、数据库的打开与关闭的判断

public boolean openDatabase(){
    return this.isOpen();
}

public void closeDatabase(){
    this.close();
}

4、数据库增删改查的抽象

1）、创建接口类IDao，抽象数据的增删改查方法

package com.fengyu.hu.db.dao;

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

/**
 * <pre>
 *      author : xiaohu
 *      time   : 2018/1/26
 *      des    :
 *  <pre/>
 */

public interface IDao<T,ID> {
    int insert(T t);                               //插入数据
    int createOrUpdate(T t);                        //插入或者更新数据
    void insertBitch(List<T> data);                     //批量插入数据
    void updateBitch(List<T> data);                     //批量更新数据
    int update(T t);                               //更新数据
    T queryForId(ID id);                            //根据id查询数据
    List<T> queryAll();                            //查询表中所有的数据
    List<T> queryByColumnAndValue(String columnName,Object columnValue);    //根据列名与列的值查询
    List<T> queryByColumnNameOrder(String column,boolean ascending);       //根据列名按照一定的顺序查询
    int deleteForId(ID id);                        //根据id删除数据
    int deleteBitch(Collection<T> data);                               //删除表中所有的数据
    int deleteByColumnValue(String columnName,Object columnValue);   //根据列的值删除数据
    long getCount();
    long deleteAll();
}

注意：T具体的实体类，例如：User，ID是实体类主键的类型

2）、IDao的实现类

package com.fengyu.hu.db.dao;

import android.content.Context;

import com.fengyu.hu.db.helper.DatabaseHelper;
import com.j256.ormlite.android.apptools.OpenHelperManager;
import com.j256.ormlite.dao.Dao;
import com.j256.ormlite.stmt.DeleteBuilder;

import java.sql.SQLException;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.Callable;

/**
 * <pre>
 *      author : xiaohu
 *      time   : 2018/1/26
 *      des    :Dao实现类
 *
 *  <pre/>
 */

public class DaoImpl<T,ID> implements IDao<T,ID>{
    protected Dao<T,ID> mDao;

    @SuppressWarnings("unchecked")
    public DaoImpl(Context context,Class openHelperClass,Class<T> typeInstance) {
        try {
            mDao = OpenHelperManager.getHelper(context,openHelperClass).getDao(typeInstance);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     *
     * @param t 插入数据
     * 如果主键不存在则插入，反之则更新数据
     */
    @Override
    public int insert(T t) {
        try {
            return mDao.create(t);
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        }
    }

    @Override
    public int createOrUpdate(T t) {
        try {
            return mDao.createOrUpdate(t).getNumLinesChanged();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 批量插入数据
     * @param data 要插入的数据
     */
    @Override
    public void insertBitch(final List<T> data) {
        if(data == null || data.isEmpty()){
            return ;
        }
        try {
            mDao.callBatchTasks(new Callable<Void>() {
                @Override
                public Void call() throws Exception {
                    for (T t : data ){
                        mDao.create(t);
                    }
                    return null;
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     *
     * @param data 批量更新数据
     */
    @Override
    public void updateBitch(final List<T> data) {
        if(data == null || data.isEmpty()){
            return ;
        }
        try {
            mDao.callBatchTasks(new Callable<Void>() {
                @Override
                public Void call() throws Exception {
                    for (T t : data) {
                        mDao.update(t);
                    }
                    return null;
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     *
     * @param t 更新数据
     */
    @Override
    public int update(T t) {
        try {
            return mDao.update(t);
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        }
    }


    /**
     * 根据主键id查询数据
     * @param id 主键id
     * @return 查询到的数据
     */
    @Override
    public T queryForId(ID id) {
        try {
            return mDao.queryForId(id);
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     *
     * @return 查询所有数据
     */
    @Override
    public List<T> queryAll() {
        try {
            return mDao.queryForAll();
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public List<T> queryByColumnAndValue(String columnName, Object columnValue) {
        try {
            return  mDao.queryBuilder().where().eq(columnName,columnValue).query();
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

    @Override
    public List<T> queryByColumnNameOrder(String column,boolean ascending) {
        try {
            return mDao.queryBuilder().orderBy(column,ascending).query();
        } catch (SQLException e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     *
     * @param id 根据id删除数据
     */
    @Override
    public int  deleteForId(ID id) {
        try {
            return mDao.deleteById(id);
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     *  批量删除数据
     * @param data 要删除所有的数据
     */
    @Override
    public int deleteBitch(Collection<T> data) {
        if(data == null || data.isEmpty()){
            return 0;
        }
        try {
            return mDao.delete(data);
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     *
     * @param columnName 列名
     * @param columnValue   列的值
     * @return 删除表中条数
     */
    @Override
    public int deleteByColumnValue(String columnName,Object columnValue) {
        try {
            List<T> t = mDao.queryBuilder().where().eq(columnName,columnValue).query();
            return mDao.delete(t);
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     *
     * @return 表中所有数据的条数
     */
    @Override
    public long getCount() {
        try {
            return mDao.countOf();
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     *
     * @return 删除表中所有的数据
     */
    @Override
    public long deleteAll() {
        try {
            DeleteBuilder<T,ID> deleteBuilder = mDao.deleteBuilder();
            return mDao.delete(deleteBuilder.prepare());
        } catch (SQLException e) {
            e.printStackTrace();
            return 0;
        }
    }

}

5、DatabaseHelper类的重写

package com.fengyu.hu.db.helper;

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

import com.fengyu.hu.Utils.PathUtils;
import com.fengyu.hu.db.bean.Article;
import com.fengyu.hu.db.bean.User;
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;
import java.util.HashMap;
import java.util.Map;

/**
 * <pre>
 *      author : xiaohu
 *      time   : 2018/1/23
 *      des    :    orm数据库帮助者
 *  <pre/>
 */

public class DatabaseHelper extends OrmLiteSqliteOpenHelper{
    private static DatabaseHelper mHelper;

    public DatabaseHelper(Context context) {
        //把数据库放到sd卡上面
        super(context, PathUtils.getFilePath(PathUtils.FNG_YU,PathUtils.DB_NAME), null, 1);
    }

    @Override
    public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
        try {
            //创建表
            TableUtils.createTable(connectionSource, User.class);
            TableUtils.createTable(connectionSource, Article.class);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
        try {
            TableUtils.dropTable(connectionSource, User.class, true);
            TableUtils.dropTable(connectionSource, Article.class,true);
            onCreate(database);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static synchronized DatabaseHelper getInstance(Context context){
        if(mHelper == null){
            synchronized (DatabaseHelper.class){
                if(mHelper == null){
                    mHelper = new DatabaseHelper(context.getApplicationContext());
                }
            }
        }
        return mHelper;
    }

    @Override
    public void close() {
        super.close();
        for (String key : daos.keySet()){
            Dao d = daos.get(key);
            d = null;
        }
    }

    /*private Dao<User,Integer> userDao;              //这个Dao<User,Integer>中的Integer可以理解为User这个类相关联的主键类型
    public Dao<User,Integer> getUserDao() throws SQLException {
        if(userDao == null){
            userDao = getDao(User.class);
        }
        return userDao;
    }*/

    private Map<String, Dao> daos = new HashMap<>();
    @SuppressWarnings("unchecked")
    public synchronized Dao getDao(Class clazz) throws SQLException {
        Dao dao;
        String simpleName = clazz.getSimpleName();
        if(daos.containsKey(simpleName)){
            dao = daos.get(simpleName);
        }else{
            dao = super.getDao(clazz);
            daos.put(simpleName,dao);
        }
        return dao;
    }

    public void onInsertOtherTable(){
        try {
            TableUtils.createTableIfNotExists(connectionSource,Article.class);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public boolean openDatabase(){
        return this.isOpen();
    }

    public void closeDatabase(){
        this.close();
    }
}

注意数据库在退出APP要关闭，在MainActivity类中的onDestroy方法调用

DatabaseHelper.getInstance(this).close();

demo的下载地址：http://download.csdn.net/download/hujiaxi222/10239685

猜你喜欢