Activity关联4个Fragment时，非Bundle/静态方式传递共享对象的最佳方案？

Hey there! Let's walk through the best solutions for your scenario—since you want to avoid Bundles and static fields/methods, and you’ve already got a solid start with the abstract class idea. Let’s break down each approach with code examples and pros/cons.

This is a clean, type-safe approach that aligns with your initial idea. Here's how to implement it:

First, create an abstract ParentFragment class that defines a contract for receiving the data object:

abstract class ParentFragment : Fragment() {
    // Abstract method that all child fragments must implement to receive data
    abstract fun onDataReceived(yourObject: YourObject)
}

Next, have all 4 of your fragments extend this abstract class and implement the required method:

class FragmentA : ParentFragment() {
    override fun onDataReceived(yourObject: YourObject) {
        // Use the object in this fragment (update UI, process data, etc.)
    }
}

class FragmentB : ParentFragment() {
    override fun onDataReceived(yourObject: YourObject) {
        // Handle the data specific to FragmentB
    }
}

In your main Activity, when you receive the object from the source fragment, iterate through all attached fragments and pass the data to those that inherit from ParentFragment:

class MainActivity : AppCompatActivity() {
    // This method is called when the source fragment sends the data
    fun receiveDataFromFragment(yourObject: YourObject) {
        // Loop through all fragments attached to the Activity
        supportFragmentManager.fragments.forEach { fragment ->
            if (fragment is ParentFragment) {
                fragment.onDataReceived(yourObject)
            }
        }
    }
}

Pros:

• Straightforward and easy to understand
• Type-safe (no casting issues if you stick to the abstract class)
• No external dependencies needed

Cons:

• Requires manually managing fragment instances (you have to ensure fragments are attached before sending data)
• Doesn’t handle configuration changes automatically (if the Activity recreates, you’ll need to re-pass the data)

This is the industry standard for sharing data between components in Android, especially since it works seamlessly with lifecycle changes and avoids memory leaks. Here's how to set it up:

First, create a shared ViewModel that holds a LiveData instance for your object:

import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel

class SharedDataViewModel : ViewModel() {
    // MutableLiveData for internal updates, exposed as immutable LiveData to fragments
    private val _sharedObject = MutableLiveData<YourObject>()
    val sharedObject = _sharedObject

    // Call this to update the data from the Activity
    fun updateSharedObject(data: YourObject) {
        _sharedObject.value = data
    }
}

In your main Activity, get an instance of this ViewModel and update it when you receive data from the source fragment:

import androidx.lifecycle.ViewModelProvider

class MainActivity : AppCompatActivity() {
    private lateinit var sharedViewModel: SharedDataViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Get the ViewModel instance tied to the Activity's lifecycle
        sharedViewModel = ViewModelProvider(this)[SharedDataViewModel::class.java]
    }

    fun receiveDataFromFragment(yourObject: YourObject) {
        // Update the ViewModel's LiveData with the new object
        sharedViewModel.updateSharedObject(yourObject)
    }
}

Finally, in each of your other fragments, observe the LiveData from the same ViewModel instance:

import androidx.lifecycle.ViewModelProvider

class FragmentC : Fragment() {
    private lateinit var sharedViewModel: SharedDataViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Get the same ViewModel instance as the Activity (using requireActivity())
        sharedViewModel = ViewModelProvider(requireActivity())[SharedDataViewModel::class.java]
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        // Observe the LiveData - this will trigger automatically when data updates
        sharedViewModel.sharedObject.observe(viewLifecycleOwner) { yourObject ->
            // Use the received object in this fragment
        }
    }
}

Pros:

• Lifecycle-aware: Automatically handles configuration changes (e.g., screen rotation) without losing data
• No need to manually track fragment instances
• Avoids memory leaks (LiveData only delivers updates to active observers)
• Clean, reactive flow of data

Cons:

• Requires using Android Jetpack components (but this is a plus for modern Android development)

If you prefer a more decoupled approach, you can use an event bus library like EventBus. However, note that this is less recommended than ViewModel because it creates implicit dependencies that are harder to debug.

Here's a quick example:
First, define an event class to hold your data:

data class DataUpdatedEvent(val yourObject: YourObject)

In your Activity, post the event when you receive data:

import org.greenrobot.eventbus.EventBus

class MainActivity : AppCompatActivity() {
    fun receiveDataFromFragment(yourObject: YourObject) {
        EventBus.getDefault().post(DataUpdatedEvent(yourObject))
    }
}

In each fragment, register/unregister for events and handle them:

import org.greenrobot.eventbus.EventBus
import org.greenrobot.eventbus.Subscribe
import org.greenrobot.eventbus.ThreadMode

class FragmentD : Fragment() {
    override fun onStart() {
        super.onStart()
        EventBus.getDefault().register(this)
    }

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

    @Subscribe(threadMode = ThreadMode.MAIN)
    fun onDataUpdated(event: DataUpdatedEvent) {
        val yourObject = event.yourObject
        // Use the object in this fragment
    }
}

Pros:

• Decouples components (fragments don’t need to know about the Activity or each other)
• Easy to implement for simple use cases

Cons:

• Implicit dependencies make debugging harder (you can’t easily track where events come from)
• Risk of memory leaks if you forget to unregister observers
• Not lifecycle-aware by default

Final Recommendation #

If you want to stick with your original abstract class idea, it’s a solid choice for simple scenarios. However, ViewModel + LiveData is the best long-term solution for modern Android apps, as it handles lifecycle changes and data persistence automatically without the downsides of static fields or Bundles.

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