1.OrmLiteSqliteOpenHelper封装
/**
* 数据库创建、更新基类
*
* @author: NPF
* @date: 2018/2/27.
*/
public abstract class DBBaseOpenHelper extends OrmLiteSqliteOpenHelper {
private final String TAG = "nan";
/**
* 需要初始化的属性
*/
private static Context mContext;
/**
* 所有数据表的映射实体类的字节码对象
*/
private Class[] mTableBeanClass;
/**
* 构造进行数据库信息初始化
*
* @param dbName 数据库名称
* @param dbVersion 数据库版本
* @param tableBeanClass 需要创建的表的映射实体字节码
*/
public DBBaseOpenHelper(@NotNull String dbName, int dbVersion, Class... tableBeanClass) {
this(mContext, dbName, null, dbVersion);
mTableBeanClass = tableBeanClass;
if (null == mContext) {
throw new RuntimeException("必须在Application中调用DBBaseOpenHelper.initInstance()");
}
if (TextUtils.isEmpty(dbName)) {
throw new RuntimeException("DBBaseOpenHelper中数据库名 dbName 不能为空");
}
}
/**
* 继承自父类构造,私有化禁止子类调用
*
* @param context
* @param databaseName
* @param factory
* @param databaseVersion
*/
private DBBaseOpenHelper(Context context, String databaseName, SQLiteDatabase.CursorFactory factory, int databaseVersion) {
super(context, databaseName, factory, databaseVersion);
}
/**
* 初始化,需要在Application中进行初始化
*
* @param context
*/
public static void initInstance(Context context) {
mContext = context;
}
/**
* 数据库表创建
*
* @param database
* @param connectionSource
*/
@Override
public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
try {
if (null != mTableBeanClass && mTableBeanClass.length > 0) {
for (Class tableBeanClass : mTableBeanClass) {
int tableIfNotExists = TableUtils.createTableIfNotExists(connectionSource, tableBeanClass);
Log.e(TAG, "创建表====" + tableIfNotExists + "===" + tableBeanClass);
}
}
} catch (SQLException e) {
e.printStackTrace();
}
}
/**
* 数据库更新
*
* @param database
* @param connectionSource
* @param oldVersion
* @param newVersion
*/
@Override
public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
update(database, connectionSource, oldVersion, newVersion);
}
/**
* 子类实现,主要编写在数据库进行更新时需要进行的操作,可以借助DBTableOperate操作类进行处理
*
* @param database
* @param connectionSource
* @param oldVersion
* @param newVersion
*/
protected abstract void update(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion);}
2.针对数据库表映射数据实体类的操作类封装
/**
* 表数据操作基类(仅提供简单的增删改查),
* 复杂查询需要在子类中自行扩展实现;
*
* @author: NPF
* @date: 2018/2/26.
*/
public class DBBaseTableDao<T, V> {
private final String TAG = "nan";
protected Class<T> mClassz;
protected Dao<T, V> mDao;
/**
* 构造函数,子类必须处理
*
* @param openHelper 数据库操作基类
*/
public DBBaseTableDao(DBBaseOpenHelper openHelper) {
if (null == openHelper) {
throw new RuntimeException(this.getClass().getSimpleName() + "中OrmLiteSqliteOpenHelper没有找到!");
}
Class clazz = getClass();
while (clazz != Object.class) {
Type type = clazz.getGenericSuperclass();
if (type instanceof ParameterizedType) {
Type[] args = ((ParameterizedType) type).getActualTypeArguments();
if (args[0] instanceof Class) {
this.mClassz = (Class<T>) args[0];
break;
}
}
clazz = clazz.getSuperclass();
}
try {
mDao = openHelper.getDao(this.mClassz);
} catch (Exception ep) {
ep.printStackTrace();
}
}
/**
* 插入单条数据,在没有ID字段的情况下使用最好
* 有ID字段,使用insert(T tableBean, V idValue)
*
* @param tableBean 表单条映射数据实体
* @return int
*/
public int insert(T tableBean) {
int result = -1;
try {
result = mDao.create(tableBean);
} catch (SQLException e) {
e.printStackTrace();
Log.e(TAG, String.format(Locale.CHINESE, "数据添加失败,原因：%s", e.getMessage()));
}
return result;
}
/**
* 插入单条数据
*
* @param tableBean 表单条映射数据实体
* @param idValue 该条数据的ID字段值
* @return int
*/
public int insert(T tableBean, V idValue) {
int result = -1;
try {
T queryTableBean = mDao.queryForId(idValue);
if (null == queryTableBean) {
result = mDao.create(tableBean);
} else {
Log.e(TAG, String.format(Locale.CHINESE, "ID为 %s 的数据已经存在,不可重复添加!", String.valueOf(idValue)));
}
} catch (SQLException e) {
e.printStackTrace();
Log.e(TAG, String.format(Locale.CHINESE, "数据添加失败,原因：%s", e.getMessage()));
}
return result;
}
/**
* 插入多条数据
*
* @param mapTableBeans 表映射数据实体Map集合,key:该表的ID值,value:表单条映射的数据实体
* @return int
*/
public int insert(Map<V, T> mapTableBeans) {
int result = -1;
List<T> tableBeans = new ArrayList<>();
try {
for (V idValue : mapTableBeans.keySet()) {
T queryTableBean = mDao.queryForId(idValue);
if (null == queryTableBean) {
tableBeans.add(mapTableBeans.get(idValue));
} else {
Log.e(TAG, String.format(Locale.CHINESE, "ID为 %s 的数据已经存在,不可重复添加!", String.valueOf(idValue)));
}
}
result = mDao.create(tableBeans);
} catch (SQLException e) {
e.printStackTrace();
tableBeans = null;
Log.e(TAG, String.format(Locale.CHINESE, "数据批量添加失败,原因：%s", e.getMessage()));
}
return result;
}
/**
* 通过id进行数据删除
*
* @param idValue 该表指定为ID的字段值
* @return int
*/
public int deleteById(V idValue) {
int result = -1;
try {
result = mDao.deleteById(idValue);
} catch (SQLException e) {
e.printStackTrace();
Log.e(TAG, String.format(Locale.CHINESE, "通过ID %s 删除数据失败,原因：%s", String.valueOf(idValue), e.getMessage()));
}
return result;
}
/**
* 指定列及该列值,删除该条数据
*
* @param columnName 列名
* @param columnValue 列值
* @return int
*/
public int deleteByColumn(String columnName, Object columnValue) {
int result = -1;
try {
DeleteBuilder builder = mDao.deleteBuilder();
builder.where().eq(columnName, columnValue);
result = builder.delete();
} catch (SQLException e) {
e.printStackTrace();
Log.e(TAG, String.format(Locale.CHINESE, "自定义删除指定列数据失败,原因：%s", e.getMessage()));
}
return result;
}
/**
* 删除 列columnName1 = columnValue1 并且 columnName2 = columnValue2
*
* @param columnName1 列名1
* @param columnValue1 列值1
* @param columnName2 列名2
* @param columnValue2 列值2
* @return int
*/
public int deleteByColumnAnd(String columnName1, Object columnValue1, String columnName2, Object columnValue2) {
int result = -1;
try {
DeleteBuilder<T, V> builder = mDao.deleteBuilder();
Where<T, V> where = builder.where();
where.and(where.eq(columnName1, columnValue1), where.eq(columnName2, columnValue2));
result = builder.delete();
} catch (SQLException e) {
e.printStackTrace();
Log.e(TAG, String.format(Locale.CHINESE, "自定义删除指定列数据失败 And,原因：%s", e.getMessage()));
}
return result;
}
/**
* 删除 列columnName1 = columnValue1 或 columnName2 = columnValue2
*
* @param columnName1 列名1
* @param columnValue1 列值1
* @param columnName2 列名2
* @param columnValue2 列值2
* @return int
*/
public int deleteByColumnOr(String columnName1, Object columnValue1, String columnName2, Object columnValue2) {
int result = -1;
try {
DeleteBuilder<T, V> builder = mDao.deleteBuilder();
Where<T, V> where = builder.where();
where.or(where.eq(columnName1, columnValue1), where.eq(columnName2, columnValue2));
result = builder.delete();
} catch (SQLException e) {
e.printStackTrace();
Log.e(TAG, String.format(Locale.CHINESE, "自定义删除指定列数据失败 Or,原因：%s", e.getMessage()));
}
return result;
}
/**
* 删除表中指定数据(可用于无ID 参数情况下删除)
*
* @param tableBean 数据映射实体
* @return int
*/
public int delete(T tableBean) {
int result = -1;
try {
result = mDao.delete(tableBean);
} catch (SQLException e) {
e.printStackTrace();
Log.e(TAG, String.format(Locale.CHINESE, "删除表中 %s 数据失败,原因：%s", tableBean.getClass().getSimpleName(), e.getMessage()));
}
return result;
}
/**
* 删除表中所有数据
*
* @return int
*/
public int deleteAll() {
int result = -1;
try {
result = mDao.deleteBuilder().delete();
} catch (SQLException e) {
e.printStackTrace();
Log.e(TAG, String.format(Locale.CHINESE, "删除所有数据失败,原因：%s", e.getMessage()));
}
return result;
}
/**
* 更新表中数据
*
* @param tableBean 数据映射实体
* @return int
*/
public int update(T tableBean) {
int result = -1;
try {
result = mDao.update(tableBean);
} catch (SQLException e) {
e.printStackTrace();
}
return result;
}
/**
* 更新该条数据的ID值
*
* @param tableBean 该条数据映射实体
* @param newId 新的ID值
* @return int
*/
public int update(T tableBean, V newId) {
int result = -1;
try {
result = mDao.update(tableBean);
} catch (SQLException e) {
e.printStackTrace();
}
return result;
}
/**
* 添加或者更新数据,
* 可在返回的Dao.CreateOrUpdateStatus中通过isCreated()、isUpdated()判断类型，、,
* 并且可以通过getNumLinesChanged()获取改变行数
*
* @param tableBean 单条数据映射实体
* @return Dao.CreateOrUpdateStatus
*/
public Dao.CreateOrUpdateStatus createOrUpdate(T tableBean) {
Dao.CreateOrUpdateStatus status = null;
try {
status = mDao.createOrUpdate(tableBean);
} catch (SQLException e) {
e.printStackTrace();
}
return status;
}
/**
* 查询表中所有数据
*
* @return List<T>
*/
public List<T> queryAll() {
List<T> tableBeans = new ArrayList<>();
try {
tableBeans.addAll(mDao.queryForAll());
} catch (Exception e) {
e.printStackTrace();
Log.e(TAG, String.format(Locale.CHINESE, "查询所有数据失败,原因：%s", e.getMessage()));
}
return tableBeans;
}
/**
* 通过ID查询指定数据
*
* @param idValue 该表指定为ID的字段值
* @return T
*/
public T queryById(V idValue) {
T tableBean = null;
try {
tableBean = mDao.queryForId(idValue);
} catch (SQLException e) {
e.printStackTrace();
Log.e(TAG, String.format(Locale.CHINESE, "通过ID %s 查询数据失败,原因：%s", String.valueOf(idValue), e.getMessage()));
}
return tableBean;
}
/**
* 指定列、列值查询该条数据
*
* @param columnName 列名
* @param columnValue 列值
* @return List<T>
*/
public List<T> queryByColumn(String columnName, Object columnValue) {
List<T> tableBeans = new ArrayList<>();
try {
QueryBuilder<T, V> builder = mDao.queryBuilder();
builder.where().eq(columnName, columnValue);
tableBeans = builder.query();
} catch (SQLException e) {
e.printStackTrace();
Log.e(TAG, String.format(Locale.CHINESE, "查询所有数据失败,原因：%s", e.getMessage()));
}
return tableBeans;
}
/**
* 查询columnName1 = columnValue1 并且 columnName2 = columnValue2的数据
*
* @param columnName1 列名1
* @param columnValue1 列值1
* @param columnName2 列名2
* @param columnValue2 列值2
* @return List<T>
*/
public List<T> queryByColumnAnd(String columnName1, Object columnValue1, String columnName2, Object columnValue2) {
List<T> tableBeans = new ArrayList<>();
try {
QueryBuilder<T, V> builder = mDao.queryBuilder();
Where<T, V> where = builder.where();
where.and(where.eq(columnName1, columnValue1), where.eq(columnName2, columnValue2));
tableBeans = builder.query();
} catch (SQLException e) {
e.printStackTrace();
Log.e(TAG, String.format(Locale.CHINESE, "自定义查询数据失败 And ,原因：%s", e.getMessage()));
}
return tableBeans;
}
/**
* 查询columnName1 = columnValue1 或 columnName2 = columnValue2的数据
*
* @param columnName1 列名1
* @param columnValue1 列值1
* @param columnName2 列名2
* @param columnValue2 列值2
* @return List<T>
*/
public List<T> queryByColumnOr(String columnName1, Object columnValue1, String columnName2, Object columnValue2) {
List<T> tableBeans = new ArrayList<>();
try {
QueryBuilder<T, V> builder = mDao.queryBuilder();
Where<T, V> where = builder.where();
where.or(where.eq(columnName1, columnValue1), where.eq(columnName2, columnValue2));
tableBeans = builder.query();
} catch (SQLException e) {
e.printStackTrace();
Log.e(TAG, String.format(Locale.CHINESE, "自定义查询数据失败 Or ,原因：%s", e.getMessage()));
}
return tableBeans;
}
/**
* 查询表中数据总条数
*
* @return
*/
public long count() {
long result = 0;
try {
result = mDao.countOf();
} catch (SQLException e) {
e.printStackTrace();
Log.e(TAG, String.format(Locale.CHINESE, "查询数据总条数失败,原因：%s", e.getMessage()));
}
return result;
}}
3.数据库具体配置类实现,继承自OrmLiteSqliteOpenHelper封装类DBBaseOpenHelper
/**
* 数据库具体操作类
*
* @author: NPF
* @date: 2018/2/24.
*/
public class ORMLiteHelper extends DBBaseOpenHelper {
/**
* 数据库名称
*/
private static final String DBNAME = "dbName";
/**
* 数据库版本
*/
private static final int DBVERSION = 1;
/**
* 初始化数据库信息
*
* @param dbName
* @param dbVersion
* @param classz 需要创建的表映射的数据实体类
*/
public ORMLiteHelper(@NotNull String dbName, int dbVersion, Class... classz) {
super(dbName, dbVersion, classz);
}
/**
* 类实例
*/
private static ORMLiteHelper mInstance;
/**
* 单例模式获取实例
*/
public static ORMLiteHelper getInstance() {
if (null == mInstance) {
synchronized (ORMLiteHelper.class) {
if (null == mInstance) {
mInstance = new ORMLiteHelper(DBNAME, DBVERSION, OrmTable.class);
}
}
}
return mInstance;
}
/**
* 数据库版本迭代执行该函数
*
* @param database
* @param connectionSource
* @param oldVersion
* @param newVersion
*/
@Override
protected void update(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
}}
4.单表数据操作具体类实现，继承自DBBaseTableDao<T, V>
/**
* 单表数据实体对应的数据操作类
*
* @author: NPF
* @date: 2018/2/24.
*/
public class OrmTableDao extends DBBaseTableDao<OrmTable, String> {
private static OrmTableDao mInstance;
public OrmTableDao(DBBaseOpenHelper openHelper) {
super(openHelper);
}
/**
* 单例模式获取实例
*/
public static OrmTableDao getInstance() {
if (null == mInstance) {
synchronized (OrmTableDao.class) {
if (null == mInstance) {
mInstance = new OrmTableDao(ORMLiteHelper.getInstance());
}
}
}
return mInstance;
}
/**
* 自行添加基类中没有的数据操作处理函数
* <p>
* 查询 (columnName1 = columnValue1 并且 columnName2 = columnValue2) 或者 (columnName3 = columnValue3 并且 columnName4 = columnValue4)的数据
*
* @param columnName1 列名1
* @param columnValue1 列值1
* @param columnName2 列名2
* @param columnValue2 列值2
* @param columnName3 列名3
* @param columnValue3 列值3
* @param columnName4 列名4
* @param columnValue4 列值4
* @return
*/
public List<OrmTable> queryByCustom(String columnName1, Object columnValue1, String columnName2, Object columnValue2
, String columnName3, Object columnValue3, String columnName4, Object columnValue4) {
List<OrmTable> ormTables = null;
try {
QueryBuilder<OrmTable, String> builder = mDao.queryBuilder();
Where<OrmTable, String> where = builder.where();
where.or(where.and(where.eq(columnName1, columnValue1), where.eq(columnName2, columnValue2))
, where.and(where.eq(columnName3, columnValue3), where.eq(columnName4, columnValue4)));
ormTables = builder.query();
} catch (SQLException e) {
e.printStackTrace();
}
return ormTables;
}}
5.表映射数据实体类
/**
* 数据表映射数据实体类
*
* @author: NPF
* @date: 2018/2/24.
*/
@DatabaseTable(tableName = "tTable")
public class OrmTable {
/**
* columnName：列名
* id：指定该列为id列
* <p>
* 该属性被指定为id列后,其数据类型将与Dao<T,ID>中的泛型ID的类型一致
*/
@DatabaseField(columnName = "_id", id = true)
public String _id;
@DatabaseField(columnName = "name")
public String name;
@DatabaseField(columnName = "sex")
public int sex;
@DatabaseField(columnName = "age")
public int age;}
网友评论