一天一Android之Fragment

今天愚人节，先祝大家愚人节快乐!

今天来说一下Android开发中经常使用到的一个类：Fragment。由于Android屏幕的碎片化，Android为我们提供了一个和方便的类来使我们的APP可以适应各种屏幕的手机和平板，当然，Fragment的功能远不止是为适应屏幕而生。你可以把Fragment当成Activity的一个界面的一个组成部分，甚至Activity的界面可以由完全不同的Fragment组成，更神奇的是Fragment拥有自己的生命周期和接收、处理用户的事件，这样就不必再Activity写一堆控件的事件处理的代码了，更重要的是，你可以动态的添加、替换和移除某个Fragment。

Fragment的生命周期

Fragment必须依赖与Activity而存在的，因此Activity的生命周期会直接影响到Fragment的生命周期，我们来看看官网的这张关于两者的生命周期图:

可以看到，Fragment的生命周期方法中的大部分我们还是很熟悉的，只比Activity多了几个方法：

onAttach(Activity)
当Fragment与Activity发生关联时调用
onCreateView(LayoutInflater,ViewGroup,Bundle)
创建该Fragment的视图，会在这个方法中加载布局文件，返回视图。
onActivityCreated(Bundle)
当Activity的onCreate方法返回时调用
onDestoryView()
与onCreateView相对应，当该Fragment的视图被移除时调用
onDetach()
与onAttach相对应，当该Fragment与Activity关联被取消时调用。

注意：除了onCreateView方法，其他的所有方法如果你重写了，必须调用父类的方法。

静态使用Fragment

首先需要继承Fragment类，重写onCreateView方法。注意，我们即可用使用Android Studio为我们提供的创建方式，也可以直接创建java类继承Fragment，我们这里使用第二种方式，因为使用Android Studio创建的Fragment会我们生成很多无用的代码。另外，当你选择继承Fragment的时候，会有两个不同的包，一个是系统内置的android.app.Fragment，一个是support-v4库中的android.support.v4.app.Fragment。这里建议使用support-v4库中的。

下面展示一个例子，使用两个Fragment作为Activity的布局，一个Fragment用于标题布局，一个Fragment用于内容布局：

布局文件

TitleFragment

<?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="44dp"
              android:background="#963">
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/title_button"
        android:text="按钮"
        android:layout_marginLeft="5dp"
        android:layout_centerVertical="true"/>
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:id="@+id/title_text"
        android:text="你猜我是谁"
        android:textColor="#fff"
        android:textSize="22sp"
        android:layout_centerInParent="true"
        />
</RelativeLayout>

ContentFragment

<?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="match_parent">
    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="content主页"
        android:textSize="25sp"
        android:layout_centerInParent="true"
        />
</RelativeLayout>

两个Fragment类文件

TitleFragment

public class TitleFragment extends Fragment {
    private Button mButton;
    
    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.title_fragment,container,false);
        mButton = (Button) view.findViewById(R.id.title_button);
        mButton.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Toast.makeText(getActivity(),"我是一个按钮",Toast.LENGTH_SHORT).show();
            }
        });
        return view;
    }
}

ContentFragment

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

其实Fragment的创建很简单，我们只需要在onCreateView方法中加载布局就行。

再来看看如何在Activity中使用：

MainActivity的布局

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.guiyongdong.fragmentdemo.MainActivity">
    <fragment
        android:layout_width="match_parent"
        android:layout_height="44dp"
        android:name="com.guiyongdong.fragmentdemo.TitleFragment"
        android:id="@+id/fragment_title"
        />
    <fragment
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:name="com.guiyongdong.fragmentdemo.ContentFragment"
        android:id="@+id/fragment_content"
        />
</LinearLayout>

在MainActivity类的代码中我们什么都不用添加，运行结果如下：

注意：使用Fragment，在xml中必须添加id或者tag属性其中之一，不然有些系统会直接崩溃。

动态使用Fragment

先来修改一下MainActivity的布局文件，当我们点击TitleFragment上的按钮的时候，动态添加ContentFragment到视图中。

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.guiyongdong.fragmentdemo.MainActivity">
    <fragment
        android:layout_width="match_parent"
        android:layout_height="44dp"
        android:name="com.guiyongdong.fragmentdemo.TitleFragment"
        android:id="@+id/fragment_title"
        />
    <FrameLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:id="@+id/fragment_content"
        />
</LinearLayout>

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Button button = (Button) findViewById(R.id.title_button);
        button.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                FragmentManager manager = getSupportFragmentManager();
                //开启Fragment事务
                FragmentTransaction transaction = manager.beginTransaction();
                ContentFragment contentFragment = new ContentFragment();
                //替换布局
                transaction.replace(R.id.fragment_content,contentFragment);
                //事务提交
                transaction.commit();
            }
        });
    }
}

运行起来，点击按钮，显示的效果和刚才静态添加的运行效果一模一样。可以看到，我们这里使用了FragmentManager，我们来具体了解一下这个类。

Fragment家族常用的类

Fragment常用的三个类：

android.support.v4.app.Fragment：主要用于定义Fragment
android.support.v4.app.FragmentManager：主要用于在Activity中操作Fragment
android.support.v4.app.FragmentTransaction：保证一系列Fragment操作的原子性，如果你熟悉事务的话一定能明白

首先，通过getSupportFragmentManager()获取FragmentManager

然后获取一个事务对象，通过manager.beginTransaction()来开启一个事务

接下来，就可以操作Fragment了，例如：

transaction.add()：往Activity中添加一个Fragment
transaction.remove()：从Activity中移除一个Fragment
transaction.replace()：使用另一个Fragment替换当前的，实际上就是remove()然后add()的合体~
transaction.hide()：隐藏当前的Fragment，仅仅是设为不可见，并不会销毁
transaction.show()：显示之前隐藏的Fragment
transaction.detach()：会将view从UI中移除,和remove()不同,此时fragment的状态依然由FragmentManager维护
transaction.attach()：重建view视图，附加到UI上并显示
transatcion.commit()：提交事务

上述，基本是操作Fragment的所有的方式了，在一个事务开启到提交可以进行多个的添加、移除、替换等操作。

这里有几个需要注意的：

如果你已经有一个Fragment，再次调用transaction的add、replace，都会和Activity进行重新绑定，另外也会重新调用Fragmnet的onCreateView方法，重新绑定视图。

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

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

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

管理Fragment回退栈

类似与Android系统为Activity维护一个任务栈，我们也可以通过Activity维护一个回退栈来保存每次Fragment事务发生的变化。如果你将Fragment任务添加到回退栈，当用户点击后退按钮时，将看到上一次的保存的Fragment。一旦Fragment完全从回退栈中弹出，用户再次点击后退键，则退出当前Activity。

我们先来看一个效果图：

点击第一个按钮，切换到第二个界面，并在输入框内输入内容,点击第二个按钮，切换到第三个界面，然后点击Back键依次回退。这里是Fragment实现的，用户点击Back，实际是Fragment回退栈不断的弹栈。

如何添加一个Fragment事务到回退栈：FragmentTransaction.addToBackStack(String)。

我们来个例子，在MainActivity中依次添加三个Fragment，利用返回栈再依次显示三个Fragment。

先看MainActivity的布局文件：

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical"
    tools:context="com.guiyongdong.fragmentdemo.MainActivity">
    <FrameLayout
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:id="@+id/id_content"/>
</LinearLayout>

不同的Fragment就在这个FrameLayout中显示。

MainActivity.java：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //添加第一个Fragment
        FragmentManager manager = getSupportFragmentManager();
        FragmentTransaction transaction = manager.beginTransaction();
        FragmentOne one = new FragmentOne();
        transaction.add(R.id.id_content,one,"ONE");
        transaction.commit();
    }
}

很简答，直接将FragmentOne添加到布局文件的FrameLayout中，因为这里是第一个Fragment，所以并没有添加到返回栈中。

来看FragmentOne.java：

public class FragmentOne extends Fragment implements View.OnClickListener {
    private Button mButton;
    
    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_one,container,false);
        mButton = (Button) view.findViewById(R.id.one_button);
        mButton.setOnClickListener(this);
        return view;
    }
    @Override
    public void onClick(View v) {
        FragmentTwo two = new FragmentTwo();
        FragmentManager manager = getActivity().getSupportFragmentManager();
        FragmentTransaction transaction = manager.beginTransaction();
        transaction.replace(R.id.id_content,two,"TWO");
        transaction.addToBackStack(null);
        transaction.commit();
    }
}

我们在点击FragmentOne中的按钮时，使用了replace方法，如果不添加事务到回退栈中，前一个Fragment，也就是FragmentOne实例会被销毁，所以，我们调用transaction.addToBackStack(null)，将当前的事务添加到回退栈，所以FragmentOne实例不会被销毁，但是视图层依然会被销毁，即会调用onDestoryView方法。

接下来看FragmentTwo.java:

public class FragmentTwo extends Fragment implements View.OnClickListener {
    private Button mButton;
    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_two,container,false);
        mButton = (Button) view.findViewById(R.id.two_button);
        mButton.setOnClickListener(this);
        return view;
    }
    @Override
    public void onClick(View v) {
        FragmentThree three = new FragmentThree();
        FragmentManager manager = getActivity().getSupportFragmentManager();
        FragmentTransaction transaction = manager.beginTransaction();
        transaction.hide(this);
        transaction.add(R.id.id_content,three,"THREE");
        transaction.addToBackStack(null);
        transaction.commit();
    }
}

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

最后FragmentThree很简单，这里就不说了。

经过上面的介绍，应该已经知道Fragment回退栈是怎么一回事了，以及hide，replace等各自的应用的场景。

Fragment与Activity通信

因为Fragmnet都是依赖与Activity的，所以通信起来并不复杂，大概归为：

如果你Activity中包含自己管理的Fragment的引用，可以通过引用直接访问所有的Fragment的public方法
如果Activity中未保存任何Fragment的引用，那么没关系，每个Fragment都有一个唯一的TAG或者ID,可以通过getSupportFragmentManager().findFragmentByTag()或者findFragmentById()获得任何Fragment实例，然后进行操作。
在Fragment中可以通过getActivity()得到当前绑定的Activity的实例，然后进行操作

Fragment与Activity通信的最佳实现

因为要考虑Fragment的重复使用，所以必须降低Fragment与Activity的耦合，而且Fragment更不应该直接操作别的Fragment，毕竟Fragment操作应该由它的管理者Activity来决定。通常情况下，我们可以使用接口来解决这一问题。

下面通过两种方式，分别重构FragmentOne和FragmentTwo的点击事件，以及Activity对点击事件的响应：

先看FragmentOne:

public class FragmentOne extends Fragment implements View.OnClickListener {
    private Button mButton;
    
    //设置按钮点击回调接口
    public interface OneCallBack {
        void onOneBtnClick();
    }
    
    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_one,container,false);
        mButton = (Button) view.findViewById(R.id.one_button);
        mButton.setOnClickListener(this);
        return view;
    }
    @Override
    public void onClick(View v) {
        //交给Activity处理 
        if (getActivity() instanceof  OneCallBack) {
            ((OneCallBack) getActivity()).onOneBtnClick();
        }
    }
}

可以看到现在的FragmentOne不和任何Activity耦合，任何Activity都可以使用；并且我们声明了一个接口，来回调其点击事件，想要管理其点击事件的Activity实现此接口就即可。可以看到我们在onClick中首先判断了当前绑定的Activity是否实现了该接口，如果实现了则调用。

再来看FragmentTwo

public class FragmentTwo extends Fragment implements View.OnClickListener {
    private Button mButton;
    private TwoCallBack mTwoCallBack;
    public interface TwoCallBack {
        void onTwoBtnClick();
    }
    //设置回调接口
    public void setTwoCallBack(TwoCallBack twoCallBack) {
        mTwoCallBack = twoCallBack;
    }
    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_two,container,false);
        mButton = (Button) view.findViewById(R.id.two_button);
        mButton.setOnClickListener(this);
        return view;
    }
    @Override
    public void onClick(View v) {
        if (mTwoCallBack != null) {
            mTwoCallBack.onTwoBtnClick();
        }
    }
}

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

最后看MainActivity

public class MainActivity extends AppCompatActivity implements FragmentOne.OneCallBack {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //添加第一个Fragment
        FragmentManager manager = getSupportFragmentManager();
        FragmentTransaction transaction = manager.beginTransaction();
        FragmentOne one = new FragmentOne();
        transaction.add(R.id.id_content,one,"ONE");
        transaction.commit();
    }
    /*
    * FragmentOne 按钮点击时的回调
    * */
    @Override
    public void onOneBtnClick() {
        FragmentTwo two = new FragmentTwo();
        FragmentManager manager = getSupportFragmentManager();
        FragmentTransaction transaction = manager.beginTransaction();
        transaction.replace(R.id.id_content,two,"TWO");
        transaction.addToBackStack(null);
        transaction.commit();
        two.setTwoCallBack(new FragmentTwo.TwoCallBack() {
            /*
            * FragmentTwo 按钮点击时的回调 
            * */
            @Override
            public void onTwoBtnClick() {
                FragmentThree three = new FragmentThree();
                FragmentManager manager = getSupportFragmentManager();
                FragmentTransaction transaction = manager.beginTransaction();
                transaction.hide(manager.findFragmentByTag("TWO"));
                transaction.add(R.id.id_content,three,"THREE");
                transaction.addToBackStack(null);
                transaction.commit();
            }
        });
    }
}

代码重构结束，与开始的效果一模一样。上面两种通信方式都是值得推荐的，随便选择一种自己喜欢的。

如何处理运行时配置发生变化

运行时配置发生变化，最常见的就是屏幕发生选择，就那我们刚才的例子来说，先看下面的效果图：

本来MainActivity这时候显示的是FragmentTwo界面，但是当我们旋转屏幕的时候，这时候按钮又变成了FragmentOne的按钮，并且我们之前输入的内容也不见了。这是为什么呢？

这是因为当运行时配置发生变化时，Activity要重新启动，默认的Activity中的Fragment也会跟着Activity重新创建，这样造成当旋转的时候，本身存在的Fragment会重新启动，然后当执行Activity的onCreate时，又会再次实例化一个新的Fragment，这就是出现的原因。

其实通过检查onCreate的参数savedInstanceState就可以判断，当前是否发生Activity的重新创建，默认的savedInstanceState会存储一些数据，包括Fragment的实例，通过打印可以看出：

04-01 05:29:03.645 9330-9330/com.guiyongdong.fragmentdemo D/dd: onCreate: Bundle[{android:viewHierarchyState=Bundle[{android:views={16908290=android.view.AbsSavedState$1@5ddcbb8, 2131427404=android.view.AbsSavedState$1@5ddcbb8, 2131427405=android.view.AbsSavedState$1@5ddcbb8, 2131427406=android.support.v7.widget.Toolbar$SavedState@bd1fd91, 2131427407=android.view.AbsSavedState$1@5ddcbb8, 2131427421=android.view.AbsSavedState$1@5ddcbb8}, android:Panels={0=com.android.internal.policy.PhoneWindow$PanelFeatureState$SavedState@2d154f6}}], android:support:fragments=android.support.v4.app.FragmentManagerState@74850f7}]

所以，我们简单改一下代码，只有在savedInstanceState==null时，才进行创建Fragment实例:


public class MainActivity extends AppCompatActivity implements FragmentOne.OneCallBack {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        if (savedInstanceState == null) {
            //添加第一个Fragment
            FragmentManager manager = getSupportFragmentManager();
            FragmentTransaction transaction = manager.beginTransaction();
            FragmentOne one = new FragmentOne();
            transaction.add(R.id.id_content,one,"ONE");
            transaction.commit();
        }
        if (savedInstanceState != null) {
            Log.d("dd", "onCreate: "+savedInstanceState.toString());
        }
    }
	...
}

现在无论进行多次旋转都只会有一个Fragment实例在Activity中。
现在还存在一个问题，就是重新绘制时，Fragment发生重建，原本的数据如何保持？
其实和Activity类似，Fragment也有onSaveInstanceState的方法，在此方法中进行保存数据，然后在onCreate或者onCreateView或者onActivityCreated进行恢复都可以。

改造后的FragmentTwo:

public class FragmentTwo extends Fragment implements View.OnClickListener {
    ...
    
    private EditText mEditText;
    @Nullable
    @Override
    public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_two,container,false);
        mButton = (Button) view.findViewById(R.id.two_button);
        mButton.setOnClickListener(this);
        if (mEditText == null) {
            mEditText = (EditText) view.findViewById(R.id.editView);
        }
        if (savedInstanceState != null) {
            //恢复数据
            String str = savedInstanceState.getString("editText");
            mEditText.setText(str);
        }
        return view;
    }
    @Override
    public void onSaveInstanceState(Bundle outState) {
        String str = mEditText.getText().toString();
        outState.putString("editText",str);
    }
    ...
}

这样就不怕数据消失了。

好了，终于把Fragment相关的联系到一起了，上述基本包含了Fragment所有的用法，相信大家如果能够看完，一定有不少的收获。

一天一Android之Fragment

Fragment的生命周期

静态使用Fragment

布局文件

两个Fragment类文件

动态使用Fragment

Fragment家族常用的类

管理Fragment回退栈

Fragment与Activity通信

Fragment与Activity通信的最佳实现

如何处理运行时配置发生变化

分享到微信朋友圈

分享到微信朋友圈

分享到微信朋友圈

贵永冬

一天一Android之Fragment

Fragment的生命周期

静态使用Fragment

布局文件

两个Fragment类文件

动态使用Fragment

Fragment家族常用的类

管理Fragment回退栈

Fragment与Activity通信

Fragment与Activity通信的最佳实现

如何处理运行时配置发生变化

分享到微信朋友圈

分享到微信朋友圈

分享到微信朋友圈

贵永冬

初识ReactiveCocoa

深入ReactiveCocoa

ReactiveCocoa和RXSwift速查表

关于RAC的一些资料

RunLoop总结

聊一聊GCD的那些事

聊一聊NSOperation的那些事

iOS动画篇之UIView动画

iOS动画篇之CoreAnimation动画

iOS动画之CATransition动画