[Android]常见的数据传递方式

Demo:https://github.com/Gamin-fzym/DataTransferDemo

1.Intent

发送页面 A 到页面 B 的 Intent 时，可以通过 Intent 的 putExtra() 方法将数据附加到 Intent 上。

在页面 B 中，通过 Intent 的 getXXXExtra() 方法获取传递的数据。

1).在A页面发送 Intent

import android.app.Activity
import android.content.Intent
import android.os.Bundle
import android.util.Log
import androidx.activity.result.contract.ActivityResultContracts
import androidx.appcompat.app.AppCompatActivity
import com.example.datatransferdemo.databinding.ActivityMainBinding
import com.example.datatransferdemo.pageb.PageB1class MainActivity : AppCompatActivity() {private lateinit var binding: ActivityMainBinding// 获取返回结果，在Activity或Fragment中定义private val someActivityResultLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->if (result.resultCode == Activity.RESULT_OK) {// 执行成功后的操作val intent: Intent? = result.datawhen (intent?.tag) {"PageB1" -> {var resultValue = intent?.getStringExtra("result_key")}"PageB2" -> {val bundle = intent?.extras}}}override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)binding = ActivityMainBinding.inflate(layoutInflater)setContentView(binding.root)// 1.Intentbinding.button1.setOnClickListener {val intent = Intent(this, PageB1::class.java)intent.putExtra("key", "传递字符串") // 可选：添加要传递的数据// 启动目标 Activity//startActivity(intent)// 如果希望在目标 Activity 中获取返回结果，使用ActivityResultLauncher来启动someActivityResultLauncher.launch(intent);}}}

2).在B页面接收数据

import android.content.Intent
import android.os.Bundle
import android.util.Log
import android.widget.Button
import androidx.appcompat.app.AppCompatActivity
import com.example.datatransferdemo.Rclass PageB1 : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_page_b1)// 获取传递过来的值val value = intent.getStringExtra("key")// 离开回传数据val but = findViewById<Button>(R.id.button)but.setOnClickListener {val returnIntent = Intent()returnIntent.tag = "PageB1"returnIntent.putExtra("result_key", "返回字符串")setResult(RESULT_OK, returnIntent)finish() // 结束当前Activity, 不一定要立即结束。}}
}

3).拓展Intent用来区分回传数据

使用扩展函数为 Intent 添加一个自定义的 tag属性

import android.content.Intentvar Intent.tag: String?get() = getStringExtra("tag")set(value) {putExtra("tag", value)}

2.Bundle

类似于 Intent，可以使用 Bundle 在页面间传递数据。

在发送页面 A 到页面 B 的过程中，将数据放入 Bundle 对象中。

在接收页面 B 中，从 Intent 中获取 Bundle 对象，并从 Bundle 中提取数据。

1).在A页面发送 Bundle

val bundle = Bundle()
bundle.putInt("id",123)
bundle.putBoolean("status",true)
bundle.putString("content", "传递字符串")
val intent = Intent(this, PageB2::class.java)
intent.putExtras(bundle)
// 启动目标 Activity
//startActivity(intent)
// 获取返回结果启动
someActivityResultLauncher.launch(intent);

2).在B页面接收数据

import android.content.Intent
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import android.util.Log
import com.example.datatransferdemo.R
import com.example.datatransferdemo.tagclass PageB2 : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_page_b2)// 获取传递过来的值val bundle = intent.extrasval receivedID = bundle?.getInt("id") // 根据传递的数据类型使用对应的 getXXX() 方法val receivedStatus = bundle?.getBoolean("status")val receivedContent = bundle?.getString("content")// 离开回传数据val returnBundle = Bundle()returnBundle.putInt("id",123)returnBundle.putBoolean("status",true)returnBundle.putString("content", "传递字符串")val returnIntent = Intent()returnIntent.tag = "PageB2"returnIntent.putExtras(returnBundle)setResult(RESULT_OK, returnIntent)}
}

3.静态变量

在一个类中定义一个静态变量，其他页面可以直接访问该静态变量来传递数据。

适用于全局范围内需要传递数据的情况，但不适用于临时或有生命周期的数据传递。

1).定义静态变量

object StaticDataHolder {var sharedData = mapOf<String,String>()
}

2).在A页面设置数据

 StaticDataHolder.sharedData = mapOf<String,String>("id" to "1234", "status" to "1", "content" to "传递字符串")

3).在B页面获取数据

val receivedData = StaticDataHolder.sharedData

4.SharedPreferences

使用 SharedPreferences 可以存储和读取键值对数据，并在不同页面间共享数据。

适用于需要长期存储和共享数据的情况。

1).在A页面设置数据

val sharedPref = getSharedPreferences("my_prefs", Context.MODE_PRIVATE)
val editor = sharedPref.edit()
editor.putString("key", data) // data 是要传递的数据
editor.apply()

2).在B页面获取数据

val sharedPref = getSharedPreferences("my_prefs", Context.MODE_PRIVATE)
val receivedData = sharedPref.getString("key", "") // 根据传递的数据类型使用对应的 getXXX() 方法

5.接口回调（Interface Callback）

定义一个接口，在页面 A 中实现该接口，并将实现类的实例传递给页面 B。

页面 B 可以调用接口的方法来传递数据给页面 A。

适用于页面间有交互和回调需求的情况。

1).定义接口

interface DataCallback {fun onDataReceived(data: String)
}

2).在页面 A 中实现接口

class PageA : AppCompatActivity(), DataCallback {// 静态的DataCallback实例companion object {var callbackInstance: DataCallback? = null}override fun onDestroy() {super.onDestroy()callbackInstance = null // 防止内存泄漏}        override fun onDataReceived(data: String) {// 处理接收到的数据}// 在需要传递数据的地方将实现类的实例传递给页面 BcallbackInstance = this;val intent = Intent(this, PageB5::class.java)startActivity(intent)
}

3).在页面 B 中使用接口传递数据

  // 调用DataCallback的方法if (MainActivity.callbackInstance != null) {MainActivity.callbackInstance?.onDataReceived("传递的数据")}

6.EventBus

使用 EventBus 库来进行页面间的事件传递和数据通信。

页面 A 发布一个事件，页面 B 订阅该事件并接收数据。

适用于解耦和简化页面间通信的情况。

1).添加 EventBus 到你的项目依赖中

dependencies {implementation 'org.greenrobot:eventbus:3.3.1'
}

2).创建一个事件类

这个类的作用是在组件之间传递数据

class MessageEvent(val message: String)

3).注册和注销EventBus

在您想要接收事件的组件（如Activity或Fragment）中，注册和注销EventBus。

override fun onStart() {super.onStart()EventBus.getDefault().register(this)
}override fun onStop() {super.onStop()EventBus.getDefault().unregister(this)
}

4).监听事件

在相同的组件中，添加一个方法来监听事件，这个方法需要用@Subscribe注解。

@Subscribe(threadMode = ThreadMode.MAIN)
public fun onMessageEvent(event: MessageEvent) {// 处理事件val data = event.message// ...处理数据
}

5).发布事件

在需要发送数据的地方，发布一个事件实例。

EventBus.getDefault().post(MessageEvent("Hello, EventBus!"))

6).示例

接收方

class ReceiverActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_receiver)}override fun onStart() {super.onStart()EventBus.getDefault().register(this)}override fun onStop() {super.onStop()EventBus.getDefault().unregister(this)}@Subscribe(threadMode = ThreadMode.MAIN)public fun onMessageEvent(event: MessageEvent) {// 这里处理接收到的事件Toast.makeText(this, event.message, Toast.LENGTH_SHORT).show()}
}

发送方

class SenderActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_sender)// 假设有一个按钮用于发送事件val sendButton: Button = findViewById(R.id.sendButton)sendButton.setOnClickListener {// 当按钮被点击时，发布事件EventBus.getDefault().post(MessageEvent("Hello from SenderActivity!"))}}
}

7.Application 类

1).创建自定义Application类

创建一个新的Kotlin类，继承自Application类，并在该类中定义你想要传递的数据。

class MyApp : Application() {var globalData: String? = null// 你可以在这里定义更多的变量或方法
}

2).在AndroidManifest.xml中声明

在AndroidManifest.xml文件中的<application>标签内，使用android:name属性来指定你的自定义Application类。

<applicationandroid:name=".MyApp"...>...
</application>

3).在Activity或其他组件中使用

在任何Activity或其他组件中，你可以通过调用getApplication()方法来获取自定义Application类的实例，并访问其中定义的数据。

class MainActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_main)val app = application as MyAppapp.globalData = "Some data"}
}

注意事项

使用Application传递数据时，要注意生命周期，因为当Android系统需要为其他应用释放内存时，它可能会杀死后台进程，这会导致Application对象被重建，数据可能会丢失。
这种方法适合传递少量的、全局需要的数据。如果数据量较大或者需要持久化存储，应该考虑使用数据库、SharedPreferences或其他存储机制。
为了避免内存泄漏，不要在Application类中持有Activity、View或其他上下文相关的引用。

通过这种方式，你可以在不同的组件间共享数据，但要确保对共享数据的访问是线程安全的。

8.Parcelable

Parcelable和Serializable是两种常用的数据传递方式。Parcelable是Android特有的接口，性能比Serializable好，但实现稍微复杂一些。Serializable是Java提供的接口，实现简单，但性能较差。

实现 Parcelable 接口，使对象能够在页面间进行序列化和反序列化传递。

适用于需要传递自定义对象的情况。

1).创建一个数据类，并实现Parcelable接口。

import android.os.Parcelable
import kotlinx.parcelize.Parcelize@Parcelize
data class User(val name: String, val age: Int) : Parcelable

从Kotlin 1.1.4开始，可以使用@Parcelize注解来自动实现Parcelable接口，前提是在项目的build.gradle文件中启用了kotlin-parcelize插件。

plugins {// 其它插件...id("org.jetbrains.kotlin.plugin.parcelize") 
}

2).在启动新Activity时，将Parcelable对象放入Intent。

val intent = Intent(this, SecondActivity::class.java).apply {val user = User("John Doe", 30)putExtra("USER_KEY", user)
}
startActivity(intent)

3).在接收Activity中，从Intent中取出Parcelable对象。

class SecondActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_second)val user = intent.getParcelableExtra<User>("USER_KEY")user?.let {// 使用user对象}}
}

注意： 当使用Serializable时，所有序列化的对象中的子对象也必须实现Serializable接口。而Parcelable则需要每个子对象都要实现Parcelable接口。

建议在Android中优先使用Parcelable，因为它比Serializable更高效。

9.Serializable

创建一个实现 Serializable 接口的数据类。

在发送页面中创建数据对象，并将其放入 Intent 中。

在接收页面中从 Intent 中获取传递的 Serializable 对象。

1).创建一个数据类，并实现Serializable接口。

import java.io.Serializabledata class User(val name: String, val age: Int) : Serializable

2).在启动新Activity时，将Serializable对象放入Intent。

val intent = Intent(this, SecondActivity::class.java).apply {val user = User("John Doe", 30)putExtra("USER_KEY", user)
}
startActivity(intent)

3).在接收Activity中，从Intent中取出Serializable对象。

class SecondActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_second)val user = intent.getSerializableExtra("USER_KEY") as? Useruser?.let {// 使用user对象}}
}

10.数据库（Database）

使用数据库存储数据，并在不同页面间读取和写入数据。

可以使用 SQLite、Room 等数据库框架进行数据的持久化和共享。

适用于需要长期存储和大量数据共享的情况。

1).添加依赖

在项目的build.gradle文件中，添加Room数据库的依赖。

plugins {id("kotlin-kapt")
}android {...defaultConfig {...kapt {arguments {arg("room.schemaLocation", "$projectDir/schemas")}}}compileOptions {sourceCompatibility = JavaVersion.VERSION_17targetCompatibility = JavaVersion.VERSION_17}kotlinOptions {jvmTarget = "17"}...
}dependencies {implementation("androidx.room:room-runtime:2.5.0")//annotationProcessor("androidx.room:room-compiler:2.5.0")// For Kotlin use kapt instead of annotationProcessorkapt("androidx.room:room-compiler:2.5.0")// optional - Kotlin Extensions and Coroutines support for Roomimplementation("androidx.room:room-ktx:2.5.0")
}

2).定义数据模型

创建一个数据类，并使用@Entity注解标记，表示这是一个数据库表。

import androidx.room.Entity
import androidx.room.PrimaryKey@Entity
data class User(@PrimaryKey val id: Int,val name: String,val age: Int
)

3).创建DAO（数据访问对象）

定义一个接口，使用@Dao注解标记，里面包含访问数据库的方法。

import androidx.room.Dao
import androidx.room.Insert
import androidx.room.Query@Dao
interface UserDao {@Insertsuspend fun insertUser(user: User): Long@Query("SELECT * FROM user WHERE id = :id")suspend fun getUserById(id: Int): User?
}

4).创建数据库实例

创建一个抽象类，继承自RoomDatabase，并使用@Database注解。

import androidx.room.Database
import androidx.room.RoomDatabase@Database(entities = [User::class], version = 1)
abstract class AppDatabase : RoomDatabase() {abstract fun userDao(): UserDao
}

5).使用数据库

在您的Activity或Fragment中，获取数据库实例并执行数据库操作。

val db = Room.databaseBuilder(applicationContext,AppDatabase::class.java, "database-name"
).build()val userDao = db.userDao()// 插入用户
GlobalScope.launch {userDao.insertUser(User(1, "John Doe", 30))// 测试时每次修改一下ID，不然存在相同ID会报错
}// 查询用户
GlobalScope.launch {val user = userDao.getUserById(1)// 使用user对象
}

注意：

上述代码中使用了Kotlin协程来处理异步数据库操作。
Room.databaseBuilder()需要一个Context对象，通常您会在Activity或Application中调用它。
数据库操作（如插入和查询）不应在主线程上执行，因为它们可能会阻塞UI，所以应该在协程或其他异步机制中运行。
GlobalScope的使用在真实的应用程序中并不推荐，因为它的生命周期是整个应用程序，您应该使用具有更短生命周期的作用域，如lifecycleScope或viewModelScope。

11.文件（File）

将数据存储到文件中，在不同页面间通过读写文件来传递数据。

可以使用内部存储或外部存储来创建和访问文件。

适用于大量数据或需要持久化存储的情况。

1).定义一个帮助类或者函数来处理文件的读写操作

以下是一个简单的例子：

import android.content.Context
import java.io.*class FileHelper(private val context: Context) {fun writeToFile(fileName: String, data: String) {context.openFileOutput(fileName, Context.MODE_PRIVATE).use { outputStream ->outputStream.write(data.toByteArray())}}fun readFromFile(fileName: String): String {return context.openFileInput(fileName).bufferedReader().useLines { lines ->lines.fold("") { some, text ->"$some\n$text"}}}
}

2).在您的Activity或Fragment中，您可以使用这个帮助类来存储数据到文件。

class SomeActivity : AppCompatActivity() {private lateinit var fileHelper: FileHelperoverride fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_some)fileHelper = FileHelper(this)// 保存数据到文件val dataToSave = "Some data to be shared"fileHelper.writeToFile("shared_data.txt", dataToSave)}private fun loadData() {// 从文件中读取数据val data = fileHelper.readFromFile("shared_data.txt")// 使用读取的数据// ...}
}

3).在另一个页面，您可以使用相同的FileHelper实例来读取之前写入的文件。

class AnotherActivity : AppCompatActivity() {private lateinit var fileHelper: FileHelperoverride fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_another)fileHelper = FileHelper(this)// 读取数据val sharedData = fileHelper.readFromFile("shared_data.txt")// 使用数据// ...}
}

确保在使用文件进行数据传递时考虑到线程安全和性能问题。对于大量数据或频繁的读写操作，可能需要考虑使用其他数据传递方法，例如数据库或SharedPreferences。此外，对于敏感数据，请确保适当加密，以保护用户数据安全。

12. 网络请求（Network Request）

使用网络请求来传递数据，可以通过 HTTP 请求或其他网络协议进行数据交换。

发送方将数据通过网络发送给接收方，接收方通过解析网络响应来获取数据。

适用于远程数据交换或与服务器进行通信的情况。

1).添加网络权限到你的AndroidManifest.xml文件

<uses-permission android:name="android.permission.INTERNET" />

2).选择一个网络请求库

如Retrofit, OkHttp或Volley，这里以Retrofit为例。

3).添加所选网络库的依赖到你的build.gradle文件中

dependencies {// Retrofit & Gsonimplementation 'com.squareup.retrofit2:retrofit:2.9.0'implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
}

4).创建一个模型类来表示你的数据

data class User(val name: String, val email: String)

5).定义一个接口来描述HTTP请求

import retrofit2.Call
import retrofit2.http.GETinterface ApiService {@GET("users/info")fun getUserInfo(): Call<User>
}

6).使用Retrofit构建器实例化你的服务

import retrofit2.Retrofit
import retrofit2.converter.gson.GsonConverterFactoryobject RetrofitClient {private const val BASE_URL = "https://your.api.url/"val apiService: ApiService by lazy {Retrofit.Builder().baseUrl(BASE_URL).addConverterFactory(GsonConverterFactory.create()).build().create(ApiService::class.java)}
}

7).发送网络请求并处理响应

import retrofit2.Call
import retrofit2.Callback
import retrofit2.Responseclass MainActivity : AppCompatActivity() {override fun onCreate(savedInstanceState: Bundle?) {super.onCreate(savedInstanceState)setContentView(R.layout.activity_main)RetrofitClient.apiService.getUserInfo().enqueue(object : Callback<User> {override fun onResponse(call: Call<User>, response: Response<User>) {if (response.isSuccessful) {val userInfo = response.body()// 使用userInfo数据}}override fun onFailure(call: Call<User>, t: Throwable) {// 处理请求失败的情况}})}
}

13.ContentProvider

使用 ContentProvider 进行跨应用的数据共享和传递。

ContentProvider 提供了标准的接口和方法来操作数据，并可以通过 URI 进行数据的访问。

适用于需要在不同应用间共享数据的情况。

1).定义一个ContentProvider类

首先，创建一个类继承自ContentProvider并实现它的抽象方法。

class MyContentProvider : ContentProvider() {// 初始化ContentProvideroverride fun onCreate(): Boolean {// 初始化数据库等操作return true}// 查询数据override fun query(uri: Uri,projection: Array<String>?,selection: String?,selectionArgs: Array<String>?,sortOrder: String?): Cursor? {// 处理查询请求return null}// 插入数据override fun insert(uri: Uri, values: ContentValues?): Uri? {// 处理插入请求return null}// 更新数据override fun update(uri: Uri,values: ContentValues?,selection: String?,selectionArgs: Array<String>?): Int {// 处理更新请求return 0}// 删除数据override fun delete(uri: Uri,selection: String?,selectionArgs: Array<String>?): Int {// 处理删除请求return 0}// 返回MIME类型override fun getType(uri: Uri): String? {// 根据URI返回正确的MIME类型return null}
}

2).在AndroidManifest.xml中注册ContentProvider

<providerandroid:name=".MyContentProvider"android:authorities="com.example.myapp.provider"android:exported="true" />

android:authorities应该是唯一的，通常使用应用的包名作为前缀。

3).使用ContentResolver访问ContentProvider

其他应用可以使用ContentResolver来查询你的ContentProvider。

获取ContentResolver实例：

在你的应用中，你可以通过调用getContentResolver()方法来获取ContentResolver的实例。这通常在Activity或Service中进行。

val contentResolver = context.contentResolver

构建URI：

访问ContentProvider的数据时，你需要指定一个URI。这个URI指向你想要访问的数据集合或单个数据项。URI通常遵循这样的格式：content://<authority>/<path>，其中<authority>是在AndroidManifest.xml中注册ContentProvider时指定的，并且是唯一的。<path>是你希望访问的数据表或数据类型。

val uri: Uri = Uri.parse("content://com.example.myapp.provider/table_name")

查询数据：

使用ContentResolver的query()方法来请求数据。你可以指定列名、选择条件、选择参数和排序顺序。

val cursor: Cursor? = contentResolver.query(uri,projection, // String数组，代表你想要返回的列。selection, // SQL中的where子句，但不包括"WHERE"本身。selectionArgs, // 与selection中的占位符相匹配的值。sortOrder // 结果的排序方式。
)

处理返回的Cursor：

如果查询成功，query()方法将返回一个Cursor对象。通过这个Cursor，你可以遍历和读取数据。

cursor?.let {while (it.moveToNext()) {// 使用Cursor获取数据val columnValue = it.getString(it.getColumnIndex("column_name"))// 处理数据...}
}
cursor?.close() // 最后记得关闭Cursor

插入、更新和删除数据：

除了查询数据，ContentResolver还提供了insert(), update(), 和 delete()方法来进行数据的增、改、查操作。

// 插入数据
val newUri: Uri? = contentResolver.insert(uri, contentValues)// 更新数据
val rowsUpdated: Int = contentResolver.update(uri, contentValues, selection, selectionArgs)// 删除数据
val rowsDeleted: Int = contentResolver.delete(uri, selection, selectionArgs)

处理权限：

如果ContentProvider包含私有数据或者需要限制访问，你需要在AndroidManifest.xml中声明相应的权限，并在访问时请求这些权限。

安全性考虑：

当你的ContentProvider向其他应用公开数据时，需要考虑到数据安全性。确保对输入的URI进行验证，避免SQL注入等安全漏洞，并根据需要对访问进行身份验证和授权。

通过这种方式，ContentResolver和ContentProvider一起提供了一种强大的机制，允许应用之间安全、高效地共享数据。