在上一篇文章中，我们完成了原始的网络框架搭建，现在我们来搭建一下数据库和UI的基础建设。
数据库
数据库方面网上也有非常多的ORM框架，像OrmLite、GreenDAO等都是非常不错的数据映射框架。但使用起来或多或少都存在着一些不便。下面笔者为大家推荐一款非常轻量级的数据库框架LiteOrm，为什么说它非常轻量呢，因为你只需创建一个实体类，然后使用它的API去操作即可，完全不用考虑其它事情。这款国人自己开发的数据库Orm，针对中小型产品完全够用。
具体用法大家可自行查看。它最大的不足是没有Maven依赖，要想使用它，需要把源码DOWN下来，添加到项目中去。
- 进入LiteOrm页面，将源码下载下来。
- 解压文件，进入android-lite-orm-master->library->src->com目录下，将整个litesuits文件夹复制到我们项目的database->src->main->java->com目录下。这里大家可以直接到我的GitHub里找到，然后替换到你们的工程里，因为这个源码有些方法无法编译，笔者的代码是修改完的。
- 因为这个框架是比较完善的，使用起来也很简洁，最重要的是在一个工程中，经常替换数据库框架的可能性实在太低，所以，我们简单的对这个框架的API做一个装饰者即可，不需要大动干戈的去封装。所以，在com.monch.database包下创建一个类，起名叫DB，代码如下：
public class DB implements DataBase {
private LiteOrm mLiteOrm;
private DB(DataBaseConfig config) {
mLiteOrm = LiteOrm.newSingleInstance(config);
}
private static volatile DB instance;
public static void initialize(DataBaseConfig config) {
instance = new DB(config);
}
public static DB get() {
if (instance == null) {
throw new IllegalArgumentException("DB instance is null.");
}
return instance;
}
@Override
public SQLiteDatabase openOrCreateDatabase() {
return mLiteOrm.openOrCreateDatabase();
}
@Override
public long save(Object entity) {
return mLiteOrm.save(entity);
}
@Override
public <T> int save(Collection<T> collection) {
return mLiteOrm.save(collection);
}
@Override
public long insert(Object entity) {
return mLiteOrm.insert(entity);
}
@Override
public long insert(Object entity, ConflictAlgorithm conflictAlgorithm) {
return mLiteOrm.insert(entity, conflictAlgorithm);
}
@Override
public <T> int insert(Collection<T> collection) {
return mLiteOrm.insert(collection);
}
@Override
public <T> int insert(Collection<T> collection, ConflictAlgorithm conflictAlgorithm) {
return mLiteOrm.insert(collection, conflictAlgorithm);
}
@Override
public int update(Object entity) {
return mLiteOrm.update(entity);
}
@Override
public int update(Object entity, ConflictAlgorithm conflictAlgorithm) {
return mLiteOrm.update(entity, conflictAlgorithm);
}
@Override
public int update(Object entity, ColumnsValue cvs, ConflictAlgorithm conflictAlgorithm) {
return mLiteOrm.update(entity, cvs, conflictAlgorithm);
}
@Override
public <T> int update(Collection<T> collection) {
return mLiteOrm.update(collection);
}
@Override
public <T> int update(Collection<T> collection, ConflictAlgorithm conflictAlgorithm) {
return mLiteOrm.update(collection, conflictAlgorithm);
}
@Override
public <T> int update(Collection<T> collection, ColumnsValue cvs, ConflictAlgorithm conflictAlgorithm) {
return mLiteOrm.update(collection, cvs, conflictAlgorithm);
}
@Override
public int update(WhereBuilder builder, ColumnsValue cvs, ConflictAlgorithm conflictAlgorithm) {
return mLiteOrm.update(builder, cvs, conflictAlgorithm);
}
@Override
public int delete(Object entity) {
return mLiteOrm.delete(entity);
}
@Override
public <T> int delete(Class<T> claxx) {
return mLiteOrm.delete(claxx);
}
@Override
public <T> int deleteAll(Class<T> claxx) {
return mLiteOrm.deleteAll(claxx);
}
@Override
public <T> int delete(Class<T> claxx, long start, long end, String orderAscColu) {
return mLiteOrm.delete(claxx, start, end, orderAscColu);
}
@Override
public <T> int delete(Collection<T> collection) {
return mLiteOrm.delete(collection);
}
@Override
public <T> int delete(Class<T> claxx, WhereBuilder where) {
return mLiteOrm.delete(claxx, where);
}
@Override
public int delete(WhereBuilder where) {
return mLiteOrm.delete(where);
}
@Override
public <T> ArrayList<T> query(Class<T> claxx) {
return mLiteOrm.query(claxx);
}
@Override
public <T> ArrayList<T> query(QueryBuilder<T> qb) {
return mLiteOrm.query(qb);
}
@Override
public <T> T queryById(long id, Class<T> clazz) {
return mLiteOrm.queryById(id, clazz);
}
@Override
public <T> T queryById(String id, Class<T> clazz) {
return mLiteOrm.queryById(id, clazz);
}
@Override
public <T> long queryCount(Class<T> claxx) {
return mLiteOrm.queryCount(claxx);
}
@Override
public long queryCount(QueryBuilder qb) {
return mLiteOrm.queryCount(qb);
}
@Override
public SQLStatement createSQLStatement(String sql, Object[] bindArgs) {
return mLiteOrm.createSQLStatement(sql, bindArgs);
}
@Override
public boolean execute(SQLiteDatabase db, SQLStatement statement) {
return mLiteOrm.execute(db, statement);
}
@Override
public boolean dropTable(Object entity) {
return mLiteOrm.dropTable(entity);
}
@Override
public boolean dropTable(Class<?> claxx) {
return mLiteOrm.dropTable(claxx);
}
@Override
public boolean dropTable(String tableName) {
return mLiteOrm.dropTable(tableName);
}
@Override
public ArrayList<RelationKey> queryRelation(Class class1, Class class2, List<String> key1List) {
return mLiteOrm.queryRelation(class1, class2, key1List);
}
@Override
public <E, T> boolean mapping(Collection<E> col1, Collection<T> col2) {
return mLiteOrm.mapping(col1, col2);
}
@Override
public SQLiteDatabase getReadableDatabase() {
return mLiteOrm.getReadableDatabase();
}
@Override
public SQLiteDatabase getWritableDatabase() {
return mLiteOrm.getWritableDatabase();
}
@Override
public TableManager getTableManager() {
return mLiteOrm.getTableManager();
}
@Override
public SQLiteHelper getSQLiteHelper() {
return mLiteOrm.getSQLiteHelper();
}
@Override
public DataBaseConfig getDataBaseConfig() {
return mLiteOrm.getDataBaseConfig();
}
@Override
public SQLiteDatabase openOrCreateDatabase(String path, SQLiteDatabase.CursorFactory factory) {
return mLiteOrm.openOrCreateDatabase(path, factory);
}
@Override
public boolean deleteDatabase() {
return mLiteOrm.deleteDatabase();
}
@Override
public boolean deleteDatabase(File file) {
return mLiteOrm.deleteDatabase(file);
}
@Override
public void close() {
mLiteOrm.close();
}
}
这里我没有做任何的修饰，只是使用装饰者模式包装了一次，避免当我们真要替换框架时出现巨大工作量的尴尬。
- 接下来给大家说明一下DB类的使用，代码如下
学校实体类：
@Table("School") // 这是表名
public class SchoolEntity implements Serializable {
// 每个实体类一定要实现 Serializable 接口，并且添加此变量
// 了解序列化的同学都知道，Serializable是一种稳定的序列化方式
// 这种序列化的优点是稳定，缺点是序列化时会生成较多的变量占用内存
// 这个属性是Serializable的版本号，一旦改变，将无法反序列化，
// 所以这个值，确定后就不要修改
private static final long serialVersionUID = -1;
@PrimaryKey(AssignType.AUTO_INCREMENT) // 主键，这是表示自增ID
public long id;
// 学校名称
public String name;
// 学校地址，@Column是设置列名的注解
@Column("address")
public String address;
// LiteOrm数据库可以直接将引用类型的数据，序列化为字节，存入表中
// 前提是这个引用类型一定要实现Serializable接口
public List<ClassEntity> classes;
}
班级实体类：
// @Table是设置表名的注解，如果不设置，表名默认为包名+类名
// 比如此类将以com_monch_database_test_Class为表名
@Table("Class")
public class ClassEntity implements Serializable {
private static final long serialVersionUID = -1;
// 主键，这是表示自定义ID，操作数据库时，此属性一定要赋值
@PrimaryKey(AssignType.BY_MYSELF)
public long id;
// 班级名称
public String name;
// 班级人数
public int count;
}
操作类：
// 初始化数据库
DB.initialize(new DataBaseConfig(context, "数据库名称.db", false, 1,
new SQLiteHelper.OnUpdateListener() {
@Override
public void onUpdate(SQLiteDatabase db, int oldVersion, int newVersion) {
if (newVersion > oldVersion) {
// 数据库更新回调
}
}
}));
// 创建学校
SchoolEntity school = new SchoolEntity();
school.name = "测试小学";
school.address = "北京市测试街道110号";
school.classes = new ArrayList<>(2);
// 创建1班
ClassEntity class1 = new ClassEntity();
class1.id = 1;
class1.name = "一年1班";
class1.count = 30;
school.classes.add(class1); // 将1班添加到学校中
// 创建2班
ClassEntity class2 = new ClassEntity();
class2.id = 2;
class2.name = "一年2班";
class2.count = 20;
school.classes.add(class2); // 将2班添加到学校中
DB db = DB.get();
// 保存学校，此时班级也被直接保存至学校表中
// 说明一下save方法和insert方法：
// insert方法是直接插入
// save方法是以id为准，如果实例中有id并在表中存在此数据则执行更新，否则为插入
long schoolId = db.save(school);
// 按照id查询学校
SchoolEntity querySchool = db.queryById(schoolId, SchoolEntity.class);
// 删除学校
int count = db.delete(SchoolEntity.class);
真正的操作代码：
// 保存
long schoolId = db.save(school);
// 查询
SchoolEntity querySchool = db.queryById(schoolId, SchoolEntity.class);
// 删除
int count = db.delete(SchoolEntity.class);
每句话都是一个功能，是不是很轻量？具体使用，大家可自行查看文档。
至此，数据库框架搭建完成。具体代码请移步GitHub查看
