Android企业级架构-仿微信-数据库搭建

在上一篇文章中，我们完成了原始的网络框架搭建，现在我们来搭建一下数据库和UI的基础建设。

数据库

数据库方面网上也有非常多的ORM框架，像OrmLite、GreenDAO等都是非常不错的数据映射框架。但使用起来或多或少都存在着一些不便。下面笔者为大家推荐一款非常轻量级的数据库框架LiteOrm，为什么说它非常轻量呢，因为你只需创建一个实体类，然后使用它的API去操作即可，完全不用考虑其它事情。这款国人自己开发的数据库Orm，针对中小型产品完全够用。
具体用法大家可自行查看。它最大的不足是没有Maven依赖，要想使用它，需要把源码DOWN下来，添加到项目中去。

1. 进入LiteOrm页面，将源码下载下来。
2. 解压文件，进入android-lite-orm-master->library->src->com目录下，将整个litesuits文件夹复制到我们项目的database->src->main->java->com目录下。这里大家可以直接到我的GitHub里找到，然后替换到你们的工程里，因为这个源码有些方法无法编译，笔者的代码是修改完的。
3. 因为这个框架是比较完善的，使用起来也很简洁，最重要的是在一个工程中，经常替换数据库框架的可能性实在太低，所以，我们简单的对这个框架的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();
    }
}

这里我没有做任何的修饰，只是使用装饰者模式包装了一次，避免当我们真要替换框架时出现巨大工作量的尴尬。

4. 接下来给大家说明一下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查看