掌握Android Fragment开发之魂：Fragment的深度解析（中）-EW帮帮网

在上一篇文章中，我们深入探讨Fragment的核心特性、优势、生命周期，以及如何通过静态和动态使用Fragment。感兴趣的朋友，请前往查阅：掌握Android Fragment开发之魂：Fragment的深度解析（上）。

在这篇文章中，我们将继续深入探讨 Android Fragment，包括以下几个核心主题:

Fragment 通信

Fragment 向 Activity 传递数据
Activity 向 Fragment 传递数据
Fragment 之间的通信方式

通过全面的理论解析、生动的示例代码和实践经验分享，这篇文章将帮助您彻底掌握 Fragment 在 Android 应用程序开发中的使用技巧，提升代码的可维护性和用户体验。现在，就让我们一起开始这段激动人心的 Fragment 之旅吧!

在 Android 应用程序中，通常情况下 Activity 和 Fragment 之间、Fragment 与 Fragment 之间都需要进行数据通信。对于这种跨层级的通信，我们有多种选择，每种方式都有其适用场景。接下来，我们就来一一拆解它们。

一、Fragment 向 Activity 传递数据

当 Fragment 需要将数据传递给宿主 Activity 时，有以下几种常见方式:

1、通过接口回调

这是最常用和标准的做法。我们需要在 Fragment 中定义一个接口，并在 Activity 中实现该接口的方法。当 Fragment 需要传递数据时，只需调用接口中的方法即可。

实现细节如下:

// 定义接口
public interface DataTransferInterface {
    void onDataReceived(String data);
}

// Fragment 实现
public class MyFragment extends Fragment {
    private DataTransferInterface dataTransferInterface;

    @Override
    public void onAttach(@NonNull Context context) {
        super.onAttach(context);
        if (context instanceof DataTransferInterface) {
            dataTransferInterface = (DataTransferInterface) context;
        } else {
            throw new RuntimeException("Activity must implement DataTransferInterface");
        }
    }

    public void sendData(String data) {
        dataTransferInterface.onDataReceived(data);
    }
}

// Activity 实现接口
public class MainActivity extends AppCompatActivity implements DataTransferInterface {

    @Override
    public void onDataReceived(String data) {
        // 处理从 Fragment 传递过来的数据
    }
}

2、通过 ViewModel

如果应用程序使用了 ViewModel 架构组件，那么通过共享 ViewModel 实例也是一种不错的选择。Fragment 可以更新 ViewModel 中的数据，Activity 监听这些数据变化并做出响应。

第一步，创建 ViewModel 类

public class SharedViewModel extends ViewModel {
    private MutableLiveData<String> mMessage = new MutableLiveData<>();

    public LiveData<String> getMessage() {
        return mMessage;
    }

    public void setMessage(String message) {
        mMessage.setValue(message);
    }
}

在 SharedViewModel 中，我们定义了一个私有的 mMessage MutableLiveData 对象和一个公共的 getMessage() 方法来获取 LiveData。setMessage() 方法用于设置 mMessage 的值。

第二步，创建 Fragment 布局和类

fragment_share_data.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <EditText
        android:id="@+id/edit_text"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="Enter some text" />

    <Button
        android:id="@+id/button_share"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Share Data" />

</LinearLayout>
ShareDataFragment.java

public class ShareDataFragment extends Fragment {

    private SharedViewModel viewModel;
    private EditText editText;

    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater， @Nullable ViewGroup container， @Nullable Bundle savedInstanceState) {
        return inflater.inflate(R.layout.fragment_share_data， container， false);
    }

    @Override
    public void onViewCreated(@NonNull View view， @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view， savedInstanceState);

        viewModel = new ViewModelProvider(requireActivity()).get(SharedViewModel.class);
        editText = view.findViewById(R.id.edit_text);
        view.findViewById(R.id.button_share).setOnClickListener(v -> {
            viewModel.setMessage(editText.getText().toString());
        });
    }
}

在 ShareDataFragment 中，我们首先获取 SharedViewModel 的实例。然后，我们在 onViewCreated() 方法中设置按钮的点击事件监听器。当点击按钮时，我们将 EditText 中的文本传递给 ViewModel 的 setMessage() 方法。

第三步，创建 Activity 布局和类

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <FrameLayout
        android:id="@+id/fragment_container"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1" />

    <TextView
        android:id="@+id/text_view"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textSize="18sp" />

</LinearLayout>

MainActivity.java

public class MainActivity extends AppCompatActivity {

    private TextView textView;
    private SharedViewModel viewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        textView = findViewById(R.id.text_view);

        viewModel = new ViewModelProvider(this).get(SharedViewModel.class);
        viewModel.getMessage().observe(this， message -> {
            textView.setText(message);
        });

        if (savedInstanceState == null) {
            getSupportFragmentManager().beginTransaction()
                    .replace(R.id.fragment_container， new ShareDataFragment())
                    .commit();
        }
    }
}

在 MainActivity 中，我们首先获取 SharedViewModel 的实例。然后，我们观察 ViewModel 中的 LiveData 对象，并在数据发生变化时更新 TextView 的文本。

最后，我们在 onCreate() 方法中添加 ShareDataFragment 到Activity的布局中。

运行这个示例应用程序后，你会看到一个包含 EditText 和按钮的 Fragment。当你在 EditText 中输入一些文本并点击"Share Data"按钮时，文本将被传递给 ViewModel，并在 Activity 的 TextView 中显示出来。

3、通过事件总线 (EventBus)

使用事件总线库(如 EventBus 或 RxBus)也是一种解决方案。Fragment 发送事件，Activity 注册监听并处理事件。这种方式比较灵活，但也增加了复杂性。

下面是使用 EventBus 库演示 Fragment 向 Activity 传递数据的完整案例。

第一步，添加 EventBus 依赖

首先，我们需要在项目的 build.gradle 文件中添加 EventBus 库的依赖:

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

第二步，定义事件类

我们需要定义一个事件类，用于在 Fragment 和 Activity 之间传递数据。

public class MessageEvent {
    public final String message;

    public MessageEvent(String message) {
        this.message = message;
    }
}

第三步，创建 Fragment 布局和类

fragment_share_data.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <EditText
        android:id="@+id/edit_text"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="Enter some text" />

    <Button
        android:id="@+id/button_share"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Share Data" />

</LinearLayout>

ShareDataFragment.java

public class ShareDataFragment extends Fragment {

    private EditText editText;

    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater， @Nullable ViewGroup container， @Nullable Bundle savedInstanceState) {
        return inflater.inflate(R.layout.fragment_share_data， container， false);
    }

    @Override
    public void onViewCreated(@NonNull View view， @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view， savedInstanceState);

        editText = view.findViewById(R.id.edit_text);
        view.findViewById(R.id.button_share).setOnClickListener(v -> {
            String message = editText.getText().toString();
            EventBus.getDefault().post(new MessageEvent(message));
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        EventBus.getDefault().register(this);
    }

    @Override
    public void onStop() {
        super.onStop();
        EventBus.getDefault().unregister(this);
    }
}

在 ShareDataFragment 中，我们在按钮的点击事件监听器中创建了一个 MessageEvent 对象，并将其发送到 EventBus。另外，我们需要在 onStart() 方法中注册 Fragment 到 EventBus，并在 onStop() 方法中注销。

第四步，创建 Activity 布局和类

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <FrameLayout
        android:id="@+id/fragment_container"
        android:layout_width="match_parent"
        android:layout_height="0dp"
        android:layout_weight="1" />

    <TextView
        android:id="@+id/text_view"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:textSize="18sp" />

</LinearLayout>

MainActivity.java

public class MainActivity extends AppCompatActivity {

    private TextView textView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        textView = findViewById(R.id.text_view);

        if (savedInstanceState == null) {
            getSupportFragmentManager().beginTransaction()
                    .replace(R.id.fragment_container， new ShareDataFragment())
                    .commit();
        }
    }

    @Override
    protected void onStart() {
        super.onStart();
        EventBus.getDefault().register(this);
    }

    @Override
    protected void onStop() {
        super.onStop();
        EventBus.getDefault().unregister(this);
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onMessageEvent(MessageEvent event) {
        textView.setText(event.message);
    }
}

在 MainActivity 中，我们首先在 onCreate() 方法中添加 ShareDataFragment 到Activity的布局中。然后，我们在 onStart() 方法中注册 Activity 到 EventBus，并在 onStop() 方法中注销。

最后，我们定义了一个 onMessageEvent() 方法，该方法会在收到 MessageEvent 时被调用。在该方法中，我们将从 Fragment 传递过来的消息显示在 TextView 上。

注意，我们使用了 @Subscribe(threadMode = ThreadMode.MAIN) 注解，以确保事件处理逻辑在主线程中执行，从而避免潜在的线程安全问题。

运行这个示例应用程序后，你会看到一个包含 EditText 和按钮的 Fragment。当你在 EditText 中输入一些文本并点击"Share Data"按钮时，文本将被传递给 Activity，并在 Activity 的 TextView 中显示出来。

二、Activity 向 Fragment 传递数据

当 Activity 需要向 Fragment 传递数据时，我们有以下几种选择:

1、通过 Fragment arguments Bundle

这是官方推荐的做法。我们可以在实例化 Fragment 时，通过 Bundle 传递数据。Fragment 可以在 onCreate() 或 onCreateView() 方法中获取 arguments Bundle。

// 创建 Bundle 并添加数据
Bundle bundle = new Bundle();
bundle.putString("key"， "value");

// 实例化 Fragment 并设置 arguments
MyFragment fragment = new MyFragment();
fragment.setArguments(bundle);

// 在 Fragment 中获取数据
String value = getArguments().getString("key");

2、通过 FragmentManager 设置数据

除了使用 arguments Bundle，我们还可以利用 FragmentManager 直接向 Fragment 实例设置数据。不过这种方式需要提前获取 Fragment 实例的引用。

假设我们有一个MainActivity，它包含一个ContentFragment。我们希望在MainActivity中获取一些数据，并通过FragmentManager将这些数据传递给ContentFragment。

MainActivity.java

import androidx.appcompat.app.AppCompatActivity;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentTransaction;

import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 假设这是我们要传递给Fragment的数据
        String dataToSend = "Hello， Fragment!";

        // 获取FragmentManager实例
        FragmentManager fragmentManager = getSupportFragmentManager();

        // 开始Fragment事务
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

        // 检查ContentFragment是否已经添加过，如果没有则添加
        if (fragmentManager.findFragmentByTag("ContentFragment") == null) {
            ContentFragment contentFragment = new ContentFragment();
            // 将数据通过Bundle传递给Fragment
            Bundle args = new Bundle();
            args.putString("data"， dataToSend);
            contentFragment.setArguments(args);

            // 添加Fragment到事务
            fragmentTransaction.add(R.id.fragment_container， contentFragment， "ContentFragment");
        }

        // 提交事务
        fragmentTransaction.commit();
    }
}

activity_main.xml

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/fragment_container"
    android:layout_width="match_parent"
    android:layout_height="match_parent"/>

ContentFragment.java

import android.os.Bundle;
import androidx.fragment.app.Fragment;

import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;

public class ContentFragment extends Fragment {

    public ContentFragment() {
        // Required empty public constructor
    }

    @Override
    public View onCreateView(LayoutInflater inflater， ViewGroup container， Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        View view = inflater.inflate(R.layout.fragment_content， container， false);

        // 从Bundle中获取数据
        Bundle args = getArguments();
        if (args != null) {
            String data = args.getString("data");
            // 在Fragment的UI上显示传递过来的数据
            TextView textView = view.findViewById(R.id.textview_data);
            textView.setText(data);
        }

        return view;
    }
}

fragment_content.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <TextView
        android:id="@+id/textview_data"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="18sp" />

    <!-- 其他布局内容 -->
</LinearLayout>

在这个例子中，MainActivity在onCreate方法中创建了一个String类型的数据，并使用Bundle将其传递给ContentFragment。然后，通过FragmentTransaction将ContentFragment添加到布局中的FrameLayout上。在ContentFragment的onCreateView方法中，我们通过getArguments方法获取传递过来的Bundle，从中提取数据，并将其设置到TextView上显示。

这个案例展示了如何在Activity和Fragment之间通过FragmentManager和Bundle进行数据传递。在实际应用中，你可以根据需要传递更复杂的数据结构。

3、通过 ViewModel

在Android架构组件中，ViewModel是一个用于存储和管理UI相关数据的类，它在配置更改（如屏幕旋转）时仍然保持数据，不随Activity或Fragment的销毁而销毁。使用ViewModel可以轻松地在Activity和Fragment之间共享数据，特别是当涉及到Fragment之间的通信时。

以下是使用ViewModel在Activity和Fragment之间传递数据的一个完整案例。

假设我们有一个MainActivity，它使用一个SharedViewModel来存储一些数据，并希望将这些数据传递给一个ContentFragment。

SharedViewModel.java

import androidx.lifecycle.ViewModel;

public class SharedViewModel extends ViewModel {
    private String data;

    public void setData(String data) {
        this.data = data;
    }

    public String getData() {
        return data;
    }
}

MainActivity.java

import androidx.appcompat.app.AppCompatActivity;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentTransaction;
import androidx.lifecycle.ViewModelProvider;

import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    private SharedViewModel sharedViewModel;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        sharedViewModel = new ViewModelProvider(this).get(SharedViewModel.class);

        // 假设这是我们要传递给Fragment的数据
        sharedViewModel.setData("Hello， Fragment!");

        // 获取FragmentManager实例
        FragmentManager fragmentManager = getSupportFragmentManager();

        // 开始Fragment事务
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();

        // 检查ContentFragment是否已经添加过，如果没有则添加
        if (fragmentManager.findFragmentByTag("ContentFragment") == null) {
            ContentFragment contentFragment = new ContentFragment();
            fragmentTransaction.add(R.id.fragment_container， contentFragment， "ContentFragment");
        }

        // 提交事务
        fragmentTransaction.commit();
    }
}

ContentFragment.java

import androidx.fragment.app.Fragment;
import androidx.lifecycle.ViewModelProvider;

import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;

public class ContentFragment extends Fragment {

    private SharedViewModel sharedViewModel;

    public ContentFragment() {
        // Required empty public constructor
    }

    @Override
    public View onCreateView(LayoutInflater inflater， ViewGroup container， Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        View view = inflater.inflate(R.layout.fragment_content， container， false);

        sharedViewModel = new ViewModelProvider(this).get(SharedViewModel.class);

        // 在Fragment的UI上显示ViewModel中的数据
        TextView textView = view.findViewById(R.id.textview_data);
        textView.setText(sharedViewModel.getData());

        return view;
    }
}

activity_main.xml

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/fragment_container"
    android:layout_width="match_parent"
    android:layout_height="match_parent"/>

fragment_content.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <TextView
        android:id="@+id/textview_data"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="18sp" />

    <!-- 其他布局内容 -->
</LinearLayout>

在这个例子中，MainActivity在onCreate方法中创建了一个SharedViewModel实例，并设置了一些数据。然后，它通过FragmentTransaction将ContentFragment添加到布局中的FrameLayout上。

在ContentFragment的onCreateView方法中，我们通过ViewModelProvider获取了与MainActivity相同的SharedViewModel实例，并从其中获取数据，将其显示在TextView上。

使用ViewModel的好处在于，即使Activity或Fragment被销毁并重新创建，ViewModel中的数据也不会丢失，这在处理屏幕旋转等配置更改时非常有用。此外，ViewModel也有助于实现MVVM架构模式，提高代码的可维护性和可测试性。

三、Fragment 之间的通信

对于 Fragment 之间的通信，我们有几种可选方案:

1、通过共享 ViewModel

在Android开发中，Fragment之间的通信可以通过共享ViewModel实现。这种方式特别适合于使用ViewModel来保持数据在配置更改（如屏幕旋转）时的持续性，并且可以在多个Fragment之间共享数据。

以下是使用共享ViewModel在两个Fragment之间进行通信的完整案例。

假设我们有两个Fragment：FragmentA和FragmentB。FragmentA允许用户输入一些数据，然后FragmentA将这些数据通过共享的ViewModel传递给FragmentB。

SharedViewModel.java

import androidx.lifecycle.ViewModel;

public class SharedViewModel extends ViewModel {
    private String data = "";

    public void setData(String data) {
        this.data = data;
    }

    public String getData() {
        return data;
    }
}

FragmentA.java

import android.os.Bundle;
import androidx.fragment.app.Fragment;
import androidx.lifecycle.ViewModelProvider;
import androidx.navigation.Navigation;

import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.EditText;

public class FragmentA extends Fragment {

    private SharedViewModel sharedViewModel;

    public FragmentA() {
        // Required empty public constructor
    }

    @Override
    public View onCreateView(LayoutInflater inflater， ViewGroup container， Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        View view = inflater.inflate(R.layout.fragment_a， container， false);

        sharedViewModel = new ViewModelProvider(this).get(SharedViewModel.class);

        EditText editText = view.findViewById(R.id.editTextData);
        Button button = view.findViewById(R.id.buttonSendData);

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String data = editText.getText().toString();
                sharedViewModel.setData(data);
                // 可以在这里进行FragmentB的导航
                Navigation.findNavController(v).navigate(R.id.action_fragmentA_to_fragmentB);
            }
        });

        return view;
    }
}

fragment_a.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <EditText
        android:id="@+id/editTextData"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="Enter data here"/>

    <Button
        android:id="@+id/buttonSendData"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Send Data"/>
</LinearLayout>

FragmentB.java

import android.os.Bundle;
import androidx.fragment.app.Fragment;
import androidx.lifecycle.ViewModelProvider;

import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;

public class FragmentB extends Fragment {

    private SharedViewModel sharedViewModel;

    public FragmentB() {
        // Required empty public constructor
    }

    @Override
    public View onCreateView(LayoutInflater inflater， ViewGroup container， Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        View view = inflater.inflate(R.layout.fragment_b， container， false);

        sharedViewModel = new ViewModelProvider(this).get(SharedViewModel.class);

        TextView textView = view.findViewById(R.id.textViewData);
        textView.setText(sharedViewModel.getData());

        return view;
    }
}

fragment_b.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <TextView
        android:id="@+id/textViewData"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="18sp" />

    <!-- 其他布局内容 -->
</LinearLayout>

在这个例子中，我们创建了一个SharedViewModel类，它持有一个String类型的数据。在FragmentA中，用户输入的数据通过按钮点击事件被收集并存储到SharedViewModel中。然后，通过Navigation组件导航到FragmentB。

在FragmentB中，我们同样使用ViewModelProvider获取SharedViewModel的实例，并从其中读取数据，将其显示在TextView上。

这种方式的优点是，即使用户在FragmentA和FragmentB之间切换，或者发生屏幕旋转等配置更改，SharedViewModel中的数据也不会丢失，因为ViewModel是设计为与UI控制器（如Fragment或Activity）的整个生命周期绑定的。

2、通过事件总线 (EventBus)

使用事件总线（如EventBus）在Fragment之间进行通信是一种轻量级的方式，它允许不同组件通过发布和订阅事件来异步通信。以下是使用EventBus在两个Fragment之间进行通信的案例。

首先，确保你已经在项目中添加了EventBus的依赖。在build.gradle文件中添加如下依赖：

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

假设我们有两个Fragment：FragmentA和FragmentB。FragmentA允许用户触发一个事件，然后通过EventBus发布这个事件。FragmentB订阅这个事件，并在接收到事件时更新UI。

EventBus 初始化

在Application类中初始化EventBus，确保它在应用启动时被初始化。

import org.greenrobot.eventbus.EventBus;

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        EventBus.builder().addIndex(OptInIndex.class).installDefaultEventBus();
    }
}

确保在AndroidManifest.xml中指定MyApplication作为你的application标签的值。

定义事件

创建一个简单的事件类。

import org.greenrobot.eventbus.Subscribe;

public class DataEvent {
    public final String data;

    public DataEvent(String data) {
        this.data = data;
    }
}

FragmentA.java

import android.os.Bundle;
import androidx.fragment.app.Fragment;
import androidx.navigation.Navigation;

import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;

import org.greenrobot.eventbus.EventBus;

public class FragmentA extends Fragment {

    private EventBus eventBus;

    public FragmentA() {
        // Required empty public constructor
    }

    @Override
    public View onCreateView(LayoutInflater inflater， ViewGroup container， Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        View view = inflater.inflate(R.layout.fragment_a， container， false);

        eventBus = EventBus.getDefault();

        Button button = view.findViewById(R.id.buttonSendData);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                // 发布事件
                eventBus.post(new DataEvent("Data from FragmentA"));
                // 导航到FragmentB，如果需要的话
                Navigation.findNavController(v).navigate(R.id.action_fragmentA_to_fragmentB);
            }
        });

        return view;
    }

    @Override
    public void onStart() {
        super.onStart();
        eventBus.register(this);
    }

    @Override
    public void onStop() public void onStop() {
        super.onStop();
        eventBus.unregister(this);
    }
}

FragmentB.java

import android.os.Bundle;
import androidx.fragment.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;

import org.greenrobot.eventbus.EventBus;
import org.greenrobot.eventbus.Subscribe;

public class FragmentB extends Fragment {

    private EventBus eventBus;
    private TextView textView;

    public FragmentB() {
        // Required empty public constructor
    }

    @Override
    public View onCreateView(LayoutInflater inflater， ViewGroup container， Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        View view = inflater.inflate(R.layout.fragment_b， container， false);
        textView = view.findViewById(R.id.textViewData);

        eventBus = EventBus.getDefault();

        return view;
    }

    @Override
    public void onStart() {
        super.onStart();
        eventBus.register(this);
    }

    @Override
    public void onStop() {
        super.onStop();
        eventBus.unregister(this);
    }

    @Subscribe
    public void onEvent(DataEvent event) {
        // 更新UI
        textView.setText(event.data);
    }
}

fragment_a.xml 和 fragment_b.xml

这两个Fragment的布局文件分别包含一个按钮和一个文本视图，用于触发事件和显示事件数据。

<!-- fragment_a.xml -->
<Button
    android:id="@+id/buttonSendData"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:text="Send Data"/>
<!-- fragment_b.xml -->
<TextView
    android:id="@+id/textViewData"
    android:layout_width="wrap_content"
    android:layout_height="wrap_content"
    android:textSize="18sp"/>

在这个例子中，FragmentA在用户点击按钮时发布一个DataEvent。FragmentB注册了EventBus，并且有一个方法onEvent，它使用@Subscribe注解来监听DataEvent事件。当FragmentB接收到事件时，它会更新其TextView来显示事件中的数据。

请注意，使用EventBus时，务必在Fragment的onStart方法中注册EventBus，在onStop方法中取消注册，以避免内存泄漏。此外，由于EventBus是一个全局通信工具，使用时要注意避免不同组件间的事件冲突。

3、通过中介 Activity

在Android开发中，有时需要通过中介Activity来实现Fragment之间的通信。这通常发生在Fragment之间没有直接的联系，或者需要由Activity来协调Fragment间的交互时。以下是通过中介Activity在两个Fragment之间进行通信的完整案例。

假设我们有两个Fragment：FragmentA和FragmentB。FragmentA允许用户输入一些数据，然后通过调用Activity中的方法将这些数据传递给FragmentB。

MainActivity.java

import androidx.appcompat.app.AppCompatActivity;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentTransaction;

import android.os.Bundle;
import android.view.View;
import android.widget.EditText;

public class MainActivity extends AppCompatActivity implements FragmentA.OnDataPassListener {

    public interface OnDataPassListener {
        void onDataPass(String data);
    }

    private String receivedData = "";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        if (savedInstanceState == null) {
            FragmentTransaction fragmentTransaction = getSupportFragmentManager().beginTransaction();
            fragmentTransaction.add(R.id.fragment_container， new FragmentA()， "FragmentA");
            fragmentTransaction.commit();
        }
    }

    public void receiveData(String data) {
        receivedData = data;
        updateFragmentB();
    }

    private void updateFragmentB() {
        Fragment currentFragment = getSupportFragmentManager().findFragmentById(R.id.fragment_container);
        if (currentFragment instanceof FragmentB) {
            FragmentB fragmentB = (FragmentB) currentFragment;
            fragmentB.updateData(receivedData);
        }
    }
}

FragmentA.java

import android.os.Bundle;
import androidx.fragment.app.Fragment;
import androidx.appcompat.widget.AppCompatButton;

import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.EditText;

public class FragmentA extends Fragment {

    private OnDataPassListener onDataPassListener;

    @Override
    public View onCreateView(LayoutInflater inflater， ViewGroup container， Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        View view = inflater.inflate(R.layout.fragment_a， container， false);

        final EditText editText = view.findViewById(R.id.editTextData);
        AppCompatButton button = view.findViewById(R.id.buttonSendData);

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String data = editText.getText().toString();
                if (onDataPassListener != null) {
                    onDataPassListener.onDataPass(data);
                }
            }
        });

        return view;
    }

    @Override
    public void onAttach(Context context) {
        super.onAttach(context);
        if (context instanceof MainActivity.OnDataPassListener) {
            onDataPassListener = (MainActivity.OnDataPassListener) context;
        } else {
            throw new RuntimeException(context.toString()
                    + " must implement OnDataPassListener");
        }
    }

    @Override
    public void onDetach() {
        super.onDetach();
        onDataPassListener = null;
    }
}

FragmentB.java

import android.os.Bundle;
import androidx.fragment.app.Fragment;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;

public class FragmentB extends Fragment {

    private TextView textView;
    private MainActivity mainActivity;

    public FragmentB() {
        // Required empty public constructor
    }

    @Override
    public View onCreateView(LayoutInflater inflater， ViewGroup container， Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        View view = inflater.inflate(R.layout.fragment_b， container， false);
        textView = view.findViewById(R.id.textViewData);

        return view;
    }

    public void updateData(String data) {
        textView.setText(data);
    }

    @Override
    public void onAttach(Activity activity) {
        super.onAttach(activity);
        try {
            mainActivity = (MainActivity) activity;
        } catch (ClassCastException e) {
            throw new ClassCastException(activity.toString() + " must implement MainActivity");
        }
    }

    @Override
    public void onDetach() {
        super.onDetach();
        mainActivity = null;
    }
}

activity_main.xml

<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/fragment_container"
    android:layout_width="match_parent"
    android:layout_height="match_parent"/>

fragment_a.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <EditText
        android:id="@+id/editTextData"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="Enter data here"/>

    <Button
        android:id="@+id/buttonSendData"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Send Data"/>
</LinearLayout>

fragment_b.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <TextView
        android:id="@+id/textViewData"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="18sp" />

    <!-- 其他布局内容 -->
</LinearLayout>

在这个例子中，MainActivity实现了一个自定义的接口OnDataPassListener，该接口定义了一个方法onDataPass，用于接收从FragmentA传递过来的数据。FragmentA在用户输入数据并点击发送按钮后，通过onDataPassListener.onDataPass(data);调用将数据传递给MainActivity。然后，MainActivity通过调用updateFragmentB()方法将数据传递给FragmentB。

在FragmentB中，我们定义了一个updateData方法来更新UI。MainActivity和FragmentB之间的通信通过mainActivity对象实现。

这种方式的优点是，Activity可以作为一个中介者来协调Fragment之间的交互，同时可以对数据进行验证和处理。然而，这种方式可能会导致代码的耦合度增加，因此在设计时需要仔细考虑。

4、通过 Interface

在Android开发中，使用接口（Interface）作为回调机制是一种常见的Fragment之间通信的方式。这种方式允许Fragment在需要与另一个Fragment或Activity交互时请求对方执行特定的操作。

以下是使用接口在FragmentA和FragmentB之间进行通信的完整案例。

假设我们有两个Fragment：FragmentA和FragmentB。FragmentA需要将一些数据传递给FragmentB，但它们之间没有直接的引用。因此，我们将在FragmentB中定义一个接口，然后让FragmentA实现这个接口，以便在需要时调用FragmentB的方法。

FragmentB.java

import android.os.Bundle;
import androidx.fragment.app.Fragment;
import androidx.annotation.Nullable;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.TextView;

public class FragmentB extends Fragment {

    private OnFragmentBActionListener listener;

    // 定义一个接口，用于回调
    public interface OnFragmentBActionListener {
        void onFragmentBAction(String data);
    }

    @Override
    public void onActivityCreated(@Nullable Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        // 设置回调接口
        listener.onFragmentBAction("Initial data");
    }

    @Override
    public View onCreateView(LayoutInflater inflater， ViewGroup container， Bundle savedInstanceState) {
        // Inflate the layout for this fragment
        View view = inflater.inflate(R.layout.fragment_b， container， false);
        TextView textView = view.findViewById(R.id.textViewData);
        textView.setText("Waiting for data from Fragment A");

        return view;
    }

    // 设置回调接口的实现者
    public void setOnFragmentBActionListener(OnFragmentBActionListener listener) {
        this.listener = listener;
    }
}

FragmentA.java

import android.os.Bundle;
import androidx.fragment.app.Fragment;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.EditText;

public class FragmentA extends Fragment implements FragmentB.OnFragmentBActionListener {

    private EditText editText;
    private Button button;

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater， @Nullable ViewGroup container， @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_a， container， false);

        editText = view.findViewById(R.id.editTextData);
        button = view.findViewById(R.id.buttonSendData);

        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                String data = editText.getText().toString();
                // 调用FragmentB的方法，传递数据
                onFragmentBAction(data);
            }
        });

        return view;
    }

    @Override
    public void onFragmentBAction(String data) {
        // 在这里实现FragmentB的回调方法
        // 由于FragmentA实现了FragmentB的接口，所以这里可以直接调用这个方法
        // 但是我们需要持有FragmentB的引用，以便传递数据
    }
}

MainActivity.java

import androidx.appcompat.app.AppCompatActivity;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentManager;
import androidx.fragment.app.FragmentTransaction;

import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
        FragmentA fragmentA = new FragmentA();
        fragmentTransaction.add(android.R.id.content， fragmentA);
        fragmentTransaction.commit();

        // 假设FragmentB已经实例化并添加到Activity中
        FragmentB fragmentB = (FragmentB) fragmentManager.findFragmentById(R.id.fragment_b);
        if (fragmentB != null) {
            // 设置FragmentB的回调接口
            fragmentB.setOnFragmentBActionListener(fragmentA);
        }
    }
}

layout 文件

以下是fragment_a.xml和fragment_b.xml的示例布局文件。

<!-- fragment_a.xml -->
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <EditText
        android:id="@+id/editTextData"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:hint="Enter data here"/>

    <Button
        android:id="@+id/buttonSendData"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Send Data"/>
</LinearLayout>
<!-- fragment_b.xml -->
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    android:padding="16dp">

    <TextView
        android:id="@+id/textViewData"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:textSize="18sp" />

    <!-- 其他布局内容 -->
</LinearLayout>

在这个例子中，`FragmentB`定义了一个接口`OnFragmentBActionListener`，该接口包含一个方法`onFragmentBAction`，用于接收数据。`FragmentA`实现了这个接口，并在用户输入数据并点击发送按钮时，调用该方法。
在`MainActivity`中，我们实例化了`FragmentA`并将其添加到布局中。同时，我们通过调用`FragmentB`的`setOnFragmentBActionListener`方法，将`FragmentA`作为回调接口的实现者传递给`FragmentB`。现在，当`FragmentA`需要与`FragmentB`通信时，它可以通过调用`onFragmentBAction`方法来实现。

请注意，为了使这个例子工作，你需要确保FragmentB的实例已经存在于MainActivity中，并且有一个方法来设置其回调接口。此外，由于FragmentA实现了FragmentB的接口，它可以直接调用接口中定义的方法，但前提是它需要持有FragmentB的引用。在实际应用中，你可以通过在MainActivity中设置这个引用，然后将它传递给需要它的Fragment。

结语：

以上就是我总结的一些 Fragment 通信方式。当然，实际项目中还需要根据具体情况来权衡和调整。希望通过这篇文章，您能够全面掌握 Fragment 的使用技巧，提升您的 Android 开发能力。

掌握Android Fragment开发之魂：Fragment的深度解析（中）

一、Fragment 向 Activity 传递数据

二、Activity 向 Fragment 传递数据

三、Fragment 之间的通信

网站公告

今日签到

热门文章

最新发布