上手Fragment

最新推荐文章于 2022-10-08 07:45:00 发布

_dolphin

最新推荐文章于 2022-10-08 07:45:00 发布

阅读量268

点赞数

本文链接：https://blog.csdn.net/qq_30591155/article/details/107006814

版权

Android 专栏收录该内容

9 篇文章 1 订阅

订阅专栏

文章目录

Fragment的静态注册
Fragment的动态注册
Fragment生命周期
Fragment的常用类和API
Fragment 回退栈
Fragment与Activity之间的通信
- Activity传递数据到Fragment（不推荐）
- Fragment传递数据到Activity

Fragment的静态注册

什么是静态注册，fragment的静态注册就是Activity中的标签属性（activity_main.xml中的fragment标签）和定义的Fragment类在运行之前已经绑定，运行时不在发生变化。

步骤：

声明一个类继承自Fragment加载自定义的布局

注：fragment存在于两个包中，如果导入的是android.app.fragment包，已过时，如下图，那么与fragment相关联的Activity类可以继承自Activity（或者子类，fragment事务方法有区别）；如果导入的是v4包中的fragment，那么与fragment相关联的Activity类必须继承自FragmentActivity或者AppCompatActivity。

将activity布局中的<fragment>标签与fragment类绑定

<fragment
        android:id="required"
        android:tag="not_required
        android:name="继承自Fragment的全限定类名"
        android:layout_height="..."
        android:layout_width="..."/>

id属性和name属性必填，否则抛出

Caused by: java.lang.IllegalArgumentException: Binary XML file line #8: Must specify unique android:id, android:tag, or have a parent with an id for null

完整示例：

首先声明了两个类分别继承自v4包下的Fragment，然后通过onCreateView方法将布局加载并返回，我的理解继承Fragment类的作用，是将一个布局转换为fragment，然后该类才能附在fragment标签上。加载的两个布局代码就贴一个吧。

fragment_title.xml
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:background="@android:color/white">
    <TextView
        android:layout_width="match_parent"
        android:layout_height="60dp"
        android:gravity="center"
        android:text="我是一个title"
        android:textSize="25sp"
        android:background="#4444F0"/>
</RelativeLayout>

import android.support.v4.app.Fragment;

public class FragmentTitle extends Fragment {

    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater,ViewGroup container, Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_title, container, false);
        return view;
    }
}

import android.support.v4.app.Fragment;

/**
 *android.support.v4.app.Fragment
 *加载Fragment的Activity必须继承FragmentActivity，否则他不会认为这是一个Fragment
 */
public class FragmentContent extends Fragment {

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

FragmentActivity类

/**
 * 1） 静态加载Fragment
 * 使用V4包下的Fragment，Activity需要继承自FragmentActivity|或者FragmentActivity的子类(AppCompatActivity)
 */
public class FragmentActivity extends android.support.v4.app.FragmentActivity {

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

通过activity布局中的<fragment>标签静态绑定，activity_fragment布局如下。

<?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">

    <!--在main_activity中注册fragment标签
        ==注意：它不是一个控件，它是一个引用型的标签==-->
    <fragment
        android:id="@+id/left_frag"
        android:tag="frag_left"
        android:name="cn.wjx34t0701.fragment.FragmentTitle"
        android:layout_height="wrap_content"
        android:layout_width="match_parent"/>
    <fragment
        android:id="@+id/right_frag"
        android:tag="frag_right"
        android:layout_height="match_parent"
        android:layout_width="match_parent"
        android:name="cn.wjx34t0701.fragment.FragmentContent" />
</LinearLayout>

运行截图

在这里插入图片描述

Fragment的动态注册

动态注册的Fragment可以灵活的向activity布局容器中添加或者删除，就像java多态的特性那样，根据程序逻辑所需，动态绑定。

步骤：

继承Fragment，和前面静态注册一样。
在Activity中调用getSupportFragmentManager()(v4包下）获得FragmentManager对象，然后通过fragmentManager.beginTransaction()获得FragmentTransaction，开启事务，动态的对Fragment进行管理。

示例：

Activity所在布局，主要是对布局进行了简单的修改，通过<include>标签引入一个简单的底部导航栏，导航栏布局代码不在展示，就四个控件；然后借助framelayout控件承载我们的fragment。

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

    <!--静态加载-->
    <fragment
        android:id="@+id/frag_title"
        android:layout_width="match_parent"
        android:layout_height="45dp"
        android:layout_alignParentTop="true"
        android:name="cn.wjx34t0701.fragment.FragmentTitle"/>

    <!--动态加载fragment将其放入FrameLayout布局容器-->
    <FrameLayout
        android:id="@+id/frame_content"
        android:layout_below="@id/frag_title"
        android:layout_above="@id/bottombar"
        android:layout_width="match_parent"
        android:layout_height="match_parent"/>

    <include
        android:id="@+id/bottombar"
        layout="@layout/bottom_bar"
        android:layout_width="match_parent"
        android:layout_height="50dp"
        android:layout_alignParentStart="true"
        android:layout_alignParentBottom="true" />

</RelativeLayout>

activity所在类，因为使用的是v4包下的fragment，所以这里继承的是AppCompatActivity

public class DynamicFragmentActivity extends AppCompatActivity implements View.OnClickListener {

    private TextView mTabWechat;
    private TextView mTabFriend;
    private WechatContent mWechatFragment;
    private FriendContent mFriendFragment;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_dynamic_fragment);
        initView();
        // 设置初始化fragment
        setDefaultFragment();
    }

    private void initView() {
        mTabWechat = findViewById(R.id.tab_wechat);
        mTabFriend = findViewById(R.id.tab_friend);
        mTabWechat.setOnClickListener(this);
        mTabFriend.setOnClickListener(this);

    }

    private void setDefaultFragment() {
        // 获取Fragment的管理对象 FragmentManager：用来在Fragment和Activity之间交互的接口
        FragmentManager fragmentManager = getSupportFragmentManager();
        // 获得事务对象，add、remove、replace等等操作都称为事务
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        mWechatFragment = new WechatContent();
        transaction.replace(R.id.frame_content, mWechatFragment);
        /**
         * 其他常用事务
         * transaction.remove(Fragment);
         * transaction.hide(Fragment);
         * transaction.show(Fragment);
         */

        // 提交事务
        transaction.commit();

    }

    @Override
    public void onClick(View v) {
        FragmentManager fragmentManager = getSupportFragmentManager();
        // 开启fragment事务
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        switch (v.getId()) {
            case R.id.tab_wechat:
                if (mWechatFragment == null) {
                    mWechatFragment = new WechatContent();
                }
                transaction.replace(R.id.frame_content, mWechatFragment);
                break;
            case R.id.tab_friend:
                if (mFriendFragment == null) {
                    mFriendFragment = new FriendContent();
                }
                transaction.replace(R.id.frame_content, mFriendFragment);
                break;
        }
        // 提交事务
        transaction.commit();
    }
}

还有两个Fragment，分别是WechatFragment和FriendFragment，这里偷了个巧，两者都使用了一个布局，主要是在onCreateView布局获取到的时候，对其中的控件做了一些改变。

public class WechatContent extends Fragment {

    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_content, container, false);
        TextView textView = view.findViewById(R.id.content_tag);
        textView.setText("WeChat");
        return view;
    }
}

public class FriendContent extends Fragment {

    public static final String TAG = "FriendContent";
    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        Log.d(TAG, "onCreateView...");
        View view = inflater.inflate(R.layout.fragment_content, container, false);
        TextView textView = view.findViewById(R.id.content_tag);
        textView.setText("Friend Content");
        return view;
    }
}

在这里插入图片描述

Fragment生命周期

在这里插入图片描述

Fragment依存于Activity而存在，因此Activity的生命周期会直接影响到Fragment。

onAttach(Activity)
当Fragment与Activity发生关联时调用。
onCreateView(LayoutInflater, ViewGroup,Bundle)
创建该Fragment的视图
onActivityCreated(Bundle)
当Activity的onCreate方法返回时调用
onDestoryView()
与onCreateView想对应，当该Fragment的视图被移除时调用
onDetach()
与onAttach相对应，当Fragment与Activity关联被取消时调用
注意：除了onCreateView，其他的所有方法如果你重写了，必须调用父类对于该方法的实现，

Fragment的常用类和API

Fragment常用的三个类：

android.app.Fragment 主要用于定义Fragment

android.app.FragmentManager 主要用于在Activity中操作Fragment

android.app.FragmentTransaction 保证一些列Fragment操作的原子性，就像数据库中的事务一样。

FragmentManager

在activity所在类通过getSupportFragmentManager()或者getFragmentManager()(分别对应v4包和老包）获取

FragmentTransaction 主要方法

FragmentTransaction transaction = fm.benginTransatcion();开启一个事务
transaction.add()

往Activity中添加一个fragment
transaction.remove()

从Activity中移除一个Fragment，如果移除的Fragment没有添加到回退栈，这个Fragment实例将会被销毁
transaction.replace()

使用另一个Fragment替换当前的，实际上是remove()然后add()的结合
transaction.hide()

隐藏当前的Fragment，仅仅是设为不可见，并不会销毁
transaction.show()

显示之前隐藏的Fragment
detach()

会将view从UI中移除,和remove()不同,此时fragment的状态依然由FragmentManager维护
attach()

重建view视图，附加到UI上并显示

commit()

提交一个事务

Transaction主要方法	作用
add()	往Activity中添加一个fragment
remove()	从Activity中移除一个Fragment，如果移除的Fragment没有添加到回退栈，这个Fragment实例将会被销毁
replace()	使用另一个Fragment替换当前的，实际上是remove()然后add()的结合
hide()	隐藏当前的Fragment，仅仅是设为不可见，并不会销毁
show()	显示之前隐藏的Fragment
detach()	会将view从UI中移除,和remove()不同,此时fragment的状态依然由FragmentManager维护
attach()	重建view视图，附加到UI上并显示
commit()	提交一个事务
addToBackStack(“fname”)	FragmentManager拥有回退栈（BackStack），类似于Activity的任务栈，如果添加了该语句，就把该事务加入回退栈，当用户点击返回按钮，会回退该事务（回退指的是如果事务是`add(frag1)`，那么回退操作就是`remove(frag1)`）；如果没添加该语句，用户点击返回按钮会直接销毁Activity。

如何使用？

a、比如：我在FragmentA中的EditText填了一些数据，当切换到FragmentB时，如果希望会到A还能看到数据，则适合你的就是hide和show；也就是说，希望保留用户操作的面板，你可以使用hide和show，当然了不要使劲在那new实例，进行下非null判断。

b、再比如：我不希望保留用户操作，你可以使用remove()，然后add()；或者使用replace()这个和remove,add是相同的效果。

c、remove和detach有一点细微的区别，在不考虑回退栈的情况下，remove会销毁整个Fragment实例，而detach则只是销毁其视图结构，实例并不会被销毁。那么二者怎么取舍使用呢？如果你的当前Activity一直存在，那么在不希望保留用户操作的时候，你可以优先使用detach。

Fragment 回退栈

类似与Android系统为Activity维护一个任务栈，我们也可以通过Activity维护一个回退栈来保存每次Fragment事务发生的变化。默认情况下，Fragment事务是不会加入回退栈的，如果你想将Fragment任务添加到回退栈，可以通过addToBackStack("")方法，当用户点击后退按钮时，将看到上一次的保存的Fragment。一旦Fragment完全从后退栈中弹出，用户再次点击后退键，则退出当前Activity。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WbONgAKY-1593345355851)(D:\FILE\NeHcIxbp2r.gif)]

MainActivity.java

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        transaction.add(R.id.frame_container, new FragmentOne(), "ONE");
        transaction.commit();
    }
}

activity布局代码很简单就不在贴了，就是将fragment放入framlayout中。

FragmentOne.java

public class FragmentOne extends Fragment implements View.OnClickListener {

    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        // attachToRoot false，若为true会导致重复添加
        View view = inflater.inflate(R.layout.fragment_one, container, false);
        Button btTwo = view.findViewById(R.id.go_two);
        btTwo.setOnClickListener(this);
        return view;
    }

    @Override
    public void onClick(View v) {
        FragmentTwo fmTwo = new FragmentTwo();
        FragmentManager fragmentManager = getFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        transaction.replace(R.id.frame_container, fmTwo, "TWO");
        transaction.addToBackStack(null);
        transaction.commit();
    }
}

点击FragmentOne中的按钮时，使用了replace方法，replace是remove和add的结合，并且如果不添加事务到回退栈，前一个Fragment实例会被销毁。这里很明显，我们调用tx.addToBackStack(null);将当前的事务添加到了回退栈，所以FragmentOne实例不会被销毁，~~但是视图层次依然会被销毁，即会调用onDestoryView和onCreateView，证据就是：仔细看上面的效果图，我们在跳转前在文本框输入的内容，在用户Back得到第一个界面的时候不见了。~~有歧义待研究，因为上面gif演示了视图层中的数据也还在

FragmentTwo.java

public class FragmentTwo extends Fragment implements View.OnClickListener {
    public static final String TAG = "FragmentTwo";

    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        // attachToRoot false，若为true会导致重复添加
        View view = inflater.inflate(R.layout.fragment_two, container, false);
        Button btTwo = view.findViewById(R.id.go_three);
        btTwo.setOnClickListener(this);
        return view;
    }

    @Override
    public void onClick(View v) {
        FragmentThree fmThree = new FragmentThree();
        FragmentManager fragmentManager = getFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        transaction.hide(this);
        transaction.add(R.id.frame_container, fmThree);
        // transaction.replace(R.id.frame_container, fmThree, "THREE");
        transaction.addToBackStack(null);
        transaction.commit();
    }

这里点击时，我们没有使用replace，而是先隐藏了当前的Fragment，然后添加了FragmentThree的实例，最后将事务添加到回退栈。这样做的目的是为了给大家提供一种方案：如果不希望视图重绘该怎么做，请再次仔细看效果图，我们在FragmentTwo的EditText填写的内容，用户Back回来时，数据还在【当做一种技巧吧！】

Fragment与Activity之间的通信

Activity传递数据到Fragment（不推荐）

在将fragment添加到事务之前设置，fragment.setArguments(Bundle);

//举例  
//Activity中
Fragment fm = new Fragment();
Bundle bundle = new Bundle();
bundle.putString("hello", hello);
fm.setArguments(bundle);

//Fragment中   
Bundle bundle = getArguments();
//获取bundle之后，再用bundle获取对应的数据  
String hello = bundle.getString("hello");

使用findFragmentByTag()方法获取Fragment，调用Fragment的方法。（注：动态添加fragment的同时设置标签调用transaction.add(container, fragment, TAG);，当fragment动态加入的时候，才可以findFragmentByTag）

 //获取当前页面的fragment，这里的Tag是在将Fragment添加到布局的时候设置的。
Fragment fragment = (Fragment) getSupportFragmentManager().findFragmentByTag(tag);
//调用相应的方法
fragment.xxx();
// 比如，我可以获取TAG为"one"的fragment然后根据类型做一定的强转，调用方法进行通信
Fragment one = getFragmentManager().findFragmentByTag("one");
if (one instanceof FragmentOne) {
    ((FragmentOne) one).sayHell();
}

Fragment传递数据到Activity

因为要考虑Fragment的重复使用，所以必须降低Fragment与Activity的耦合，而且Fragment更不应该直接操作别的Fragment，毕竟Fragment操作应该由它的管理者Activity来决定。

下面以Activity响应FragmentOne和FragmentTwo中点击事件为例进行讲解。

FragmentOne.java

public class FragmentOne extends Fragment implements View.OnClickListener {

    public static final String TAG = "FragmentOne";

    public interface FOneBtnClickListener {
        void onFOneBtnClick(String msg);
    }

    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        Bundle arguments = getArguments();
        if (arguments != null) {
            Log.d(TAG, "arguments "+arguments.get("content"));
        }
        // attachToRoot false，若为true会导致重复添加
        View view = inflater.inflate(R.layout.fragment_one, container, false);
        Button btTwo = view.findViewById(R.id.go_two);
        btTwo.setOnClickListener(this);
        return view;
    }


    @Override
    public void onClick(View v) {

        if (getActivity() instanceof MainActivity) {
            ((MainActivity) getActivity()).onFOneBtnClick("fragment_one send a msg");
        }
    }
}

FragmentOne不与任何Activity耦合，为什么？因为接口，当FragmentOne点击事件发生后，会进行判断当前Activity是否实现了该接口，如果实现了那么就会回调到Activity所在类，这是一种通信的方式，否则不会回调。

FragmentTwo.java

public class FragmentTwo extends Fragment implements View.OnClickListener {
    public static final String TAG = "FragmentTwo";

    private FTwoBtnClickListener mListener;
    public interface FTwoBtnClickListener {
        void onFTwoBtnClick(String msg);
    }

    public void setListener(FTwoBtnClickListener listener) {
        mListener = listener;
    }

    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        // attachToRoot false，若为true会导致重复添加
        View view = inflater.inflate(R.layout.fragment_two, container, false);
        Button btTwo = view.findViewById(R.id.go_three);
        btTwo.setOnClickListener(this);
        return view;
    }

    @Override
    public void onClick(View v) {
        if (mListener != null) {
            mListener.onFTwoBtnClick("fragment_two send a msg");
        }
    }
}

与FragmentOne极其类似，但是我们提供了setListener这样的方法，意味着Activity不仅需要实现该接口，还必须显示调用mFTwo.setfTwoBtnClickListener(this)。

public class MainActivity extends AppCompatActivity implements FragmentOne.FOneBtnClickListener, FragmentTwo.FTwoBtnClickListener {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Bundle bundle = new Bundle();
        bundle.putCharSequence("content", "activity send a msg");
        FragmentOne fragmentOne = new FragmentOne();
        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        fragmentOne.setArguments(bundle);
        transaction.add(R.id.frame_container, fragmentOne, "ONE");
        transaction.commit();

    }

	/**
	* FragmentOne 按钮点击时的回调
	*/
    @Override
    public void onFOneBtnClick(String msg) {
        Toast.makeText(this, "msg-->"+msg, Toast.LENGTH_SHORT).show();
        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTwo fmTwo = new FragmentTwo();
        fmTwo.setListener(this);
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        transaction.replace(R.id.frame_container, fmTwo, "TWO");
        transaction.addToBackStack(null);
        transaction.commit();
    }

    @Override
    public void onFTwoBtnClick(String msg) {
        Toast.makeText(this, "msg-->"+msg, Toast.LENGTH_SHORT).show();
    }
}

上面两种通信方式都是值得推荐的，随便选择一种自己喜欢的。这里再提一下：虽然Fragment和Activity可以通过getActivity与findFragmentByTag或者findFragmentById，进行任何操作，甚至在Fragment里面操作另外的Fragment，但是没有特殊理由是绝对不提倡的。**Activity担任的是Fragment间类似总线一样的角色，应当由它决定Fragment如何操作。**另外虽然Fragment不能响应Intent打开，但是Activity可以，Activity可以接收Intent，然后根据参数判断显示哪个Fragment。

参考

郭霖Android Fragment 真正的完全解析

《Android Fragment 非常详细的一篇》