MVP架构下，含ViewPager的Fragment与Pager内Fragment如何通信？

针对你在MVP架构下主Fragment与ViewPager子Fragment的通信需求，我提供几个简洁合规的方案，既不破坏MVP的分层职责，也能优雅实现筛选条件的传递：

方案1：基于事件总线（Event Bus）的跨Presenter通信 #

这个方案适合场景明确的单向数据传递，比如筛选条件更新这类事件。我们可以用RxJava的PublishSubject或者GreenRobot的EventBus，核心是让子Presenter订阅筛选事件，JobsPresenter在条件变化时发布事件。

实现步骤： #

1. 定义筛选事件类：

public class FilterUpdatedEvent {
    private FilterParams filterParams; // 你的筛选条件实体类
    public FilterUpdatedEvent(FilterParams params) {
        this.filterParams = params;
    }
    public FilterParams getFilterParams() {
        return filterParams;
    }
}

2. JobsPresenter发布事件：
   在JobsPresenter中，当用户选择完筛选条件后，发布事件：

public class JobsPresenter {
    private PublishSubject<FilterUpdatedEvent> filterEventSubject = PublishSubject.create();
    // 对外提供订阅入口
    public Observable<FilterUpdatedEvent> getFilterEventObservable() {
        return filterEventSubject;
    }
    // 当筛选条件更新时调用
    public void onFilterApplied(FilterParams params) {
        filterEventSubject.onNext(new FilterUpdatedEvent(params));
    }
}

3. 子Presenter订阅事件：
   以NewJobsPresenter为例，在初始化时订阅事件，收到后通知View更新列表：

public class NewJobsPresenter {
    private NewJobsView view;
    private Disposable filterDisposable;
    public NewJobsPresenter(NewJobsView view, JobsPresenter jobsPresenter) {
        this.view = view;
        // 订阅筛选事件
        filterDisposable = jobsPresenter.getFilterEventObservable()
                .subscribe(event -> {
                    // 这里可以判断当前Fragment是否可见，避免不必要的更新
                    if (view.isFragmentVisible()) {
                        view.updateJobListWithFilter(event.getFilterParams());
                    }
                });
    }
    // 记得在Presenter销毁时取消订阅
    public void onDestroy() {
        if (filterDisposable != null && !filterDisposable.isDisposed()) {
            filterDisposable.dispose();
        }
    }
}

4. 子View实现可见性判断：
   子Fragment（比如NewJobsFragment）需要实现isFragmentVisible()方法，基于getUserVisibleHint()或者onResume()/onPause()维护可见状态：

public class NewJobsFragment extends Fragment implements NewJobsView {
    private boolean isVisibleToUser;
    @Override
    public void setUserVisibleHint(boolean isVisibleToUser) {
        super.setUserVisibleHint(isVisibleToUser);
        this.isVisibleToUser = isVisibleToUser;
    }
    @Override
    public boolean isFragmentVisible() {
        return isVisibleToUser && isResumed();
    }
}

优缺点： #

• ✅ 解耦性强，JobsPresenter不需要知道子Presenter的存在
• ✅ 实现简单，适合单向事件传递
• ❌ 过度使用可能导致事件泛滥，要注意事件的单一职责

方案2：接口回调+ViewPager获取当前Fragment #

这个方案更贴合MVP的“面向接口”思想，通过JobsFragment定义回调接口，子Fragment实现该接口，JobsFragment在筛选条件变化时，获取ViewPager当前显示的子Fragment并触发回调。

实现步骤： #

1. 定义筛选回调接口：
   在JobsFragment中定义接口，用于传递筛选条件：

public interface FilterChangeListener {
    void onFilterChanged(FilterParams params);
}

2. 子Fragment实现接口：
   每个子Fragment实现该接口，并在回调中通知自己的Presenter：

public class NewJobsFragment extends Fragment implements NewJobsView, FilterChangeListener {
    private NewJobsPresenter presenter;
    @Override
    public void onFilterChanged(FilterParams params) {
        presenter.applyFilter(params);
    }
    // ... 其他View层方法
}

3. JobsFragment触发回调：
   JobsFragment在筛选条件确定后，获取ViewPager当前显示的Fragment，判断是否实现了FilterChangeListener，然后调用方法：

public class JobsFragment extends Fragment implements JobsView {
    private JobsPresenter presenter;
    private ViewPager viewPager;
    // 当筛选条件更新时，由Presenter调用View的这个方法
    @Override
    public void notifyCurrentFragmentOfFilter(FilterParams params) {
        Fragment currentFragment = getChildFragmentManager()
                .findFragmentByTag("android:switcher:" + viewPager.getId() + ":" + viewPager.getCurrentItem());
        if (currentFragment instanceof FilterChangeListener) {
            ((FilterChangeListener) currentFragment).onFilterChanged(params);
        }
    }
}

4. JobsPresenter协调调用：
   JobsPresenter在处理完筛选逻辑后，调用View层的方法触发回调：

public class JobsPresenter {
    private JobsView view;
    public void onFilterConfirmed(FilterParams params) {
        // 可以先保存筛选条件到Model层
        // ...
        view.notifyCurrentFragmentOfFilter(params);
    }
}

优缺点： #

• ✅ 符合MVP的接口驱动思想，职责清晰
• ✅ 只通知当前显示的Fragment，避免无效更新
• ❌ 需要处理Fragment的实例获取，要注意ViewPager的Fragment标签规则（上面的标签格式是Android ViewPager默认的）

方案3：共享筛选Model层 #

这个方案把筛选条件的管理抽离到独立的Model类中，所有Presenter都依赖这个Model，通过观察者模式监听条件变化，适合需要多组件共享状态的场景。

实现步骤： #

1. 创建筛选Model类：
   用单例或者依赖注入提供，内部维护筛选条件，并提供观察者接口：

public class FilterModel {
    private static FilterModel instance;
    private FilterParams currentFilter;
    private List<FilterObserver> observers = new ArrayList<>();
    public static FilterModel getInstance() {
        if (instance == null) {
            instance = new FilterModel();
        }
        return instance;
    }
    public interface FilterObserver {
        void onFilterUpdated(FilterParams params);
    }
    public void registerObserver(FilterObserver observer) {
        if (!observers.contains(observer)) {
            observers.add(observer);
        }
    }
    public void unregisterObserver(FilterObserver observer) {
        observers.remove(observer);
    }
    public void updateFilter(FilterParams params) {
        this.currentFilter = params;
        notifyObservers();
    }
    private void notifyObservers() {
        for (FilterObserver observer : observers) {
            observer.onFilterUpdated(currentFilter);
        }
    }
}

2. JobsPresenter更新Model：
   当用户选择筛选条件后，JobsPresenter调用Model更新：

public class JobsPresenter {
    private JobsView view;
    private FilterModel filterModel;
    public JobsPresenter(JobsView view) {
        this.view = view;
        this.filterModel = FilterModel.getInstance();
    }
    public void onFilterApplied(FilterParams params) {
        filterModel.updateFilter(params);
    }
}

3. 子Presenter监听Model变化：
   子Presenter在初始化时注册观察者，收到变化后通知View更新，同时在销毁时取消注册：

public class NewJobsPresenter implements FilterModel.FilterObserver {
    private NewJobsView view;
    private FilterModel filterModel;
    public NewJobsPresenter(NewJobsView view) {
        this.view = view;
        this.filterModel = FilterModel.getInstance();
        filterModel.registerObserver(this);
    }
    @Override
    public void onFilterUpdated(FilterParams params) {
        if (view.isFragmentVisible()) {
            view.refreshJobListWithFilter(params);
        }
    }
    public void onDestroy() {
        filterModel.unregisterObserver(this);
    }
}

优缺点： #

• ✅ 筛选状态集中管理，适合多组件需要同步状态的场景
• ✅ 符合MVP中Model层负责数据/状态管理的职责
• ❌ 如果是多进程场景需要调整，单例要注意内存泄漏（可以用弱引用存储观察者）

方案推荐 #

如果你的场景只是单向传递筛选条件给当前显示的子Fragment，我推荐方案2，它更贴合MVP的设计原则，代码可读性高，且不会引入额外的库。如果未来有多个组件需要监听筛选条件变化，方案3会更合适；而方案1适合快速实现，尤其是已经引入RxJava的项目。

最后要注意，不管用哪个方案，都要在Presenter的生命周期销毁方法中取消订阅/注册，避免内存泄漏。

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