Android ormlite 数据库-白红宇

Android ormlite 数据库

阅读量：7272 次

发布时间：2019-06-29

本文共 22447 字，大约阅读时间需要 74 分钟。

这里记录ormlite的原因：有很多效率更高的数据库比如greendao，但是使用中会有很多问题，比如greendao是自动化build的，而且需要改gradle中的配置，这就可能影响当前项目的使用。当时有个项目使用jni，

dependencies {    classpath 'com.android.tools.build:gradle:3.1.3'    // NOTE: Do not place your application dependencies here; they belong    // in the individual module build.gradle files}

greendao的配置跟项目使用的jni需要的配置冲突，很是麻烦。

ormlite的优点很明显，引入jar包，其他代码随便撸。

虽然缺点是慢，但是移动端的优化真的不在数据库这点时间，在其他方面有更大的优化空间

注意：bean成员变量用public

必须有空构造方法

dao =super.getDao(clazz);这里clazz千万不能用clazz.getClass()

有的时候dao =super.getDao(clazz);报红，是因为JDK高版本可以不显示强制转化，低版本不行，加上强转语法就行。

ormlite incompatible types required

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

package com.fnf.aiui.databases;import android.content.Context;import android.database.sqlite.SQLiteDatabase;import com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper;import com.j256.ormlite.dao.Dao;import com.j256.ormlite.support.ConnectionSource;import java.sql.SQLException;import java.util.HashMap;import java.util.Map;/** * Created by wfy 2017/7/5 11:25. */public class DatabaseHelper extends OrmLiteSqliteOpenHelper {    public interface OnCreateListener {        void onCreate(SQLiteDatabase database, ConnectionSource connectionSource);        void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion);    }    private static OnCreateListener onCreateListener;    public static void setDbInfo(String dbName, int dbVersion, OnCreateListener listener) {        DB_NAME = dbName;        DB_VERSION = dbVersion;        onCreateListener = listener;    }    /**     * 数据库名字     */    private static String DB_NAME;    /**     * 数据库版本     */    private static int DB_VERSION;    private Map
    
      daos = new HashMap<>();    private DatabaseHelper(Context context) {        super(context, DB_NAME, null, DB_VERSION);    }    @Override    public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {        if(onCreateListener!=null)onCreateListener.onCreate(database,connectionSource);    }    @Override    public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {        if(onCreateListener!=null)onCreateListener.onUpgrade(database,connectionSource,oldVersion,newVersion);    }    private static DatabaseHelper instance;    /** 单例获取该Helper */    public static synchronized DatabaseHelper getHelper(Context context) {        context = context.getApplicationContext();        if (instance == null) {            synchronized (DatabaseHelper.class) {                if (instance == null) {                    instance = new DatabaseHelper(context);                }            }        }        return instance;    }    @SuppressWarnings("unchecked")    public synchronized Dao getDao(Class clazz) throws SQLException {        Dao dao = null;        String className = clazz.getSimpleName();        if (daos.containsKey(className)) {            dao = daos.get(className);        }        if (dao == null) {            dao = super.getDao(clazz);            daos.put(className, dao);        }        return dao;    }    /** 释放资源 */    @Override    public void close() {        super.close();        for (String key : daos.keySet()) {            Dao dao = daos.get(key);            dao = null;        }    }}

package com.fnf.aiui.databases;import android.content.Context;import com.j256.ormlite.dao.Dao;import com.j256.ormlite.stmt.DeleteBuilder;import com.j256.ormlite.stmt.PreparedDelete;import com.j256.ormlite.stmt.PreparedQuery;import com.j256.ormlite.stmt.PreparedUpdate;import com.j256.ormlite.stmt.QueryBuilder;import com.j256.ormlite.stmt.UpdateBuilder;import com.j256.ormlite.stmt.Where;import com.j256.ormlite.support.DatabaseConnection;import java.security.InvalidParameterException;import java.sql.SQLException;import java.util.Iterator;import java.util.List;import java.util.Map;/** * 数据库CRUD操作的Dao，子类继承实现抽象方法 * Created by wfy 2017/7/5 11:25. */public abstract class BaseDao
    
      {    protected Context mContext;    protected DatabaseHelper mDatabaseHelper;    public BaseDao(Context context) {        if (context == null) {            throw new IllegalArgumentException("Context can't be null!");        }        mContext = context.getApplicationContext();        mDatabaseHelper = DatabaseHelper.getHelper(mContext);    }    /**     * public Dao
     
       getDao() throws SQLException     *     * @return     * @throws SQLException     */    public abstract Dao
      
        getDao() throws SQLException;    /**************************************** 保存 ******************************************************/    /**     * 插入一条记录     *     * @param t     */    public void insert(T t) {        try {            Dao
       
         dao = getDao();            dao.create(t);        } catch (SQLException e) {            e.printStackTrace();        }    }    /**     * 插入一组记录，使用事务处理     *     * @param list     */    public void insertList(List
        
          list) {        if (list.size() <= 0) return;        try {            Dao
         
           dao = getDao(); DatabaseConnection databaseConnection = null; try { databaseConnection = dao.startThreadConnection(); dao.setAutoCommit(databaseConnection, false); for (T t : list) { dao.create(t);// dao.createIfNotExists(t); } dao.commit(databaseConnection); } catch (SQLException e) { dao.rollBack(databaseConnection); e.printStackTrace(); } finally { dao.endThreadConnection(databaseConnection); } } catch (SQLException e) { e.printStackTrace(); } } /**************************************** 更新 ******************************************************/ /** * 更新一条记录 * * @param t */ public void update(T t) { try { Dao
          
            dao = getDao(); dao.update(t); } catch (SQLException e) { e.printStackTrace(); } } /** * 根据指定条件和指定字段更新记录 * * @param key * @param value * @param columnNames * @param columnValues */ public void update(String key, Object value, String[] columnNames, Object[] columnValues) { if (columnNames.length != columnNames.length) { throw new InvalidParameterException("params size is not equal"); } try { Dao
           
             dao = getDao(); UpdateBuilder
            
              updateBuilder = dao.updateBuilder(); updateBuilder.where().eq(key, value); for (int i = 0; i < columnNames.length; i++) { updateBuilder.updateColumnValue(columnNames[i], columnValues[i]); } PreparedUpdate
             
               prepareUpdate = updateBuilder.prepare(); dao.update(prepareUpdate); } catch (SQLException e) { e.printStackTrace(); } } /** * 根据指定条件和指定字段更新记录 * * @param key * @param value * @param columnNames * @param columnValues */ public void update(String[] key, Object[] value, String[] columnNames, Object[] columnValues) { if (columnNames.length != columnNames.length) { throw new InvalidParameterException("params size is not equal"); } try { Dao
              
                dao = getDao(); UpdateBuilder
               
                 updateBuilder = dao.updateBuilder(); Where
                
                  where = updateBuilder.where(); for (int i = 0; i < key.length; i++) { if (i == 0) { where.eq(key[i], value[i]); } else { where.and().eq(key[i], value[i]); } } for (int i = 0; i < columnNames.length; i++) { updateBuilder.updateColumnValue(columnNames[i], columnValues[i]); } PreparedUpdate
                 
                   prepareUpdate = updateBuilder.prepare(); dao.update(prepareUpdate); } catch (SQLException e) { e.printStackTrace(); } } /** * 根据PreparedUpdate更新记录 * * @param preparedUpdate */ public void update(PreparedUpdate
                  
                    preparedUpdate) { try { Dao
                   
                     dao = getDao(); dao.update(preparedUpdate); } catch (SQLException e) { e.printStackTrace(); } } /**************************************** 保存或更新 ******************************************************/ /** * 插入或更新一条记录，不存在则插入，否则更新 * * @param t */ public void insertOrUpdate(T t) { try { Dao
                    
                      dao = getDao(); dao.createOrUpdate(t); } catch (SQLException e) { e.printStackTrace(); } } /** * 插入或更新一组数据，使用事务处理 * * @param list */ public void insertOrUpdate(List
                     
                       list) { if (list.size() <= 0) return; try { Dao
                      
                        dao = getDao(); DatabaseConnection databaseConnection = null; try { databaseConnection = dao.startThreadConnection(); dao.setAutoCommit(databaseConnection, false); for (T t : list) { dao.createOrUpdate(t); } dao.commit(databaseConnection); } catch (SQLException e) { dao.rollBack(databaseConnection); e.printStackTrace(); } finally { dao.endThreadConnection(databaseConnection); } } catch (SQLException e) { e.printStackTrace(); } } /**************************************** 删除操作 ******************************************************/ /** * 删除一条记录 * * @param t */ public void delete(T t) { try { Dao
                       
                         dao = getDao(); dao.delete(t); } catch (SQLException e) { e.printStackTrace(); } } /** * 根据单个条件删除一条记录,如果有多个记录满足该条件，删除查询到的第一条记录 * * @param columnName * @param columnValue */ public void delete(String columnName, Object columnValue) { try { Dao
                        
                          dao = getDao(); QueryBuilder
                         
                           queryBuilder = dao.queryBuilder(); queryBuilder.where().eq(columnName, columnValue); PreparedQuery
                          
                            preparedQuery = queryBuilder.prepare(); T t = dao.queryForFirst(preparedQuery); dao.delete(t); } catch (SQLException e) { e.printStackTrace(); } } /** * 根据条件组合删除一条记录,如果有多个记录满足该条件，删除查询到的第一条记录 * * @param columnNames * @param columnValues */ public void delete(String[] columnNames, Object[] columnValues) { if (columnNames.length != columnNames.length) { throw new InvalidParameterException("params size is not equal"); } try { QueryBuilder
                           
                             queryBuilder = getDao().queryBuilder(); Where
                            
                              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
                             
                               preparedQuery = queryBuilder.prepare(); Dao
                              
                                dao = getDao(); T t = dao.queryForFirst(preparedQuery); delete(t); } catch (SQLException e) { e.printStackTrace(); } } /** * 删除一组记录，使用事务处理 * @param list */ /** * 注意：Dao.delete(Collection
                               
                                 datas)方法删除，最多只能删除999条记录 **/ public void deleteList(List
                                
                                  list) { if (list.size() <= 0) return; try { Dao
                                 
                                   dao = getDao(); DatabaseConnection databaseConnection = null; try { databaseConnection = dao.startThreadConnection(); dao.setAutoCommit(databaseConnection, false); for (T t : list) { dao.delete(t); } dao.commit(databaseConnection); } catch (SQLException e) { dao.rollBack(databaseConnection); e.printStackTrace(); } finally { dao.endThreadConnection(databaseConnection); } } catch (SQLException e) { e.printStackTrace(); }// try {// Dao
                                  
                                    dao = getDao();// dao.delete(list);// } catch (SQLException e) {// e.printStackTrace();// } } /** * 根据条件删除满足条件的所有记录 * * @param columnName * @param columnValue */ public void deleteList(String columnName, Object columnValue) { try { Dao
                                   
                                     dao = getDao(); DeleteBuilder
                                    
                                      deleteBuilder = dao.deleteBuilder(); deleteBuilder.where().eq(columnName, columnValue); PreparedDelete
                                     
                                       preparedDelete = deleteBuilder.prepare(); dao.delete(preparedDelete); } catch (SQLException e) { e.printStackTrace(); } } /** * 根据条件组合删除所有满足条件的记录 * * @param columnNames * @param columnValues */ public void deleteList(String[] columnNames, Object[] columnValues) { if (columnNames.length != columnNames.length) { throw new InvalidParameterException("params size is not equal"); } try { Dao
                                      
                                        dao = getDao(); DeleteBuilder
                                       
                                         deleteBuilder = dao.deleteBuilder(); Where
                                        
                                          wheres = deleteBuilder.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]); } } PreparedDelete
                                         
                                           preparedDelete = deleteBuilder.prepare(); dao.delete(preparedDelete); } catch (SQLException e) { e.printStackTrace(); } } /** * 根据id删除一条记录 * * @param id */ public void deleteById(Integer id) { try { Dao
                                          
                                            dao = getDao(); dao.deleteById(id); } catch (SQLException e) { e.printStackTrace(); } } /** * 根据id数组删除一组记录 * * @param ids */ public void deleteByIds(List
                                           
                                             ids) { try { Dao
                                            
                                              dao = getDao(); dao.deleteIds(ids); } catch (SQLException e) { e.printStackTrace(); } } /** * 根据PreparedDelete删除记录 * * @param preparedDelete */ public void delete(PreparedDelete
                                             
                                               preparedDelete) { try { Dao
                                              
                                                dao = getDao(); dao.delete(preparedDelete); } catch (SQLException e) { e.printStackTrace(); } } /** * 删除表中的所有记录 */ public void deleteAll() { try { Dao
                                               
                                                 dao = getDao(); DeleteBuilder
                                                
                                                  deleteBuilder = dao.deleteBuilder(); PreparedDelete
                                                 
                                                   preparedDelete = deleteBuilder.prepare(); dao.delete(preparedDelete); } catch (SQLException e) { e.printStackTrace(); } } /** * 清空一张表中的数据 * * @param table 表名 */ public void clearTable(String table) { try { Dao
                                                  
                                                    dao = getDao(); String delete = String.format("delete from %s", table); dao.queryRaw(delete);//清空数据 String updateSeq = String.format("update sqlite_sequence SET seq = 0 where name ='%s'", table); dao.queryRaw(updateSeq);//自增长ID为0 } catch (SQLException e) { e.printStackTrace(); } } /**************************************** 查询操作 ******************************************************/ /** * 根据单个条件查询一条记录 * * @param columnName * @param columnValue * @return */ public T query(String columnName, Object columnValue) { try { Dao
                                                   
                                                     dao = getDao(); QueryBuilder
                                                    
                                                      queryBuilder = dao.queryBuilder(); queryBuilder.where().eq(columnName, columnValue); PreparedQuery
                                                     
                                                       preparedQuery = queryBuilder.prepare(); T t = dao.queryForFirst(preparedQuery); return t; } catch (SQLException e) { e.printStackTrace(); } return null; } /** * 根据条件组合查询一条记录 * * @param columnNames * @param columnValues * @return */ public T query(String[] columnNames, Object[] columnValues) { if (columnNames.length != columnNames.length) { throw new InvalidParameterException("params size is not equal"); } try { QueryBuilder
                                                      
                                                        queryBuilder = getDao().queryBuilder(); Where
                                                       
                                                         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
                                                        
                                                          preparedQuery = queryBuilder.prepare(); Dao
                                                         
                                                           dao = getDao(); T t = dao.queryForFirst(preparedQuery); return t; } catch (SQLException e) { e.printStackTrace(); } return null; } /** * 根据PreparedQuery查询所有记录 * * @param preparedQuery * @return */ public List
                                                          
                                                            queryList(PreparedQuery
                                                           
                                                             preparedQuery) { try { Dao
                                                            
                                                              dao = getDao(); DatabaseConnection databaseConnection = null; try { databaseConnection = dao.startThreadConnection(); dao.setAutoCommit(databaseConnection, false); List
                                                             
                                                               query = dao.query(preparedQuery); dao.commit(databaseConnection); return query; } catch (SQLException e) { dao.rollBack(databaseConnection); e.printStackTrace(); } finally { dao.endThreadConnection(databaseConnection); } } catch (SQLException e) { e.printStackTrace(); } return null; } /** * 根据单个条件查询所有满足条件的记录 * * @param columnName * @param columnValue * @return */ public List
                                                              
                                                                queryList(String columnName, Object columnValue) { try { Dao
                                                               
                                                                 dao = getDao(); QueryBuilder
                                                                
                                                                  queryBuilder = dao.queryBuilder(); queryBuilder.where().eq(columnName, columnValue); PreparedQuery
                                                                 
                                                                   preparedQuery = queryBuilder.prepare(); List
                                                                  
                                                                    query = dao.query(preparedQuery); return query; } catch (SQLException e) { e.printStackTrace(); } return null; } /** * 根据条件组合查询所有满足条件的记录 * * @param columnNames * @param columnValues * @return */ public List
                                                                   
                                                                     queryList(String[] columnNames, Object[] columnValues) { if (columnNames.length != columnNames.length) { throw new InvalidParameterException("params size is not equal"); } try { Dao
                                                                    
                                                                      dao = getDao(); QueryBuilder
                                                                     
                                                                       queryBuilder = dao.queryBuilder(); Where
                                                                      
                                                                        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
                                                                       
                                                                         preparedQuery = queryBuilder.prepare(); List
                                                                        
                                                                          query = dao.query(preparedQuery); return query; } catch (SQLException e) { e.printStackTrace(); } return null; } /** * 根据键值对查询所有满足条件的记录 * * @param map * @return */ public List
                                                                         
                                                                           queryList(Map
                                                                          
                                                                            map) { try { Dao
                                                                           
                                                                             dao = getDao(); QueryBuilder
                                                                            
                                                                              queryBuilder = dao.queryBuilder(); if (!map.isEmpty()) { Where
                                                                             
                                                                               wheres = queryBuilder.where(); Iterator
                                                                              
                                                                               
                                                                                > iterator = map.entrySet().iterator(); String key = null; Object value = null; for (int i = 0; iterator.hasNext(); i++) { Map.Entry
                                                                                
                                                                                  next = iterator.next(); key = next.getKey(); value = next.getValue(); if (i == 0) { wheres.eq(key, value); } else { wheres.and().eq(key, value); } } } PreparedQuery
                                                                                 
                                                                                   preparedQuery = queryBuilder.prepare(); List
                                                                                  
                                                                                    query = dao.query(preparedQuery); return query; } catch (SQLException e) { e.printStackTrace(); } return null; } /** * 根据Id查询 * * @param id * @return */ public T queryById(Integer id) { try { Dao
                                                                                   
                                                                                     dao = getDao(); T t = dao.queryForId(id); return t; } catch (SQLException e) { e.printStackTrace(); } return null; } /** * 查询所有记录 * * @return */ public List
                                                                                    
                                                                                      queryAll() { try { Dao
                                                                                     
                                                                                       dao = getDao(); List
                                                                                      
                                                                                        query = dao.queryForAll(); return query; } catch (SQLException e) { e.printStackTrace(); } return null; } /** * 条件查询 * * @param offset 偏移量 * @param limit 查询数量 * @param columnName * @param columnValue * @return */ public List
                                                                                       
                                                                                         queryAll(long offset, long limit, String columnName, Object columnValue) { try { Dao
                                                                                        
                                                                                          dao = getDao(); QueryBuilder
                                                                                         
                                                                                           queryBuilder = dao.queryBuilder(); queryBuilder.offset(offset) .limit(limit) .where().eq(columnName, columnValue); PreparedQuery
                                                                                          
                                                                                            preparedQuery = queryBuilder.prepare(); List
                                                                                           
                                                                                             query = dao.query(preparedQuery); return query; } catch (SQLException e) { e.printStackTrace(); } return null; } /** * 条件查询 * * @param offset 偏移量 * @param limit 查询数量 * @return */ public List
                                                                                            
                                                                                              queryAll(long offset, long limit) { try { Dao
                                                                                             
                                                                                               dao = getDao(); QueryBuilder
                                                                                              
                                                                                                queryBuilder = dao.queryBuilder(); queryBuilder.offset(offset) .limit(limit); PreparedQuery
                                                                                               
                                                                                                 preparedQuery = queryBuilder.prepare(); List
                                                                                                
                                                                                                  query = dao.query(preparedQuery); return query; } catch (SQLException e) { e.printStackTrace(); } return null; } /** * 条件查询 * * @param offset 偏移量 * @param limit 查询数量 * @param order 排序字段 * @param ascending true--升序 false--降序 * @return */ public List
                                                                                                 
                                                                                                   queryAll(long offset, long limit, String order, boolean ascending) { try { Dao
                                                                                                  
                                                                                                    dao = getDao(); QueryBuilder
                                                                                                   
                                                                                                     queryBuilder = dao.queryBuilder(); queryBuilder.orderBy(order, ascending) .offset(offset) .limit(limit); PreparedQuery
                                                                                                    
                                                                                                      preparedQuery = queryBuilder.prepare(); List
                                                                                                     
                                                                                                       query = dao.query(preparedQuery); return query; } catch (SQLException e) { e.printStackTrace(); } return null; } /**************************************** 其他操作 ******************************************************/ /** * 表是否存在 * * @return true--存在 false-- 不存在 */ public boolean isTableExists() { try { return getDao().isTableExists(); } catch (SQLException e) { e.printStackTrace(); } return false; } /** * 获得记录数 * * @return 记录数 */ public long count() { try { Dao
                                                                                                      
                                                                                                        dao = getDao(); long count = dao.countOf(); return count; } catch (SQLException e) { e.printStackTrace(); } return 0; } /** * 获得记录数 * * @param preparedQuery * @return 记录数 */ public long count(PreparedQuery
                                                                                                       
                                                                                                         preparedQuery) { try { Dao
                                                                                                        
                                                                                                          dao = getDao(); long count = dao.countOf(preparedQuery); return count; } catch (SQLException e) { e.printStackTrace(); } return 0; }}

package com.fnf.aiui.databases;import android.content.Context;import com.j256.ormlite.dao.Dao;import java.sql.SQLException;/** * Created by wfy 2017/7/5 10:54. * */public class BaseDaoImpl
    
      extends BaseDao
     
       {    private Class
      
        clazz;    private Dao
       
         dao;    public BaseDaoImpl(Context context, Class
        
          clazz) {        super(context);        // TODO Auto-generated constructor stub        this.clazz = clazz;    }    @Override    public Dao
         
           getDao() throws SQLException { // TODO Auto-generated method stub if (null == dao) { dao = mDatabaseHelper.getDao(clazz); } return dao; }}

package com.photo.album.bean;import com.j256.ormlite.field.DatabaseField;import com.j256.ormlite.table.DatabaseTable;@DatabaseTable(tableName = "table_worker")public class Worker {    @DatabaseField(generatedId = true)    public int id;    @DatabaseField(columnName = "name")    public String name;    @DatabaseField(columnName = "jobNum")    public long jobNum;    @DatabaseField(columnName = "profession", foreign = true, foreignAutoRefresh = true)    public Profession profession;    public Worker() {    }    public Worker(String name, long jobNum) {        this.name = name;        this.jobNum = jobNum;    }    public Worker(String name, long jobNum, Profession profession) {        this.name = name;        this.jobNum = jobNum;        this.profession = profession;    }    @Override    public boolean equals(Object o) {        if (this == o) return true;        if (o == null || getClass() != o.getClass()) return false;        Worker worker = (Worker) o;        return id == worker.id;    }    @Override    public int hashCode() {        return id;    }}

package com.photo.album.db;import android.content.Context;import com.photo.album.bean.Worker;import com.wuzhou.wlibrary.db.BaseDaoImpl;/** * Created by wfy 2017/7/6 09:20. */public class WorkDao extends BaseDaoImpl {    public WorkDao(Context context) {        super(context, Worker.class);    }//此处第二个构造方法更好，可以在调用端直接看到绑定的实体类  public WorkDao(Context context, Class clazz) {        super(context, clazz);    }    /**     * 自定义方法，常用的话 为了方便     * @param worker     * @return     */    public boolean isExist(Worker worker){        boolean b;        if(query("jobNum",worker.jobNum)==null){            b=false;        }else{            b=true;        }        return b;    }}

DatabaseHelper.setDbInfo("ai_db", 1, new DatabaseHelper.OnCreateListener() {            @Override            public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {                try {                    TableUtils.createTable(connectionSource, HandlerModel.class);                } catch (SQLException e) {                    e.printStackTrace();                }            }            @Override            public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {                try {                    TableUtils.dropTable(connectionSource, HandlerModel.class, true);                    onCreate(database, connectionSource);                } catch (SQLException e) {                    e.printStackTrace();                }            }        });

转载于:https://my.oschina.net/wfy94/blog/2885655

你可能感兴趣的文章