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();
“`
相关问题拓展阅读：
android SQLite数据怎么显示到UI界面中
1 sqlite增删改的例子图片
2 上面使用的例子来自android学习手册,例子、源码、文档全部搞定，采用androidstudo的目录结构，360手机助手中下载。。
3 使用SQLite。
现在的主流移动设备像Android、iPhone等都使用SQLite作为复杂数据的存储引擎，在我们为移动设备开发应用程序时，也许就要使用到SQLite来存储我们大量的数据，所以我们就需要掌握移动设备上做旅的SQLite开发技巧。对于Android平台来说，系统内置了丰富的API来供开发人员操作SQLite，我们可以轻松的完成对数据的存取。
下面就向大家介绍一下SQLite常用的操作方法，为了方便，我将代码写在了Activity的onCreate中：
view plain copy print?
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//打开或创建test.db数据库
SQLiteDatabase db = openOrCreateDatabase(“test.db”, Context.MODE_PRIVATE, null);
db.execSQL(“DROP TABLE IF EXISTS person”);
//创建person表
db.execSQL(“CREATE TABLE person (_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, age ALLINT)”);
Person person = new Person();
person.name = “john”;
person.age = 30;
//插入数据
db.execSQL(“INSERT INTO person VALUES (NULL, ?, ?)”, new Object{person.name, person.age});
person.name = “david”;
person.age = 33;
//ContentValues以键值对的形式存放数据
ContentValues cv = new ContentValues();
cv.put(“name”, person.name);
cv.put(“age”, person.age);
//插入ContentValues中的数据
db.insert(“person”, null, cv);
cv = new ContentValues();
cv.put(“age”, 35);
纯携凳//更新数据
db.update(“person”, cv, “name = ?”, new String{“john”});
Cursor c = db.rawQuery(“SELECT * FROM person WHERE age >= ?”, new String{“33”});
while (c.moveToNext()) {
int _id = c.getInt(c.getColumnIndex(“_id”));
隐余String name = c.getString(c.getColumnIndex(“name”));
int age = c.getInt(c.getColumnIndex(“age”));
Log.i(“db”, “_id=>” + _id + “, name=>” + name + “, age=>” + age);
}
c.close();
//删除数据
db.delete(“person”, “age = ?”, new String{“33”});
while (c.moveToNext()) {
int _id = c.getInt(c.getColumnIndex(“_id”));
String name = c.getString(c.getColumnIndex(“name”));
int age = c.getInt(c.getColumnIndex(“age”));
Log.i(“db”, “_id=>” + _id + “, name=>” + name + “, age=>” + age);
}
c.close();
//删除数据
db.delete(“person”, “age ? and age
下面来说说查询操作。查询操作相对于上面的几种操作要复杂些，因为我们经常要面对着各种各样的查询条件，所以系统也考虑到这种复杂性，为我们提供了较为丰富的查询形式：
view plain copy print?
db.rawQuery(String sql, String selectionArgs);
db.query(String table, String columns, String selection, String selectionArgs, String groupBy, String having, String orderBy);
db.query(String table, String columns, String selection, String selectionArgs, String groupBy, String having, String orderBy, String limit);
db.query(String distinct, String table, String columns, String selection, String selectionArgs, String groupBy, String having, String orderBy, String limit);
db.rawQuery(String sql, String selectionArgs);
db.query(String table, String columns, String selection, String selectionArgs, String groupBy, String having, String orderBy);
db.query(String table, String columns, String selection, String selectionArgs, String groupBy, String having, String orderBy, String limit);
db.query(String distinct, String table, String columns, String selection, String selectionArgs, String groupBy, String having, String orderBy, String limit);
上面几种都是常用的查询方法，之一种最为简单，将所有的SQL语句都组织到一个字符串中，使用占位符代替实际参数，selectionArgs就是占位符实际参数集；下面的几种参数都很类似，columns表示要查询的列所有名称集，selection表示WHERE之后的条件语句，可以使用占位符，groupBy指定分组的列名，having指定分组条件，配合groupBy使用，orderBy指定排序的列名，limit指定分页参数，distinct可以指定“true”或“false”表示要不要过滤重复值。需要注意的是，selection、groupBy、having、orderBy、limit这几个参数中不包括“WHERE”、“GROUP BY”、“HAVING”、“ORDER BY”、“LIMIT”等SQL关键字。
最后，他们同时返回一个Cursor对象，代表数据集的游标，有点类似于JavaSE中的ResultSet。
下面是Cursor对象的常用方法：
view plain copy print?
c.move(int offset); //以当前位置为参考,移动到指定行
c.moveToFirst(); //移动到之一行
c.moveToLast(); //移动到最后一行
c.moveToPosition(int position); //移动到指定行
c.moveToPrevious(); //移动到前一行
c.moveToNext(); //移动到下一行
c.isFirst();//是否指向之一条
c.isLast(); //是否指向最后一条
c.isBeforeFirst(); //是否指向之一条之前
c.isAfterLast(); //是否指向最后一条之后
c.isNull(int columnIndex); //指定列是否为空(列基数为0)
c.isClosed();//游标是否已关闭
c.getCount();//总数据项数
c.getPosition(); //返回当前游标所指向的行数
c.getColumnIndex(String columnName);//返回某列名对应的列索引值
c.getString(int columnIndex); //返回当前行指定列的值
c.move(int offset);//以当前位置为参考,移动到指定行
c.moveToFirst();//移动到之一行
c.moveToLast();//移动到最后一行
c.moveToPosition(int position);//移动到指定行
c.moveToPrevious();//移动到前一行
c.moveToNext();//移动到下一行
c.isFirst();//是否指向之一条
c.isLast();//是否指向最后一条
c.isBeforeFirst();//是否指向之一条之前
c.isAfterLast();//是否指向最后一条之后
c.isNull(int columnIndex);//指定列是否为空(列基数为0)
c.isClosed();//游标是否已关闭
c.getCount();//总数据项数
c.getPosition();//返回当前游标所指向的行数
c.getColumnIndex(String columnName);//返回某列名对应的列索引值
c.getString(int columnIndex);//返回当前行指定列的值
在上面的代码示例中，已经用到了这几个常用方法中的一些，关于更多的信息，大家可以参考官方文档中的说明。
最后当我们完成了对数据库的操作后，记得调用SQLiteDatabase的close()方法释放数据库连接，否则容易出现SQLiteException。
上面就是SQLite的基本应用，但在实际开发中，为了能够更好的管理和维护数据库，我们会封装一个继承自SQLiteOpenHelper类的数据库操作类，然后以这个类为基础，再封装我们的业务逻辑方法。
下面，我们就以一个实例来讲解具体的用法，我们新建一个名为db的项目，结构如下：
其中DBHelper继承了SQLiteOpenHelper，作为维护和管理数据库的基类，DBManager是建立在DBHelper之上，封装了常用的业务方法，Person是我们的person表对应的JavaBean，MainActivity就是我们显示的界面。
下面我们先来看一下DBHelper：
view plain copy print?
package com.scott.db;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
public class DBHelper extends SQLiteOpenHelper {
private static final String DATABASE_NAME = “test.db”;
private static final int DATABASE_VERSION = 1;
public DBHelper(Context context) {
//CursorFactory设置为null,使用默认值
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
//数据库之一次被创建时onCreate会被调用
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(“CREATE TABLE IF NOT EXISTS person” +
“(_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, age INTEGER, info TEXT)”);
}
//如果DATABASE_VERSION值被改为2,系统发现现有数据库版本不同,即会调用onUpgrade
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL(“ALTER TABLE person ADD COLUMN other STRING”);
}
}
package com.scott.db;
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
public class DBHelper extends SQLiteOpenHelper {
private static final String DATABASE_NAME = “test.db”;
private static final int DATABASE_VERSION = 1;
public DBHelper(Context context) {
//CursorFactory设置为null,使用默认值
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
//数据库之一次被创建时onCreate会被调用
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(“CREATE TABLE IF NOT EXISTS person” +
“(_id INTEGER PRIMARY KEY AUTOINCREMENT, name VARCHAR, age INTEGER, info TEXT)”);
}
//如果DATABASE_VERSION值被改为2,系统发现现有数据库版本不同,即会调用onUpgrade
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL(“ALTER TABLE person ADD COLUMN other STRING”);
}
}
正如上面所述，数据库之一次创建时onCreate方法会被调用，我们可以执行创建表的语句，当系统发现版本变化之后，会调用onUpgrade方法，我们可以执行修改表结构等语句。
关于andorid数据库基类的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
