欢迎访问宝典百科，专注于IT类百科知识解答！
在 Android 应用开发中，连接数据库通常有以下几种方式，具体选择取决于你的需求和数据库的类型：
---
1. 本地数据库：SQLite
使用场景
适用于需要在设备上存储小型结构化数据。
实现步骤
1. 创建数据库和表
使用 `SQLiteOpenHelper` 类创建和管理数据库：
```java
public class MyDatabaseHelper extends SQLiteOpenHelper {
private static final String DB_NAME = "my_database"; // 数据库名
private static final int DB_VERSION = 1; // 数据库版本
public MyDatabaseHelper(Context context) {
super(context, DB_NAME, null, DB_VERSION);
}
@Override
public void onCreate(SQLiteDatabase db) {
db.execSQL("CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, age INTEGER)");
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
db.execSQL("DROP TABLE IF EXISTS users");
onCreate(db);
}
}
```
2. 操作数据库
创建一个 `MyDatabaseHelper` 实例，并使用 `getWritableDatabase()` 或 `getReadableDatabase()` 获取数据库操作对象：
```java
MyDatabaseHelper dbHelper = new MyDatabaseHelper(context);
SQLiteDatabase db = dbHelper.getWritableDatabase();
// 插入数据
ContentValues values = new ContentValues();
values.put("name", "Alice");
values.put("age", 25);
db.insert("users", null, values);
// 查询数据
Cursor cursor = db.query("users", null, null, null, null, null, null);
while (cursor.moveToNext()) {
String name = cursor.getString(cursor.getColumnIndex("name"));
int age = cursor.getInt(cursor.getColumnIndex("age"));
Log.d("DB", "Name: " + name + ", Age: " + age);
}
cursor.close();
db.close();
```
---
2. 远程数据库：MySQL 等
使用场景
需要从服务器端访问远程数据库。
实现步骤
1. 通过 API 访问数据库
Android 不能直接连接到 MySQL 等远程数据库。推荐的做法是创建一个中间层 API（如 RESTful API）来处理数据库请求。
2. 后端示例
使用 Node.js 或 PHP 创建后端 API。例如，用 PHP 编写一个接口来查询 MySQL 数据库：
```php
$conn = new mysqli("server_address", "username", "password", "database");
if ($conn->connect_error) {
die("Connection failed: " . $conn->connect_error);
}
$sql = "SELECT * FROM users";
$result = $conn->query($sql);
$data = array();
while ($row = $result->fetch_assoc()) {
$data[] = $row;
}
echo json_encode($data);
$conn->close();
?>
```
3. Android 客户端访问 API
使用 `OkHttp` 或 `Retrofit` 发送 HTTP 请求获取数据：
```java
Retrofit retrofit = new Retrofit.Builder()
.baseUrl("https://your-server.com/")
.addConverterFactory(GsonConverterFactory.create())
.build();
ApiService apiService = retrofit.create(ApiService.class);
Call
call.enqueue(new Callback
@Override
public void onResponse(Call
if (response.isSuccessful()) {
List
for (User user : users) {
Log.d("API", "Name: " + user.getName() + ", Age: " + user.getAge());
}
}
}
@Override
public void onFailure(Call
Log.e("API", "Error: " + t.getMessage());
}
});
```
4. ApiService 接口示例
```java
public interface ApiService {
@GET("getUsers.php")
Call
}
```
5. User 数据模型
```java
public class User {
private String name;
private int age;
public String getName() {
return name;
}
public int getAge() {
return age;
}
}
```
---
3. 使用 Room 持久化库（推荐）
Room 是 Google 提供的数据库抽象层，封装了 SQLite。
步骤
1. 在 `build.gradle` 中添加依赖：
```groovy
implementation "androidx.room:room-runtime:2.5.2"
annotationProcessor "androidx.room:room-compiler:2.5.2"
```
2. 定义实体类和 DAO：
```java
@Entity
public class User {
@PrimaryKey(autoGenerate = true)
public int id;
public String name;
public int age;
}
@Dao
public interface UserDao {
@Insert
void insert(User user);
@Query("SELECT * FROM User")
List
}
```
3. 创建数据库：
```java
@Database(entities = {User.class}, version = 1)
public abstract class AppDatabase extends RoomDatabase {
public abstract UserDao userDao();
}
```
4. 使用数据库：
```java
AppDatabase db = Room.databaseBuilder(context, AppDatabase.class, "my-database").build();
UserDao userDao = db.userDao();
// 插入数据
User user = new User();
user.name = "Alice";
user.age = 25;
userDao.insert(user);
// 查询数据
List
for (User u : users) {
Log.d("Room", "Name: " + u.name + ", Age: " + u.age);
}
```
---
根据项目的复杂度和需求选择适合的方法，Room 持久化库是目前 Google 推荐的首选方案，尤其适合本地存储需求。
