Android数据库基类：实现数据的快速存储与调用 (andorid数据库基类)
随着移动互联网的普及，Android作为最为流行的移动操作系统之一，其数据库操作也越来越受到开发者的关注。而在Android应用程序开发中，数据的存储一直是一个普遍且重要的问题。为了解决这个问题，开发者需要使用一种可靠且高效的数据库操作方法，以及封装底层实现的数据库基类，以实现数据的快速存储与调用。
1、数据库操作方法
在Android应用程序开发中，SQLite是一种全功能、轻量级的关系型数据库引擎。它广泛应用于移动设备，因为它是非常小巧而又高效的，并且能够实现快速的CRUD（增、删、改、查）操作。Android SDK提供了一套SQLite API，使得开发者可以通过Java代码来与SQLite数据库进行交互。
在进行数据库操作时，开发者应该遵循以下几个步骤：
1）打开或创建数据库
2）创建表
3）插入数据
4）查询数据
5）更新数据
6）删除数据
7）关闭数据库
在实际开发过程中，我们通常会为每个数据表创建一个Java Bean类，用于封装表中的数据，方便访问和操作。
2、数据库基类的封装
封装数据库基类的目的是为了提高代码的复用性和可维护性。我们可以将所有公共的数据库操作封装到一个基类中，并提供一些常用的API，以便子类继承和调用。这样可以避免在每个数据表对应的Java Bean类中都写一遍数据库操作代码，代码重用率将大大提高。
以下是一个简单的数据库基类的实现：
“`
public abstract class BaseDao {
private SQLiteDatabase mDatabase;
private Class mClazz;
public BaseDao(Context context, Class clazz) {
// 创建或打开数据库
mDatabase = SQLiteDatabase.openOrCreateDatabase(context.getDatabasePath(“my_db”), null);
mClazz = clazz;
// 创建数据表
createTable();
}
private void createTable() {
// 通过反射获取Java Bean类中定义的表名和属性
String tableName = mClazz.getSimpleName();
Field[] fields = mClazz.getDeclaredFields();
StringBuilder = new StringBuilder();
.append(“CREATE TABLE IF NOT EXISTS “);
.append(tableName);
.append(“(“);
for (Field field : fields) {
field.setAccessible(true);
String fieldName = field.getName();
String fieldType = getFieldType(field.getType());
.append(fieldName);
.append(” “);
.append(fieldType);
.append(“,”);
}
.deleteCharAt(.length() – 1);
.append(“)”);
mDatabase.execSQL(.toString());
}
private String getFieldType(Class type) {
if (type == String.class) {
return “TEXT”;
} else if (type == int.class || type == Integer.class) {
return “INTEGER”;
} else if (type == float.class || type == Float.class) {
return “REAL”;
} else if (type == double.class || type == Double.class) {
return “REAL”;
} else {
return “BLOB”;
}
}
public void insert(T entity) {
ContentValues values = new ContentValues();
// 通过反射获取实体类中的属性并保存到ContentValues中
Field[] fields = mClazz.getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
String fieldName = field.getName();
String fieldValue = “”;
try {
Object obj = field.get(entity);
if (obj != null) {
fieldValue = obj.toString();
}
} catch (IllegalAccessException e) {
e.printStackTrace();
}
values.put(fieldName, fieldValue);
}
// 将ContentValues中的数据插入到数据库表中
mDatabase.insert(mClazz.getSimpleName(), null, values);
}
// …
}
“`
可以看到，BaseDao类中定义了一个私有的SQLiteDatabase对象mDatabase，它在构造函数中被初始化。在构造函数中，我们还通过反射获取了子类传递进来的Java Bean类的Class对象，并保存到了mClazz变量中。然后在createTable()方法中，我们通过反射获取了Java Bean类中定义的表名和属性，并拼接成了一个完整的SQL语句，然后通过mDatabase.execSQL()方法执行这个SQL语句，从而创建了数据表。
在insert()方法中，我们将子类传递进来的Java Bean对象转换成了ContentValues对象，并插入到了数据库表中。其他CRUD操作也可以采用类似的方式实现。
3、数据库操作的API设计
通常情况下，一个完整的数据库操作包括表的创建、数据的插入、数据的查询、数据的更新和数据的删除等。因此，我们可以在数据库基类中添加一些常用的API，以方便子类进行数据库操作。以下是一个示例：
“`
public abstract class BaseDao {
// …
public abstract void insert(T entity);
public abstract List query(String selection, String[] selectionArgs);
public abstract void update(T entity, String selection, String[] selectionArgs);
public abstract void delete(String selection, String[] selectionArgs);
protected List cursorToList(Cursor cursor) {
List list = new ArrayList();
if (cursor != null && cursor.moveToFirst()) {
do {
T entity = null;
try {
entity = mClazz.newInstance();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
if (entity != null) {
// 通过反射将数据填充到Java Bean对象中
Field[] fields = mClazz.getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
String fieldName = field.getName();
int columnIndex = cursor.getColumnIndex(fieldName);
if (columnIndex != -1) {
Object value = cursor.getString(columnIndex);
setFieldValue(entity, field, value);
}
}
list.add(entity);
}
} while (cursor.moveToNext());
cursor.close();
}
return list;
}
private void setFieldValue(T entity, Field field, Object value) {
try {
if (value == null) {
return;
}
Class fieldType = field.getType();
if (fieldType == int.class || fieldType == Integer.class) {
field.setInt(entity, Integer.parseInt(value.toString()));
} else if (fieldType == long.class || fieldType == Long.class) {
field.setLong(entity, Long.parseLong(value.toString()));
} else if (fieldType == float.class || fieldType == Float.class) {
field.setFloat(entity, Float.parseFloat(value.toString()));
} else if (fieldType == double.class || fieldType == Double.class) {
field.setDouble(entity, Double.parseDouble(value.toString()));
} else if (fieldType == boolean.class || fieldType == Boolean.class) {
field.setBoolean(entity, Boolean.parseBoolean(value.toString()));
} else {
field.set(entity, value.toString());
}
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
public void close() {
mDatabase.close();
}
}
“`
在这个示例中，我们定义了insert()、query()、update()、delete()等常用的API，它们的实现可以调用父类中的方法。此外，我们还定义了一个cursorToList()方法，用于将查询结果转换成Java Bean对象的列表。
4、数据库操作的使用示例
如何在实际开发中使用上述的数据库基类呢？我们可以先创建一个Java Bean类，定义数据表的结构：
“`
public class User {
private int id;
private String name;
private int age;
private String address;
// getter/setter
}
“`
然后创建一个子类继承自BaseDao，实现具体的数据库操作：
“`
public class UserDao extends BaseDao {
public UserDao(Context context) {
super(context, User.class);
}
@Override
public void insert(User entity) {
super.insert(entity);
}
@Override
public List query(String selection, String[] selectionArgs) {
Cursor cursor = mDatabase.query(mClazz.getSimpleName(), null, selection, selectionArgs, null, null, null);
return cursorToList(cursor);
}
@Override
public void update(User entity, String selection, String[] selectionArgs) {
super.update(entity, selection, selectionArgs);
}
@Override
public void delete(String selection, String[] selectionArgs) {
super.delete(selection, selectionArgs);
}
public List queryAll() {
return query(null, null);
}
public User queryById(int id) {
String selection = “id=?”;
String[] selectionArgs = new String[] {String.valueOf(id)};
List list = query(selection, selectionArgs);
return (list != null && list.size() > 0) ? list.get(0) : null;
}
// …
}
“`
在这个子类中，我们重写了父类中的API，并调用了父类中相应的方法。此外，我们还实现了一些特定的查询方法，如queryAll()和queryById()等。
在实际开发中，我们可以使用如下代码来进行数据库操作：
“`
UserDao userDao = new UserDao(context);
User user = new User();
user.setName(“张三”);
user.setAge(20);
user.setAddress(“北京市”);
userDao.insert(user);
List userList = userDao.queryAll();
for (User u : userList) {
Log.d(TAG, u.getName() + “, ” + u.getAge() + “, ” + u.getAddress());
}
user.setName(“李四”);
userDao.update(user, “id=?”, new String[] {String.valueOf(user.getId())});
userDao.delete(“id=?”, new String[] {String.valueOf(user.getId())});
User user2 = userDao.queryById(1);
if (user2 != null) {
Log.d(TAG, user2.getName() + “, ” + user2.getAge() + “, ” + user2.getAddress());
}
userDao.close();
“`
