实现数据库: 设计模式+ 反射+ 泛型
2024-11-30 本文已影响0人
xqiiitan
主要实现思路：创建数据库的表 + 插入单条数据。
插入数据，使用的还是原装的加入数据方式，只是进行了封装。
单例设计模式+ 工厂设计模式，实现DaoSupportFactory类。
- DaoFactory数据库的工厂，它关联IDaoSupport接口，接口的实现在DaoSupport中(CURD去操作数据库)。
- 使用IDaoSupport 插入数据,
// 拿到接口去插入对象数据
IDaoSupport<Person> daoSupport = DaoSupportFactory.getFactory().getDao(Person.class);
daoSupport.insert(new Person("tom", 22));
- 定义数据库接口 IDaoSupport，使用泛型T。
public interface IDaoSupport<T> {
void init(SQLiteDatabase database, Class<T> clazz);
// 插入数据，返回的是影响的行数。泛型T，规范插入的数据.
long insert(T t);
}
- 单例工厂 DaoSupportFactory
public class DaoSupportFactory {
private static DaoSupportFactory mFactory; // 静态数据库工厂，方便外部调用
private SQLiteDatabase mSqliteDatabase; // 持有外部数据库的引用
private DaoSupportFactory() {
// 判断是否有存储卡读写权限，6.0要动态申请权限。
File dbRoot = new File(Environment.getExternalStorageDirectory().getAbsolutePath()
+ File.separator + "nhdz" // 内涵段子
+ File.separator + "database");
if (!dbRoot.exists()) {
dbRoot.mkdirs();
}
File dbFile = new File(dbRoot, "nhdz.db"); // 内涵段子
// 打开或创建数据库，把数据库放到手机的内存卡里面。
mSqliteDatabase = SQLiteDatabase.openOrCreateDatabase(dbFile, null);
}
public static DaoSupportFactory getFactory() {
if (mFactory == null) {
synchronized (DaoSupportFactory.class) {
if (mFactory == null) {
mFactory = new DaoSupportFactory();
}
}
}
return mFactory;
}
// 拿到接口，通过接口插入数据
public <T> IDaoSupport getDao(Class<T> clazz) {
IDaoSupport daoSupport = new DaoSupport(); // TODO 可更换其他方案，具体的实现类。
daoSupport.init(mSqliteDatabase, clazz); // 初始化数据库
return daoSupport;
}
}
- 数据库的具体实现类DaoSupport，可替换成其他第三方数据库方案
/**
* Added by Tom on 2024/06/28.
* "create table if not exists Person(id integer primary key autoincrement, name text, age integer, flag boolean)"
* create table if not exists Person (id integer primary key autoincrement,age integer, name text)
*/
public class DaoSupport<T> implements IDaoSupport<T> {
private static final String TAG = "DaoSupport";
private SQLiteDatabase mSqliteDatabase; // 数据库db
private Class<T> mClazz; // 泛型类
// 优化：参数 key-value，参考的Google的系统view创建 AppCompatViewInflater.java
private static final Object[] mPutMethodArgs = new Object[2];
// 缓存方法(缓存所有的put方法)
private static final Map<String, Method> mPutMethods = new ArrayMap<>();
public void init(SQLiteDatabase database, Class<T> clazz) {
this.mSqliteDatabase = database;
this.mClazz = clazz; // 操作的Bean，eg: Person.java
// 反射拿到TableName，表如果不存在就创建表。
sb.append("create table if not exists ")
.append(DaoUtil.getTableName(clazz)) // 获取class的名称: clazz.getSimpleName()
.append(" (id integer primary key autoincrement, ");
Field[] fields = clazz.getDeclaredFields(); // 反射: 拿到类的所有属性名字和类型
for (Field field : fields) { // 遍历所有属性
field.setAccessible(true);
String name = field.getName(); // 属性名
String type = field.getType().getSimpleName(); // 属性Type: int,String,boolean
// type 需要进行转换，int转成integer，String转成text，
sb.append(name).append(DaoUtil.getColumnType(type)).append(", ");
}
// 最后的", " 替换成")"
sb.replace(sb.length() - 2, sb.length(), ")");
String sql = sb.toString(); // 待执行的sql语句。createTableSql
Log.d(TAG, "create table sql: " + sql);
mSqliteDatabase.execSQL(sql); // 执行创建表
}
@Override
public long insert(T obj) { // 插入单条数据
// 使用的还是原生的方式，只不过我们封装了而以。
// 一般的三方数据库，都是通过反射的形式实现的。
/**
* ContentValues values = new ContentValues();
* values.put("name", person.getName());
* db.insert("Person", null, values);
*/
ContentValues values = contentValuesByObj(obj);
// null 代表插入所有。
return mSqliteDatabase.insert(DaoUtil.getTableName(mClazz), null, values);
}
//region 查询的支持部分
private QuerySupport<T> mQuerySupport = null;
@Override
public QuerySupport<T> querySupport() {
if (mQuerySupport == null) {
mQuerySupport = new QuerySupport<>(mSqliteDatabase, mClazz);
}
return mQuerySupport;
}
// 删除，更新：对最原始的写法，比较明了。
public int delete(String whereClause, String[] whereArgs) {
return mSqliteDatabase.delete(DaoUtil.getTableName(mClazz),
whereClause, whereArgs);
}
public int update(T obj, String whereClause, String... whereArgs) {
ContentValues values = transformContentValue(obj);
return mSqliteDatabase.update(DaoUtil.getTableName(mClazz),
values, whereClause, whereArgs);
}
//endregion
// obj 对象转为ContentValues
private ContentValues transformContentValue(T obj) {
ContentValues values = new ContentValues();
Field[] fields = mClazz.getDeclaredFields();
for (Field field : fields) {
try {
field.setAccessible(true);
Object value = field.get(obj);
String name = field.getName();
if (value == null) continue;
Method valueMethod = ContentValues.class.getMethod("put",
String.class, value.getClass());
} catch (Exception e) {
e.printStackTrace();
}
}
return values;
}
@Override
public void insert(List<T> datas) { // 批量插入
mSqliteDatabase.beginTransaction(); // 1.使用事物优化
for (T data : datas) {
long no = insert(data); // 调用单条插入，实现批量插入。
Log.e(TAG, "insert: no:" + no);
}
mSqliteDatabase.endTransaction();
}
/**
* ContentValues values = new ContentValues();
* values.put("name", person.getName());
* db.insert("Person", null, values);
*/
private ContentValues contentValuesByObj(T obj) {
ContentValues values = new ContentValues();
Field[] fields = mClazz.getDeclaredFields(); // 反射：拿到类的所有属性
for (Field field : fields) { // 遍历所有属性
field.setAccessible(true); // 设置权限
try {
String key = field.getName(); // 属性的名称，对应表的字段
Object value = field.get(obj); // 获取对象obj，里面属性field的值【field对应的】。
// 使用反射, 获取put方法，然后通过反射执行。
// put的第二个参数，是带类型的。
mPutMethodArgs[0] = key;
mPutMethodArgs[1] = value;
// 缓存put方法: putInt, putString, putBoolean
// fieldTypeName = value.getClass().getName();
String fieldTypeName = field.getType().getName();
Method putMethod = mPutMethods.get(fieldTypeName); // 先从缓存获取方法。
if (putMethod == null) {
// values.put(key, 11);
putMethod = ContentValues.class.getDeclaredMethod("put", String.class, value.getClass());
mPutMethods.put(fieldTypeName, putMethod); // 添加进缓存
}
// 通过反射 执行方法
// putMethod.invoke(values, key, value); // 三个参数的invoke方法
putMethod.invoke(values, mPutMethodArgs); // 替代方法
} catch (Exception e) {
e.printStackTrace();
} finally {
mPutMethodArgs[0] = null;
mPutMethodArgs[1] = null;
}
}
return values;
}
}
