Android中Fragment间传递对象的最佳实践方案咨询

我的应用采用单Activity架构，通过NavController实现多个Fragment间的导航。在MainActivity中创建了一个仅需实例化一次的Orchestrator对象，该对象持有MainActivity的Context，需要在全应用及各Fragment中共享使用。

目前我通过定义IShared接口来传递该对象：

interface IShared {
    Orchestrator getOrchestrator();
}

MainActivity实现该接口提供Orchestrator实例：

public class MainActivity extends AppCompatActivity implements IShared {

    private Orchestrator orchestrator;
    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // ...其他初始化代码
        orchestrator = new Orchestrator(this);
        // ...其他初始化代码
    }
    
    @Override
    public Orchestrator getOrchestrator() {
        return orchestrator;
    }
}

Fragment通过已弃用的onAttach方法获取实例：

private Orchestrator orchestrator;

@Override
public void onAttach(Context context) {
    super.onAttach(context);
    orchestrator = ((IShared) context).getOrchestrator();
}

由于onAttach(Context context)已被弃用，想了解更优方案，请问是否适合使用ViewModel来持有Orchestrator对象？该对象包含大量需在Fragment间共享且会被修改的数据，但并非UI对象。

1. ViewModel是否适合持有Orchestrator？ #

适合，但要注意几个关键细节：

• ViewModel的生命周期与宿主Activity绑定，只要Activity存活，ViewModel就不会被销毁，刚好匹配你Orchestrator仅需实例化一次的需求。
• 虽然Orchestrator不是UI对象，但ViewModel本质是用于存放跨组件共享的状态/逻辑，只要它管理的是Fragment间需要共享的业务数据或逻辑，用ViewModel持有完全没问题。
• 核心注意点：ViewModel不能持有Activity Context（会引发内存泄漏），所以你当前Orchestrator持有MainActivity Context的设计需要调整——可以换成ApplicationContext，或者通过AndroidViewModel传入Application来获取安全的Context。

调整后的代码示例：

// 用AndroidViewModel持有Application，避免内存泄漏
public class SharedViewModel extends AndroidViewModel {
    private Orchestrator orchestrator;

    public SharedViewModel(Application application) {
        super(application);
        orchestrator = new Orchestrator(application.getApplicationContext());
    }

    public Orchestrator getOrchestrator() {
        return orchestrator;
    }
}

// Fragment中获取实例
private SharedViewModel viewModel;

@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);
    viewModel = new ViewModelProvider(requireActivity()).get(SharedViewModel.class);
    Orchestrator orchestrator = viewModel.getOrchestrator();
    // 后续使用orchestrator
}

2. 其他替代方案 #

方案一：弃用onAttach后的兼容写法 #

如果不想改动现有Orchestrator的Context持有逻辑，可以在Fragment的onViewCreated或onCreate中通过requireActivity()强转获取，避开弃用的onAttach方法：

@Override
public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
    super.onViewCreated(view, savedInstanceState);
    if (requireActivity() instanceof IShared) {
        orchestrator = ((IShared) requireActivity()).getOrchestrator();
    }
}

这种方式无需引入ViewModel，适合小项目或不想重构现有代码的场景，但强转存在类型安全风险，建议添加类型判断避免崩溃。

方案二：依赖注入框架（推荐中大型项目） #

如果应用规模较大，用Hilt、Dagger等DI框架将Orchestrator声明为单例，直接在Activity和Fragment中注入使用，这是最优雅的跨组件共享方式：

// Hilt示例：声明Orchestrator为单例，持有ApplicationContext
@Singleton
public class Orchestrator {
    private final Context context;

    @Inject
    public Orchestrator(@ApplicationContext Context context) {
        this.context = context;
    }
}

// MainActivity中注入
@AndroidEntryPoint
public class MainActivity extends AppCompatActivity {
    @Inject
    Orchestrator orchestrator;
}

// Fragment中注入
@AndroidEntryPoint
public class MyFragment extends Fragment {
    @Inject
    Orchestrator orchestrator;
}

这种方式完全避免了强转和生命周期依赖，同时保证单例和类型安全，是长期维护的最优解。

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