如何利用ViewModel实现Fragment间通信？Spinner选中值跨Fragment传递

DevOps 小满

2026-5-27

嘿，这个场景我在做电商类APP的时候刚好遇到过，给你整理了几个实用的解决方案，都是Android开发里常用的，你可以根据自己的项目情况选：

方案一：通过宿主Activity做中间层传递（最直接）

因为所有Fragment都依附在同一个Activity下，用Activity当“中转站”是最容易上手的方式：

第一步：在你的ViewPager宿主Activity里定义一个回调接口，比如OnSpinnerValueChangeListener，把两个Spinner的变化事件都封装进去：
```
interface OnSpinnerValueChangeListener {
    fun onSpinner1Selected(selectedValue: String)
    fun onSpinner2Selected(selectedValue: String)
}
```
然后让Activity实现这个接口，同时在初始化ViewPager的时候，把其他Fragment（FragmentA/B/C）的引用保存下来。
第二步：在HomeFragment里，当Spinner选中项变化时，通过接口把值传给Activity。记得在onAttach里拿到Activity的实例，onDetach时清空引用避免内存泄漏。
第三步：Activity收到Spinner的值后，直接调用其他Fragment的公开方法（比如updateUIWithSpinnerVals(val1, val2)），就能触发UI更新了。

给你贴个简化的代码示例：
宿主Activity部分

class MainActivity : AppCompatActivity(), OnSpinnerValueChangeListener {
    private lateinit var fragmentA: FragmentA
    private lateinit var fragmentB: FragmentB

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // 初始化ViewPager的Adapter时，顺便获取FragmentA和FragmentB的实例
        val adapter = ViewPagerAdapter(supportFragmentManager)
        fragmentA = adapter.fragmentA
        fragmentB = adapter.fragmentB
        viewPager.adapter = adapter
    }

    // 实现接口的回调方法，把值转发给其他Fragment
    override fun onSpinner1Selected(selectedValue: String) {
        fragmentA.updateSpinner1Value(selectedValue)
        fragmentB.updateSpinner1Value(selectedValue)
    }

    override fun onSpinner2Selected(selectedValue: String) {
        fragmentA.updateSpinner2Value(selectedValue)
        fragmentB.updateSpinner2Value(selectedValue)
    }
}

HomeFragment的Spinner处理

class HomeFragment : Fragment() {
    private var listener: OnSpinnerValueChangeListener? = null

    override fun onAttach(context: Context) {
        super.onAttach(context)
        // 强转成接口类型，确保Activity实现了这个接口
        if (context is OnSpinnerValueChangeListener) {
            listener = context
        } else {
            throw RuntimeException("$context 必须实现 OnSpinnerValueChangeListener 接口")
        }
    }

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        val view = inflater.inflate(R.layout.fragment_home, container, false)
        val spinner1 = view.findViewById<Spinner>(R.id.spinner1)
        
        spinner1.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
            override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
                val value = parent?.getItemAtPosition(position).toString()
                // 触发回调，把值传给Activity
                listener?.onSpinner1Selected(value)
            }

            override fun onNothingSelected(parent: AdapterView<*>?) {}
        }
        // Spinner2的处理逻辑和上面完全一致，就不重复写了
        return view
    }

    override fun onDetach() {
        super.onDetach()
        listener = null // 清空引用，避免内存泄漏
    }
}

FragmentA的更新方法

class FragmentA : Fragment() {
    // 公开一个方法，供Activity调用更新UI
    fun updateSpinner1Value(value: String) {
        // 这里根据选中值更新UI，比如修改文本、加载对应数据
        tv_spinner1.text = "Spinner1 当前选中：$value"
    }

    fun updateSpinner2Value(value: String) {
        // 同理处理Spinner2的值变化
        tv_spinner2.text = "Spinner2 当前选中：$value"
    }
}

方案二：用ViewModel共享数据（强烈推荐）

如果你的项目已经用了Jetpack组件，ViewModel绝对是最优解——它能在同一个Activity的所有Fragment之间安全共享数据，还能自动处理配置变化（比如屏幕旋转）导致的数据丢失问题：

第一步：创建一个共享的ViewModel，用MutableLiveData来保存Spinner的选中值（LiveData会自动通知观察者数据变化）：

class SharedSpinnerViewModel : ViewModel() {
    // 定义两个LiveData，分别对应两个Spinner的值
    val spinner1SelectedValue = MutableLiveData<String>()
    val spinner2SelectedValue = MutableLiveData<String>()

    // 提供方法来更新值
    fun setSpinner1Value(value: String) {
        spinner1SelectedValue.value = value
    }

    fun setSpinner2Value(value: String) {
        spinner2SelectedValue.value = value
    }
}

第二步：在HomeFragment里获取这个ViewModel，当Spinner选中时调用ViewModel的方法更新值：

class HomeFragment : Fragment() {
    private lateinit var sharedViewModel: SharedSpinnerViewModel

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        // 注意这里用requireActivity()作为ViewModel的所有者，这样所有Fragment拿到的都是同一个实例
        sharedViewModel = ViewModelProvider(requireActivity())[SharedSpinnerViewModel::class.java]
        val view = inflater.inflate(R.layout.fragment_home, container, false)
        val spinner1 = view.findViewById<Spinner>(R.id.spinner1)
        
        spinner1.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
            override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
                val value = parent?.getItemAtPosition(position).toString()
                sharedViewModel.setSpinner1Value(value)
            }

            override fun onNothingSelected(parent: AdapterView<*>?) {}
        }
        // Spinner2的处理同理
        return view
    }
}

第三步：在其他Fragment（比如FragmentA）里获取同一个ViewModel，观察LiveData的变化，自动更新UI：

class FragmentA : Fragment() {
    private lateinit var sharedViewModel: SharedSpinnerViewModel

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        sharedViewModel = ViewModelProvider(requireActivity())[SharedSpinnerViewModel::class.java]
        val view = inflater.inflate(R.layout.fragment_a, container, false)
        val tvSpinner1 = view.findViewById<TextView>(R.id.tv_spinner1)
        
        // 观察Spinner1的值变化，一旦有更新就自动触发UI修改
        sharedViewModel.spinner1SelectedValue.observe(viewLifecycleOwner) { value ->
            tvSpinner1.text = "Spinner1 当前选中：$value"
            // 这里还可以做更多操作，比如根据值请求接口加载数据
        }

        // 观察Spinner2的值变化
        sharedViewModel.spinner2SelectedValue.observe(viewLifecycleOwner) { value ->
            // 处理Spinner2的变化逻辑
        }
        return view
    }
}

这个方案的好处是完全解耦了Fragment之间、Fragment和Activity之间的依赖，代码更清晰，也更符合Android Jetpack的设计理念，强烈推荐你用这个！

方案三：用EventBus传递事件（适合老项目）

如果是维护没有用Jetpack的老项目，EventBus也是一个可选方案，但现在已经不太推荐了——它会让代码的事件流变得难以追踪，还容易出现内存泄漏：

第一步：添加EventBus的依赖（比如GreenRobot的EventBus）。

第二步：定义一个事件类，用来封装Spinner的类型和选中值：

data class SpinnerSelectedEvent(val spinnerType: Int, val selectedValue: String)

第三步：在HomeFragment里，当Spinner选中时发送事件：

spinner1.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
    override fun onItemSelected(parent: AdapterView<*>?, view: View?, position: Int, id: Long) {
        val value = parent?.getItemAtPosition(position).toString()
        // 发送事件，spinnerType=1代表第一个Spinner
        EventBus.getDefault().post(SpinnerSelectedEvent(1, value))
    }

    override fun onNothingSelected(parent: AdapterView<*>?) {}
}

第四步：其他Fragment在onStart里注册EventBus，onStop里取消注册，然后定义订阅方法接收事件：

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

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

    // 订阅事件，指定在主线程处理（因为要更新UI）
    @Subscribe(threadMode = ThreadMode.MAIN)
    fun onSpinnerSelected(event: SpinnerSelectedEvent) {
        when(event.spinnerType) {
            1 -> {
                // 处理Spinner1的值变化
                tvSpinner1.text = "Spinner1 当前选中：${event.selectedValue}"
            }
            2 -> {
                // 处理Spinner2的值变化
            }
        }
    }
}

除非老项目实在没办法，否则优先选前面两个方案哦。

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