简介：本项目介绍了如何在Android应用中使用SQLite数据库进行基本的数据操作，包括数据的增加、检索、更新和删除。项目详细描述了数据库初始化、表创建、数据插入、查询、更新和删除的过程。同时，还包含了如何在Activity或Fragment中使用 SQLiteOpenHelper 类，以及如何使用RecyclerView展示查询结果和数据库事务的使用。项目的核心在于通过实际操作来加深对Android数据库操作和数据持久化机制的理解。
1. SQLite数据库基本概念与操作
在当今数字化的世界中，数据存储和管理对于任何应用程序都是至关重要的环节。SQLite是一种轻量级的数据库，它是嵌入式系统中广泛使用的数据库解决方案。SQLite不像传统的客户机/服务器数据库，它不需要单独的服务器进程或系统来运行。相反，它被直接集成到应用程序中，非常适合移动和嵌入式系统。
在本章中，我们将深入了解SQLite的基础知识，涵盖从安装和配置，到数据存储、检索、修改和删除的基础操作。我们将探索如何使用SQLite进行基本的数据库任务，并讨论其核心概念，例如表、索引、事务和游标。通过本章的学习，即使是没有数据库背景的开发者，也将能够掌握SQLite的基本操作，为进一步深入学习SQLite打下坚实的基础。
2. SQLiteOpenHelper子类实现与数据库版本控制
2.1 SQLiteOpenHelper子类设计
2.1.1 子类结构和构造方法
在Android开发中， SQLiteOpenHelper 是一个非常重要的帮助类，用于管理数据库的创建和版本管理。创建一个 SQLiteOpenHelper 的子类，通常需要重写两个方法： onCreate(SQLiteDatabase db) 和 onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) 。
首先，我们需要定义一个继承自 SQLiteOpenHelper 的子类，并提供构造方法。构造方法通常需要以下几个参数：
-
Context：应用的上下文环境。 -
String：数据库名称。 -
SQLiteDatabase.CursorFactory：可选参数，用于创建游标对象。通常使用null。 -
int：数据库当前版本号。
以下是一个简单的 SQLiteOpenHelper 子类结构：
import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
public class MyDatabaseHelper extends SQLiteOpenHelper {
private static final String DATABASE_NAME = "mydatabase.db";
private static final int DATABASE_VERSION = 1;
public MyDatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
// 创建表的SQL语句
String createTableSQL = "CREATE TABLE IF NOT EXISTS user (" +
"id INTEGER PRIMARY KEY AUTOINCREMENT, " +
"name TEXT, " +
"age INTEGER)";
// 执行创建表的语句
db.execSQL(createTableSQL);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// 数据库升级逻辑
if (oldVersion < newVersion) {
// 删除旧表，创建新表
db.execSQL("DROP TABLE IF EXISTS user");
onCreate(db);
}
}
}
2.1.2 数据库版本管理机制
SQLiteOpenHelper 管理数据库版本的方式非常直接。每当数据库结构发生改变时（例如添加新表、修改字段等），都需要通过修改 DATABASE_VERSION 常量来提升版本号，并实现 onUpgrade 方法来处理升级逻辑。
在 onUpgrade 方法中， oldVersion 参数表示当前数据库的版本， newVersion 参数表示新版本。通过比较这两个版本号，可以执行相应的数据库变更操作。例如，当数据库从版本1升级到版本2时，可以添加新表或修改现有表结构。
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
switch (oldVersion) {
case 1:
// 版本1升级到版本2的逻辑
if (newVersion >= 2) {
// 创建新表或者修改现有表结构
db.execSQL("CREATE TABLE IF NOT EXISTS user_profile (id INTEGER PRIMARY KEY AUTOINCREMENT, bio TEXT)");
}
break;
// 可以继续添加其他版本升级的case
}
}
2.2 数据库创建与升级策略
2.2.1 创建数据库和表的时机
数据库创建时机通常在 SQLiteOpenHelper 子类的 onCreate 方法中进行。当数据库首次被访问时，Android系统会检查数据库是否存在，如果不存在，则会调用 onCreate 方法。因此， onCreate 方法是初始化数据库结构的理想地方。可以在 onCreate 方法中通过 execSQL 方法执行SQL语句来创建表。
@Override
public void onCreate(SQLiteDatabase db) {
// 创建用户表
db.execSQL("CREATE TABLE IF NOT EXISTS user (" +
"id INTEGER PRIMARY KEY AUTOINCREMENT," +
"name TEXT," +
"age INTEGER)");
// 创建消息表
db.execSQL("CREATE TABLE IF NOT EXISTS message (" +
"id INTEGER PRIMARY KEY AUTOINCREMENT," +
"content TEXT," +
"sender_id INTEGER," +
"receiver_id INTEGER," +
"send_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP)");
}
2.2.2 升级时的数据库结构变更
随着应用的迭代更新，可能会对数据库结构进行变更，例如添加新字段、修改字段类型或删除某些不再需要的表。升级策略应该清晰地处理这些变更，确保应用的连续性和数据的完整性。 onUpgrade 方法提供了一种机制来处理这些变更。
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// 示例：从版本2升级到版本3
if (oldVersion < 3) {
// 删除旧表并创建新表
db.execSQL("DROP TABLE IF EXISTS message");
// 创建新结构的消息表
db.execSQL("CREATE TABLE IF NOT EXISTS message (" +
"id INTEGER PRIMARY KEY AUTOINCREMENT," +
"content TEXT," +
"sender_id INTEGER," +
"receiver_id INTEGER," +
"send_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP)");
}
}
在升级数据库时，要特别注意避免数据丢失。通常的做法是添加新表而不是直接删除旧表，并且在 onUpgrade 方法中适当迁移旧数据到新表，或者提供数据备份和恢复方案。
3. 创建数据库和表
3.1 设计合适的数据库结构
3.1.1 确定表的字段和类型
在设计数据库和表的过程中，首先需要明确的是各个表的字段（Column）以及相应的数据类型（DataType）。一个典型的错误是忽略数据类型选择的重要性，这可能会影响性能和数据的准确性。SQLite有几种基本数据类型，例如： TEXT 、 INTEGER 、 REAL （浮点数）、 BLOB （二进制大对象）等。
例如，如果您正在创建一个用户表，您可能会有如下字段：用户ID、用户名、密码、邮箱地址、注册日期。您可以选择合适的类型来匹配数据的性质，比如，用户ID可能是一个 INTEGER PRIMARY KEY ，因为它是唯一的并且是自增长的；而邮箱地址则使用 TEXT 类型。
代码示例：
CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
username TEXT NOT NULL,
password TEXT NOT NULL,
email TEXT NOT NULL,
registration_date TEXT NOT NULL
);
在上述SQL语句中， IF NOT EXISTS 检查表是否存在，如果不存在，则创建一个新表。表 users 有五个字段，其中 id 是主键且自增， username 、 password 、 email 和 registration_date 均以文本形式存储。
3.1.2 规划表之间的关系
确定了字段和数据类型之后，就需要思考表之间的关系。数据库设计中，常见的关系有三种：一对一（1:1）、一对多（1:M）和多对多（M:N）。
- 一对一关系 适用于每个表中的记录只能对应另一个表中的一条记录。例如，一个人和一个护照信息。
- 一对多关系 是最常见的一种关系，比如一个部门可以有多个员工，但每个员工只属于一个部门。
- 多对多关系 需要通过一个关联表来实现，因为一个表中的记录可以对应另一个表中多条记录，反之亦然。例如，学生选课系统，一个学生可以选多门课程，一门课程也可以被多个学生选修。
在SQLite中，实现一对多关系通常使用外键约束，而在多对多关系中，你需要创建一个额外的关联表，表中通常包含两个字段作为关联表之间的外键。
代码示例：
CREATE TABLE IF NOT EXISTS departments (
department_id INTEGER PRIMARY KEY,
department_name TEXT NOT NULL
);
CREATE TABLE IF NOT EXISTS employees (
employee_id INTEGER PRIMARY KEY,
name TEXT NOT NULL,
department_id INTEGER,
FOREIGN KEY (department_id) REFERENCES departments(department_id)
);
上述例子中， employees 表和 departments 表存在一对多关系，通过 department_id 字段和外键约束来实现。
3.2 编码实现创建表
3.2.1 SQL语句的编写和执行
在有了数据库设计之后，接下来就是将设计转换成SQL语句并执行这些语句来创建表。在Android开发中，通常是通过SQLiteOpenHelper类来管理数据库的版本以及数据库的创建和升级。但也可以直接使用SQL语句来创建表。
示例代码：
public class MyDatabase extends SQLiteOpenHelper {
private static final String DATABASE_NAME = "mydatabase.db";
private static final int DATABASE_VERSION = 1;
public MyDatabase(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL(
"CREATE TABLE IF NOT EXISTS contacts (" +
"id INTEGER PRIMARY KEY AUTOINCREMENT, " +
"name TEXT NOT NULL, " +
"phone_number TEXT NOT NULL)"
);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// 这里可以添加数据库升级的逻辑
}
}
在 onCreate 方法中，我们使用 db.execSQL 执行了一个SQL语句来创建一个新的表 contacts 。
3.2.2 程序中创建表的封装方法
为了提高代码的可维护性和复用性，通常需要将数据库操作封装成方法。在创建表的情况下，可以将创建表的SQL语句抽取出来，放到一个单独的方法中。
示例代码：
public class DatabaseUtil {
public static void createContactsTable(SQLiteDatabase db) {
String createTableSql = "CREATE TABLE IF NOT EXISTS contacts (" +
"id INTEGER PRIMARY KEY AUTOINCREMENT, " +
"name TEXT NOT NULL, " +
"phone_number TEXT NOT NULL)";
db.execSQL(createTableSql);
}
}
在上述代码中， DatabaseUtil 类提供了一个静态方法 createContactsTable ，该方法接收一个 SQLiteDatabase 对象作为参数，并执行创建表的操作。
以上便完成了第三章的介绍，接下来可以进一步深入了解如何利用SQLite进行高效的数据操作——包括数据的增加、删除、修改和查询（CRUD）。在下一章节中，我们将深入探讨这些操作的细节与实践技巧。
4. 数据操作——增删改查(CRUD)
4.1 插入数据的方法与实践
4.1.1 insert语句的使用和参数绑定
插入数据到SQLite数据库中是日常操作中最为常见的需求之一。在SQLite中，我们使用 INSERT INTO 语句来添加新的数据行到指定的表中。 INSERT INTO 语句的基本语法如下：
INSERT INTO table_name (column1, column2, column3, ...)
VALUES (value1, value2, value3, ...);
这里 table_name 指的是要插入数据的表名， column1, column2, column3 等是表中的列名，而 value1, value2, value3 等则是对应列要插入的数据。
为了安全和效率，推荐使用预编译语句（prepared statement），通过参数绑定的方式插入数据。这种做法可以有效防止SQL注入攻击，并且能够提高代码的可维护性。在Android中，我们可以利用 SQLiteStatement 或者 SQLiteDatabase 的 insert() 和 insertWithOnConflict() 方法来执行插入操作。
例如，假设我们有一个用户信息表 users ，包含 id , username , 和 password 三个字段。下面是如何使用 SQLiteDatabase 的 insert() 方法插入数据的示例代码：
ContentValues values = new ContentValues();
values.put("username", "johndoe");
values.put("password", "123456");
// 调用insert方法插入数据，第二个参数是冲突处理策略
long newRowId = database.insert("users", null, values);
在上述代码中， ContentValues 对象用来存储待插入的列名和值。 insert() 方法将数据实际插入到数据库中，并返回新插入行的 _id 值，如果没有插入成功则返回-1。
4.1.2 批量插入数据的优化技巧
当需要插入大量数据时，通过循环逐条插入的方式可能会导致性能问题，因为每次插入都会触发一次磁盘I/O操作，这样效率很低。为了优化这一过程，我们可以使用批量插入数据的方式来减少I/O操作次数。
批量插入数据一般有两种方法，一种是通过循环执行多次 insert 操作但每次插入多条数据，另一种是使用 execSQL() 方法一次性执行一个包含多个 INSERT 语句的字符串。第二种方法更为高效，因为它把多个插入操作合并到一个数据库命令中，减少了数据库I/O次数。
下面是一个使用 execSQL() 方法执行批量插入的示例：
ContentValues[] valuesArray = new ContentValues[100];
for (int i = 0; i < 100; i++) {
ContentValues values = new ContentValues();
values.put("username", "user" + i);
values.put("password", "pass" + i);
valuesArray[i] = values;
}
// 使用execSQL批量插入数据
String sql = "INSERT INTO users (username, password) VALUES ";
for (int i = 0; i < valuesArray.length; i++) {
if (i > 0) sql += ", ";
sql += "(?, ?)";
}
database.execSQL(sql, insertParams);
在这个例子中，我们首先创建了一个 ContentValues 数组来存储100条待插入的数据。然后构建了一个 INSERT 语句字符串，其中使用占位符 ? 代表数据，最终使用 execSQL() 方法一次性插入这些数据。 insertParams 是一个 Object[] 数组，包含了所有待插入的参数值。
注意，如果处理的数据量非常大，频繁地使用 execSQL() 执行批处理可能会对数据库性能产生影响，应该注意不要一次性处理过大的数据量，可能会导致事务过大，影响数据库性能和程序响应时间。
【接下来的内容将展示表、代码块、逻辑分析及参数说明等扩展性说明】
5. 在Activity或Fragment中使用数据库
5.1 Activity中数据库操作的封装
5.1.1 创建数据操作类和实例化
在Android开发中，通常需要在Activity中频繁地进行数据库操作。为了保持代码的清晰和可维护性，我们会创建一个数据操作类来进行封装。该类通常会包含打开和关闭数据库的操作，以及增删改查等方法。这里以一个名为DatabaseHelper的类为例进行介绍。
public class DatabaseHelper extends SQLiteOpenHelper {
private static final String DATABASE_NAME = "example.db";
private static final int DATABASE_VERSION = 1;
public DatabaseHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE IF NOT EXISTS items (_id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, value INTEGER)");
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// 在此处理数据库版本升级逻辑
db.execSQL("DROP TABLE IF EXISTS items");
onCreate(db);
}
// 这里可以添加自定义的方法来执行CRUD操作
public Cursor getItem(int id) {
SQLiteDatabase db = this.getReadableDatabase();
return db.rawQuery("SELECT * FROM items WHERE _id = ?", new String[]{String.valueOf(id)});
}
}
5.1.2 在Activity中调用数据库方法
在Activity中，我们可以创建一个数据操作类的实例，并利用该实例进行数据库操作。
public class MainActivity extends AppCompatActivity {
private DatabaseHelper dbHelper;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
dbHelper = new DatabaseHelper(this);
// 示例：插入数据
ContentValues values = new ContentValues();
values.put("name", "ItemName");
values.put("value", 123);
long newRowId = dbHelper.getWritableDatabase().insert("items", null, values);
// 示例：查询数据
Cursor cursor = dbHelper.getItem((int)newRowId);
if (cursor.moveToFirst()) {
String name = cursor.getString(cursor.getColumnIndex("name"));
int value = cursor.getInt(cursor.getColumnIndex("value"));
// 使用从数据库获取的数据进行操作
}
cursor.close();
}
}
5.2 Fragment中的数据库操作技巧
5.2.1 Fragment与数据库交互的难点
Fragment作为Android中用于实现模块化界面的一部分，它本身并不直接持有Context对象，而通常依赖于宿主Activity进行数据库等Context相关的操作。因此，在Fragment中直接进行数据库操作会存在一定的复杂性。
5.2.2 解决Fragment间数据共享的策略
对于需要在Fragment之间共享数据的情况，可以采用以下策略：
- 使用宿主Activity作为中介，从Activity的数据库操作类中获取或操作数据。
- 通过回调接口的方式，让Activity负责数据库操作并向Fragment提供数据。
- 利用ViewModel进行数据共享，通过LiveData等组件在Fragment之间实时更新数据。
以下是使用ViewModel进行数据共享的示例代码：
public class ItemViewModel extends ViewModel {
private final MutableLiveData<Item> itemLiveData = new MutableLiveData<>();
public void setItem(Item item) {
itemLiveData.setValue(item);
}
public LiveData<Item> getItem() {
return itemLiveData;
}
}
// 在Activity中
public class MyActivity extends AppCompatActivity {
public void onSomeAction() {
// 操作数据库，获取数据
Item item = databaseHelper.getItemFromDb();
itemViewModel.setItem(item);
}
}
// 在Fragment中
public class MyFragment extends Fragment {
@Override
public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
itemViewModel.getItem().observe(getViewLifecycleOwner(), item -> {
// 使用从数据库获取的数据更新UI
});
}
}
这样，我们不仅解决了Fragment与数据库交互的难点，还可以享受到数据自动更新UI的便利。
6. 高级数据库操作技巧
随着应用复杂性的增加，SQLite数据库的使用也需要更高层次的技巧。本章节将探讨如何利用RecyclerView高效展示数据库数据，实现高效的数据库事务处理，以及分享一些实用的最佳实践。
6.1 RecyclerView数据展示技巧
在Android应用开发中，RecyclerView是一个强大的组件，用于高效地展示大量数据集。结合SQLite数据库，我们可以实现动态加载和显示数据。
6.1.1 数据绑定与RecyclerView适配器
在使用RecyclerView时，我们通常需要一个适配器类，它负责将数据库中的数据与视图组件绑定。以下是一个简单的适配器类的结构示例：
public class MyAdapter extends RecyclerView.Adapter<MyAdapter.ViewHolder> {
private List<MyData> data;
// 构造函数，接收从数据库中查询到的数据列表
public MyAdapter(List<MyData> data) {
this.data = data;
}
// 创建ViewHolder
@Override
public ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
View view = LayoutInflater.from(parent.getContext()).inflate(R.layout.item_view, parent, false);
return new ViewHolder(view);
}
// 将数据绑定到ViewHolder
@Override
public void onBindViewHolder(ViewHolder holder, int position) {
MyData item = data.get(position);
holder.name.setText(item.getName());
holder.detail.setText(item.getDetail());
}
// 返回数据集大小
@Override
public int getItemCount() {
return data.size();
}
public static class ViewHolder extends RecyclerView.ViewHolder {
public TextView name, detail;
public ViewHolder(View itemView) {
super(itemView);
name = itemView.findViewById(R.id.name);
detail = itemView.findViewById(R.id.detail);
}
}
}
6.1.2 提高RecyclerView数据加载效率的方法
为了提高RecyclerView的加载效率，我们通常会采用懒加载或分页加载的策略。这能够减少应用在初始化时对数据库的操作，从而避免在主线程中进行耗时的数据库查询。以下是一个简单的懒加载实现方法：
public void fetchData() {
new Thread(new Runnable() {
@Override
public void run() {
final List<MyData> data = queryDatabase(); // 从数据库查询数据的方法
activity.runOnUiThread(new Runnable() {
@Override
public void run() {
adapter = new MyAdapter(data);
recyclerView.setAdapter(adapter);
}
});
}
}).start();
}
6.2 数据库事务处理技巧
数据库事务是保证数据一致性和完整性的关键技术。SQLite数据库同样支持事务处理。
6.2.1 事务的原理和应用场景
事务可以保证一系列的操作要么全部成功，要么全部失败。在SQLite中，使用BEGIN, COMMIT, 和 ROLLBACK命令来管理事务。
BEGIN TRANSACTION;
-- 执行一系列的数据库操作
COMMIT; -- 如果一切正常
-- 或者
ROLLBACK; -- 如果操作失败，撤销所有的变更
在Android应用中，这通常在后台线程中执行，以避免阻塞UI线程。
6.2.2 编写事务处理的代码实践
在Android中，我们可以创建一个辅助方法来处理事务：
public void performTransaction(final SQLiteDatabase db, final Runnable operation) {
db.beginTransaction();
try {
operation.run();
db.setTransactionSuccessful();
} catch (Exception e) {
// 日志记录操作失败的细节
} finally {
db.endTransaction();
}
}
6.3 数据库操作的最佳实践
随着应用规模的扩大，数据库操作也会变得越来越复杂。一些最佳实践可以帮助开发者优化性能和避免错误。
6.3.1 常见错误和调试方法
对于开发者而言，理解和使用SQLite的错误代码至关重要。调试时，可以使用如下的日志输出来帮助定位问题：
if (cursor != null && !cursor.isClosed()) {
cursor.close();
}
if (db != null) {
db.close();
}
6.3.2 性能优化与异常处理
性能优化涉及到查询优化、索引创建等，而异常处理则确保应用即使遇到数据库错误也能够正常运行。当遇到异常情况时，应使用try-catch结构捕获并处理异常，确保应用的稳定性。
通过以上这些高级数据库操作技巧，可以确保Android应用中数据库的高效和稳定运行，同时也能提供更好的用户体验。
简介：本项目介绍了如何在Android应用中使用SQLite数据库进行基本的数据操作，包括数据的增加、检索、更新和删除。项目详细描述了数据库初始化、表创建、数据插入、查询、更新和删除的过程。同时，还包含了如何在Activity或Fragment中使用 SQLiteOpenHelper 类，以及如何使用RecyclerView展示查询结果和数据库事务的使用。项目的核心在于通过实际操作来加深对Android数据库操作和数据持久化机制的理解。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
