SQLite数据库基本操作与分库（一）

SQliteDataBase相信大家都不陌生，目前有很多第三方框架，比如：GreenDao、DbFlow和Room等等，相信也都了解或者用过，但是我们今天不讲这些框架，目前我们项目中也用到数据库，但是根据目前框架有些需求并不能很好的符合我们的项目，所以就有了这系列文章，可能会有2篇关于数据库的文章，分别是：数据库基本操作与分库和数据库的升级,这些文章不会讲数据库的基本使用，我们将的是封装。

数据库设计三大范式：

• 1、原子性：表示我们在设计数据库时字段不能在拆分；
• 2、唯一性：该数据在我们的数据库中不存在重复性；
• 3、避免冗余性：一般是主键和外键的操作，就是两个表中不能存在重复的数据；

数据库作用

• 1、在Android开发中，数据库在中小型APP使用并不广泛，但其对于数据管理的方便性是其他数据存储工具无法取代的;
• 2、特点：数据集中管理，控制冗余，提高数据的利用率和一致性，有利于程序的开发和维护;

如何设计数据库框架？

• 1、如何自动创建数据库？
• 2、如何自动创建数据表？
• 3、如何让用户使用方便？
• 4、如何确保性能最优？
• 5、 将类名和属性名转换为创建数据表的sql语句？

类图

base.png
base_sub.png

开始设计我们的数据库框架

public class BaseDao<T> implements IBaseDao<T> {
//持有数据库操作的引用
private SQLiteDatabase mSqLiteDatabase;
//数据表名
private String mTableName;
//操作数据所对应的类型,
private Class<T> mEntityClass;


//标识是否已经初始化
private boolean mIsInit = false;

//定义一个缓存Map key是数据库字段名 value是Class成员变量
//为什么需要做这个缓存，第一是为了性能优化，
// 第二是后面再查询，通过反射把Cursor设置给entity比较方便,
// 第三是数据库字段和entity进行映射
private HashMap<String, Field> mCacheMap_DbRecord_EntityField;


//数据库初始阿虎，需自动创建表
public boolean init(SQLiteDatabase sqLiteDatabase, Class<T> entityClass) {
    this.mSqLiteDatabase = sqLiteDatabase;
    this.mEntityClass = entityClass;
    if (!mIsInit) {
        //根据传入的class 进行数据表的创建
        DbTable dbTable = entityClass.getAnnotation(DbTable.class);
        if (dbTable != null && !TextUtils.isEmpty(dbTable.value())) {
            mTableName = dbTable.value().toLowerCase();
        } else {
            mTableName = entityClass.getSimpleName().toLowerCase();
        }

        //处理关键字 order
        if (mTableName.equalsIgnoreCase("order")) {
            mTableName = mTableName + "_info";
        }
        //数据库没有打开
        if (!sqLiteDatabase.isOpen()) {
            return mIsInit = false;
        }
        //得到创建数据表的sql 串
        String createTableSql = getCreateTableSql();
        Log.e("tag", createTableSql);
        sqLiteDatabase.execSQL(createTableSql);
        mCacheMap_DbRecord_EntityField = new HashMap<>();
        initCacheMap();
        return mIsInit = true;
    }
    return mIsInit = false;
}

}

BaseDao是我们把数据库的基本操作全部抽取出来，而一般Dao是对应数据库中的的一张表，首先我们先看看init方法，init方法是根据传入的EntityClass 进行数据表的创建，这个比较简单，在看看initCacheMap方法：

 private void initCacheMap() {
    //取得所有的列名
    String sql = "select * from " + mTableName + " limit 1,0";
    Cursor cursor = mSqLiteDatabase.rawQuery(sql, null);
    cursor.close();
    String[] columnNames = cursor.getColumnNames();

    //取得所有的成员变量
    Field[] fields = mEntityClass.getDeclaredFields();
    for (Field field : fields) field.setAccessible(true);

    for (String columnName : columnNames) {
        Field fieldColumn = null;
        for (Field field : fields) {
            String fieldName;
            DbFiled dbFiled = field.getAnnotation(DbFiled.class);
            if (dbFiled != null && !TextUtils.isEmpty(dbFiled.value())) {
                fieldName = dbFiled.value();
            } else {
                fieldName = field.getName();
            }

            if (columnName.equals(fieldName)) {
                fieldColumn = field;
                break;
            }
        }
        if (fieldColumn != null) {
            mCacheMap_DbRecord_EntityField.put(columnName, fieldColumn);
        }
    }
}

定义一个缓存Map key是数据库字段名 value是EntiytClass成员变量为什么需要做这个缓存，第一是为了性能优化，第二是后面操作时通过反射把Cursor设置给entityClass比较方便,第三是数据库字段和entity进行映射。

上面BaseDao定义好之后，我们需要在定义一个管理数据库的单例类来管理数据库的所有表的Dao：

/**
 * @Describe: 管理者该数据库的所有表, 而且公共数据只有一个
 */
public class BaseDaoFactory {
//防止同一个数据库同一张表存在多个BaseDao,key是entityClass，value是dao
//因为公共数据库只存在一个，那么我们之缓存dao，即：dao的缓存池
private WeakHashMap<Class<?>, BaseDao> mDaoWeakHashMap;
private SQLiteDatabase mSqLiteDatabase;
private static String sDbName;
protected static String sDbRootPath;

//你可以认为一个设备上只能存在一个数据库
protected BaseDaoFactory() {
    if (TextUtils.isEmpty(sDbName)) throw new RuntimeException("must call init method");
    this.mSqLiteDatabase = SQLiteDatabase.openOrCreateDatabase(sDbName, null);
    this.mDaoWeakHashMap = new WeakHashMap<>();
}

private static class BaseDaoFactoryHolder {
    private static final BaseDaoFactory INSTANCE = new BaseDaoFactory();
}

public static BaseDaoFactory getInstance() {
    return BaseDaoFactoryHolder.INSTANCE;
}

/**
 * 使用前必须初始化
 *
 * @param dbName data/data/xx.xx/my.db
 */
public static void init(Context context, String dbName) {
    File file = new File("data/data/" + context.getPackageName());
    if (!file.exists()) {
        file.mkdirs();
    }
    BaseDaoFactory.sDbRootPath = file.getAbsolutePath();
    BaseDaoFactory.sDbName = sDbRootPath + "/" + dbName;
}

/**
 * @param daoClass    获取到指定Dao
 * @param entityClass 对应数据表的实体类，也就是表
 * @param <DAO>       获取到指定Dao
 * @param <ENTITY>    对应数据表的实体类
 * @return 具体的实体类
 * <p>
 * create table if not exists order(desc TEXT,id INTEGER)
 * create table if not exists tb_user(id INTEGER,name TEXT,password TEXT)
 */
@Nullable
public <DAO extends BaseDao<ENTITY>, ENTITY> DAO getBaseDao(@NonNull Class<DAO> daoClass, Class<ENTITY> entityClass) {
    // 每一张表对应一个dao
    BaseDao baseDao = mDaoWeakHashMap.get(entityClass);
    try {
        if (baseDao == null) {
            synchronized (BaseDaoFactory.class) {
                baseDao = mDaoWeakHashMap.get(entityClass);
                if (baseDao == null) {
                    baseDao = daoClass.newInstance();
                    // 每一张表对应一个dao,为了解决自动创建表，必须一个表对应一个dao
                    boolean isSuccess = baseDao.init(mSqLiteDatabase, entityClass);
                    if (isSuccess) {
                        mDaoWeakHashMap.put(entityClass, baseDao);
                    }
                }
            }
        }
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    }
    return (DAO) baseDao;
}

}

在BaseDaoFactory 中管理者该数据库的所有表, 并且对每一个Dao做了缓存，避免每次操作还要重新创建Dao造成不必要的性能开销，BaseDaoFactory 管理者该数据库的所有表, 而且公共数据只有一个，为什么这么说呢？因为目前我们的项目用到数据库分库，我们需要把公共数据库和用户的私有数据库分开来管理，而BaseDaoFactory就是管理者我们的公共数据库，那接下来看看如何分库？

public class BaseDaoSubFactory extends BaseDaoFactory {
private static final BaseDaoSubFactory instance = new BaseDaoSubFactory();

//数据库连接池,key:dbpth  value : WeakHashMap<Class<?>,BaseDao>
// WeakHashMap<Class<?>,BaseDao> :防止同一个数据库同一张表存在多个BaseDao,key是entityClass，value是dao
private WeakHashMap<String, WeakHashMap<Class<?>, BaseDao>> mDbWeakHashMap;

private BaseDaoSubFactory() {
    super();
    mDbWeakHashMap = new WeakHashMap<>();
}

public static BaseDaoSubFactory getInstance() {
    return instance;
}

/**
 * 定义一个用于分库的数据库对象
 */
private SQLiteDatabase subSqLiteDatabase;


@Override
@Nullable
public <DAO extends BaseDao<ENTITY>, ENTITY> DAO getBaseDao(@NonNull Class<DAO> daoClass, Class<ENTITY> entityClass) {
    String databaseValue = PrivateDbPathHelper.getValue(sDbRootPath);
    BaseDao baseDao = getDao(entityClass, databaseValue);
    try {
        //baseDao为null，有两种情况，1、首次创建数据库；2、首次使用dao
        if (baseDao == null) {
            synchronized (BaseDaoSubFactory.class) {
                baseDao = getDao(entityClass, databaseValue);
                if (baseDao == null) {
                    subSqLiteDatabase = SQLiteDatabase.openOrCreateDatabase(databaseValue, null);
                    // 每一张表对应一个dao,为了解决自动创建表，必须一个表对应一个dao
                    baseDao = daoClass.newInstance();
                    boolean isSuccess = baseDao.init(subSqLiteDatabase, entityClass);
                    if (isSuccess) {
                        //从数据库缓存池中获取对应的dao
                        WeakHashMap<Class<?>, BaseDao> daoWeakHashMap = mDbWeakHashMap.get(databaseValue);
                        if (daoWeakHashMap != null) {
                            daoWeakHashMap.put(entityClass, baseDao);
                        }
                    }
                }
            }
        }
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InstantiationException e) {
        e.printStackTrace();
    }
    return (DAO) baseDao;
}


/**
 * 私有数据库可能存在多个，所以我们需要缓存起来，并且要把统一数据中dao也缓存起来
 *
 * @param entityClass
 * @param databaseValue
 * @param <ENTITY>
 * @return
 */
@Nullable
private <ENTITY> BaseDao getDao(Class<ENTITY> entityClass, String databaseValue) {
    //从数据库databaseValue中拿到对应的dao的缓存池
    WeakHashMap<Class<?>, BaseDao> daoWeakHashMap = mDbWeakHashMap.get(databaseValue);
    if (daoWeakHashMap == null) {
        //管理以前的数据库，注意关闭的是私有数据库
        if (subSqLiteDatabase != null && subSqLiteDatabase.isOpen()) {
            subSqLiteDatabase.close();
        }
        //清空以前的dao缓存池
        mDbWeakHashMap.clear();
        // 如果dao的缓存池不存在，那么创建一个dao的缓存池，并加入该数据库缓存池中
        daoWeakHashMap = new WeakHashMap<>();
        mDbWeakHashMap.put(databaseValue, daoWeakHashMap);
    }
    //从获取dao缓存池中获取到指定的dao
    return daoWeakHashMap.get(entityClass);
}
}

可以看到BaseDaoSubFactory 继承BaseDaoFactory ，并且在BaseDaoSubFactory 中因为我们切换数据，我们需要把每一个数据库dao缓存，并且是根据数据库进行区分的。

多表查询：select * from person,dept where person.did = dept.did;