Android中如何获取数据并实现离线保存功能？

Hey there! 很高兴能帮你搞定Android应用里的离线数据保存功能，结合你已经会从MySQL拉取数据的基础，下面给你梳理几个实用的方案和具体实现步骤：

简单来说，就是把你从MySQL接口获取到的数据，备份一份到设备本地的存储里。当用户离线时，直接读取本地存储的数据展示就行。Android常用的本地存储方案有这几种，你可以根据数据规模和结构选：

• Room：Jetpack官方推荐的SQLite封装库，适合结构化数据（比如列表、详情类数据），上手简单还支持LiveData/Flow
• SharedPreferences：适合存储小量键值对数据（比如用户偏好设置），不适合存大量列表数据
• SQLite：原生数据库，功能全但需要自己写很多模板代码，不如Room省心
• 文件存储：把数据转成JSON/XML存成文件，适合结构简单或者非结构化的数据

我优先推荐Room，因为它和Jetpack生态结合得好，代码简洁还能避免很多原生SQLite的坑。下面是具体步骤：

1. 添加Room依赖 #

在你的app模块的build.gradle（Module级别）里加入以下依赖：

dependencies {
    // Room核心库
    implementation "androidx.room:room-runtime:2.5.0"
    kapt "androidx.room:room-compiler:2.5.0"
    // 如果用Kotlin Coroutines，加这个
    implementation "androidx.room:room-ktx:2.5.0"
}

记得同步一下Gradle哦。

2. 定义实体类（Entity） #

对应你从MySQL获取的数据结构，比如假设你要保存的是文章数据，就写一个Article类，用@Entity注解标记：

import androidx.room.Entity
import androidx.room.PrimaryKey

// 表名设为articles
@Entity(tableName = "articles")
data class Article(
    @PrimaryKey val id: Int, // 用MySQL里的主键当本地主键
    val title: String,
    val content: String,
    val createTime: Long,
    val author: String
)

3. 创建Dao接口 #

Dao是用来定义数据库操作的接口，Room会自动帮你生成实现类。这里定义插入、查询的方法：

import androidx.room.Dao
import androidx.room.Insert
import androidx.room.Query

@Dao
interface ArticleDao {
    // 插入全部数据，如果有重复主键就替换
    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insertAllArticles(articles: List<Article>)

    // 查询所有文章
    @Query("SELECT * FROM articles")
    suspend fun getAllArticles(): List<Article>

    // 根据ID查询单篇文章
    @Query("SELECT * FROM articles WHERE id = :articleId")
    suspend fun getArticleById(articleId: Int): Article?
}

用suspend修饰是为了配合Coroutines做异步操作，避免阻塞主线程。

4. 创建Room数据库类 #

这是数据库的入口，用单例模式避免重复创建实例：

import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import android.content.Context

@Database(entities = [Article::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun articleDao(): ArticleDao

    // 单例模式
    companion object {
        @Volatile
        private var INSTANCE: AppDatabase? = null

        fun getDatabase(context: Context): AppDatabase {
            return INSTANCE ?: synchronized(this) {
                val instance = Room.databaseBuilder(
                    context.applicationContext,
                    AppDatabase::class.java,
                    "app_database" // 数据库文件名
                ).build()
                INSTANCE = instance
                instance
            }
        }
    }
}

5. 结合MySQL数据获取逻辑 #

当你从MySQL接口拿到数据后，把数据插入到Room里。比如在你的数据仓库（Repository）里处理：

import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

class ArticleRepository(private val context: Context) {
    private val articleDao = AppDatabase.getDatabase(context).articleDao()

    // 从MySQL获取数据并保存到本地
    suspend fun fetchAndSaveArticles(): List<Article> {
        return withContext(Dispatchers.IO) {
            // 这里是你原来从MySQL获取数据的代码，比如用Retrofit请求接口
            val networkArticles = yourApiService.getArticles()
            
            // 把网络数据插入到本地数据库
            articleDao.insertAllArticles(networkArticles)
            
            networkArticles
        }
    }

    // 从本地获取数据
    suspend fun getLocalArticles(): List<Article> {
        return withContext(Dispatchers.IO) {
            articleDao.getAllArticles()
        }
    }
}

6. 离线读取逻辑 #

在你的ViewModel或者Activity里，先判断网络状态，再决定读网络还是本地数据：

import android.content.Context
import android.net.ConnectivityManager
import android.net.NetworkCapabilities
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import kotlinx.coroutines.launch

// 检查网络状态的方法
private fun isNetworkAvailable(context: Context): Boolean {
    val connectivityManager = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    val network = connectivityManager.activeNetwork ?: return false
    val networkCapabilities = connectivityManager.getNetworkCapabilities(network) ?: return false
    return networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
}

// 在ViewModel里处理逻辑
class ArticleViewModel(private val repository: ArticleRepository) : ViewModel() {
    fun loadArticles() = viewModelScope.launch {
        if (isNetworkAvailable(repository.context)) {
            // 有网：先拉取最新数据并存本地，然后展示
            val articles = repository.fetchAndSaveArticles()
            // 更新UI展示articles
        } else {
            // 无网：直接读本地数据
            val localArticles = repository.getLocalArticles()
            // 更新UI展示localArticles
        }
    }
}

如果你的数据结构比较简单，或者不想引入Room，也可以把数据转成JSON字符串存到文件里：

import com.google.gson.Gson
import java.io.File
import java.io.FileWriter
import java.io.IOException

// 把List转成JSON存到内部存储
fun saveArticlesToFile(context: Context, articles: List<Article>) {
    val gson = Gson()
    val json = gson.toJson(articles)
    val file = File(context.filesDir, "articles.json")
    
    try {
        val writer = FileWriter(file)
        writer.write(json)
        writer.close()
    } catch (e: IOException) {
        e.printStackTrace()
    }
}

// 从文件读取JSON转成List
fun loadArticlesFromFile(context: Context): List<Article>? {
    val gson = Gson()
    val file = File(context.filesDir, "articles.json")
    
    if (!file.exists()) return null
    
    try {
        val json = file.readText()
        return gson.fromJson(json, Array<Article>::class.java).toList()
    } catch (e: IOException) {
        e.printStackTrace()
        return null
    }
}

这个方法适合快速实现，但数据量较大时性能不如Room，而且没有数据库的查询、更新优势。

• 数据同步：如果MySQL的数据更新了，你需要考虑怎么同步本地数据——比如给每条数据加版本号，拉取时对比版本号再更新；或者每次有网时都覆盖本地数据（适合数据更新不频繁的场景）
• 权限问题：如果要存在外部存储，Android 10及以上需要用Scoped Storage或者申请MANAGE_EXTERNAL_STORAGE权限，不过优先推荐存在内部存储（不需要权限）
• 异步操作：所有网络请求和本地存储操作都不能在主线程执行，一定要用Coroutines、WorkManager或者RxJava来做异步处理，不然会触发ANR

内容的提问来源于stack exchange，提问作者user9861231