Fragment解析

Fragment的产生与介绍

Android运行在各种各样的设备中，有小屏幕的手机，超大屏的平板甚至电视。针对屏幕尺寸的差距，很多情况下，都是先针对手机开发一套App，然后拷贝一份，修改布局以适应平板神马超级大屏的。难道无法做到一个App可以同时适应手机和平板么，当然了，必须有啊。Fragment的出现就是为了解决这样的问题。你可以把Fragment当成Activity的一个界面的一个组成部分，甚至Activity的界面可以完全有不同的Fragment组成，更帅气的是Fragment拥有自己的生命周期和接收、处理用户的事件，这样就不必在Activity写一堆控件的事件处理的代码了。更为重要的是，你可以动态的添加、替换和移除某个Fragment。

为什么要使用fragment

1. 单Activity＋多Fragment：
   一个app仅有一个Activity，界面皆是Frament，Activity作为app容器使用。
   优点：性能高，速度最快。参考：新版知乎 、google系app
2. 多模块Activity＋多Fragment
   优点：速度快，相比较单Activity+多Fragment，更易维护
3. 无视图的fragment 保存数据用
   activity的onSaveInstanceState(Bundle outState)能保存的数据量有限，当有大量数据要保存的时候用无视图的fragmentActivity异常销毁时onSaveInstanceState能保存的数据有限，数据过大容易oom。所以我们可以在onSaveInstanceState时attach一个Fragment，并将要存储的大数据保存到这个Fragment。 当Activity重建时找到这个Fragment，再从中取出那些数据。
   

生命周期探究

onHiddenChanged 的回调时机

1. 当使用add()+show()，hide()跳转新的Fragment时，旧的Fragment回调onHiddenChanged()，不
   会回调onStop()等生命周期方法
2. 而新的Fragment在创建时是不会回调onHiddenChanged()
   Fragment 主要用于定义Fragment
   FragmentManager 主要用于在Activity中操作Fragment
   FragmentTransaction 保证一些列Fragment操作的原子性，熟悉事务这个词，一定能明白

获取FragmentManage的方式

1. getFragmentManager()
2. v4中，getSupportFragmentManager

主要的操作都是FragmentTransaction的方法

1. FragmentTransaction transaction = fm.benginTransatcion();//开启一个事务
2. transaction.add() 
往Activity中添加一个Fragment
3. transaction.remove()
从Activity中移除一个Fragment，如果被移除的Fragment没有添加到回退栈（回退栈后面会详细说），这个Fragment实例将会被销毁。
4. transaction.replace()
使用另一个Fragment替换当前的，实际上就是remove()然后add()的合体~ 
5. transaction.hide()
隐藏当前的Fragment，仅仅是设为不可见，并不会销毁
6. transaction.show()
显示之前隐藏的Fragment
7. detach()
会将view从UI中移除,和remove()不同,此时fragment的状态依然由FragmentManager维护。
8. attach()
重建view视图，附加到UI上并显示。
9. transatcion.commit()//提交一个事务

注意：常用Fragment的哥们，可能会经常遇到这样Activity状态不一致：State loss这样的错误。
主要是因为：commit方法一定要在Activity.onSaveInstance()之前调用
比如：我在FragmentA中的EditText填了一些数据，当切换到FragmentB时，如果希望会到A还能看到数据，则适合你的就是hide和show；也就是说，希望保留用户操作的面板，你可以使用hide和show，当然了不要使劲在那new实例，进行下非null判断。
再比如：我不希望保留用户操作，你可以使用remove()，然后add()；或者使用replace()这个和remove,add是相同的效果。
remove 和 detach 有一点细微的区别，在不考虑回退栈的情况下，remove会销毁整个Fragment实例，而detach则只是销毁其视图结构，实例并不会被销毁。那么二者怎么取舍使用呢？如果你的当前Activity一直存在，那么在不希望保留用户操作的时候，你可以优先使用detach。

Fragment Arguments

setArguments方法必须在fragment创建以后，添加给Activity前完成

Fragment与Activity通信

fragment交互后数据应该通过接口返回给activity

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

Fragmeny与ActionBar和MenuItem集成

Fragment可以添加自己的MenuItem到Activity的ActionBar或者可选菜单中。

1. 在Fragment的onCreate中调用 setHasOptionsMenu(true);
2. 然后在Fragment子类中实现onCreateOptionsMenu
   ue);
3. 然后在Fragment子类中实现onCreateOptionsMenu
4. 如果希望在Fragment中处理MenuItem的点击，也可以实现onOptionsItemSelected；当然了Activity也可以直接处理该MenuItem的点击事件。

特点

Fragment与Activity相似，有自己的生命周期，布局。相当于一个迷你的Activity
Fragment可以作为Activity的组成部分，一个Activity可以有多个Fragment
一个Fragment可以被多个Activity重用
在Activity运行时可动态地加入、移除、交换Fragment
一个具有自己生命周期的控件,有自己的处理输入事件的能力
依赖于Activity，能互相通信和托管。

优势

1、代码复用

Activity用来管理Fragment。因为一个Fragment可以被多个Activity嵌套，有个共同的业务模块就可以复用了

2、模块化

Fragment具有自己生命周期，是模块化UI的良好组件。

3、依赖性

Fragment的生命周期是寄托到Activity中，Fragment可以被Attach添加和Detach释放。

4、切换灵活

Fragments是view controllers，它们包含可测试的，解耦的业务逻辑块，由于Fragments是构建在views之上的，而views很容易实现动画效果，因此Fragments在屏幕切换时具有更好的控制。

5、可控性

Fragment可以像普通对象那样自由的创建和控制，传递参数更加容易和方便，也不用处理系统相关的事情，显示方式、替换、不管是整体还是部分，都可以做到相应的更改。

生命周期

解释如下：

onAttach()：Fragment和Activity相关联时调用。可以通过该方法获取Activity引用，还可以通过getArguments()获取参数。
onCreate()：Fragment被创建时调用。
onCreateView()：创建Fragment的布局。
onViewCreated()：当Fragment的view创建完成
onActivityCreated()：当Activity完成onCreate()时调用。
onStart()：当Fragment可见时调用。
onResume()：当Fragment可见且可交互时调用。
onPause()：当Fragment不可交互但可见时调用。
onStop()：当Fragment不可见时调用。
onDestroyView()：当Fragment的UI从视图结构中移除时调用。
onDestroy()：销毁Fragment时调用。
onDetach()：当Fragment和Activity解除关联时调用。
上面的方法中，只有onCreateView()在重写时不用写super方法，其他都需要。

因为Fragment依赖Activity，那么Fragment和Activity的生命周期可谓是息息相关，如下图所示

Activity的FragmentManager负责调用队列中Fragment的生命周期方法，只要Fragment的状态与Activity的状态保持了同步，托管Activity的FragmentManager便会继续调用其他生命周期方法以继续保持Fragment与Activity的状态一致。

打开页面

Activity-onCreate(begin)，Fragment-onAttach-onCreate-onCreateView-onViewCreated，Activity-onCreate(end)，Fragment-onActivityCreated，Activity-onStart，Fragment-onStart，Activity-onResume，Fragment-onResume

按下HOME键

Fragment-onPause，Activity-onPause，Fragment-onStop，Activity-onStop

重新打开页面

Activity-onRestart-onStart，Fragment-onStart，Activity-onResume，Fragment-onResume

按下返回键

Fragment-onPause，Activity-onPause，Fragment-onStop，Activity-onStop，Fragment-onDestroyView-onDestroy-onDetach，Activity-onDestroy

加载方式

静态加载

    <fragment
        android:id="@+id/f3"
        android:layout_width="match_parent"
        android:layout_height="150dp"
android:name="com.example.lenovo.mpplication.fragment.Fragment3"/>

动态加载

FragmentManager

Fragment的管理则交由FragmentActivity的FragmentManager来实现。

获取方式：

getSupportFragmentManager（）：在Activity中使用Fragment的管理器，对所有Fragment进行管理。

getFragmentManager（）：与 getSupportFragmentManager（）功能是一样的，只是是在Fragment中使用

getChildFragmentManager()：在嵌套的Fragment中，内部的fragment创建，需要使用getChildFragmentManager（）

注意：在fragment创建childFragment的时候，需要注意的是：使用getChildFragmentManager（） 使用getFragmentManager（）会导致内存泄漏

常用API:

getFragments():可以获取所有创建时候add进去的所有Fragment；通常可以通过这个api来获取需要指定操作的fragment对象
findFragmentByTag(String tag): 通过TAG获取指定的Fragment；这个TAG，在FragmentTransaction的add(int containerViewId, Fragment fragment,String tag)进行设置。
popBackStack()： 弹出栈顶fragment
popBackStack(String tag,int flags)：tag可以为null或者相对应的tag，flags只有0和1(POP_BACK_STACK_INCLUSIVE)两种情况
如果tag为null，flags为0时，弹出回退栈中最上层的那个fragment。
如果tag为null ，flags为1时，弹出回退栈中所有fragment。
如果tag不为null，那就会找到这个tag所对应的fragment，flags为0时，弹出该fragment以上的Fragment，如果是1，弹出该fragment（包括该fragment）以上的fragment。
popBackStackImmediate相关的方法与上面逻辑是一样的与上面不同的是，在调用的时候会立即执行弹出。

FragmentTransaction

通过FragmentTransaction实现在Activity运行时可动态地加入、移除、交换Fragment

FragmentTransaction的主要方法介绍

针对在一个Activity中的某个Layout中切换Fragment,无非两种方法：

使用replace方法创建新实例，销毁旧的，无法复用。
使用hide和show方法，最终是让Fragment的View setVisibility(true还是false)，不会调用生命周期,可复用。会调用onHiddenChanged。
add(id, fragment)

增加framgent到队列中，并显示该fragment到指定布局中。
生命周期调用
当fragment与activity连接并被建立时（onAttach()、onCreate()被调用过） 例如当fragment在回退栈时。
onCreateView()、onActivityCreated()、onStart()、onResume()。
当fragment与activity未连接并未被建立时（onAttach()、onCreate()未被调用过）
onAttach()、onCreate()、onCreateView()、onActivityCreated()、onStart()、onResume()。
id是告知FragmentManager，Fragment应该出现在哪个layout上
remove(fragment)

销毁队列中指定的fragment。
生命周期调用：onPause()、onStop()、onDestroyView()、onDestroy()、onDetach()
replace(id, fragment)

先检查队列中是否已经存在，不存在就会进入队列并把其他fragment清出队列，最后显示该fragment到指定布局中。
生命周期调用：相当于新的Fragment调用了add，队列中其他fragment调用了remove
(新的Fragment创建：onAttach()、onCreate()、onCreateView()、onActivityCreated()、onStart()、onResume()，队列中其他fragment销毁：onPause()、onStop()、onDestroyView()、onDestroy()、onDetach())
show(fragment)

显示队列中的指定framgent。
当队列中存在该fragment时并被调用过hide(fragment)时，回调onHiddenChange(boolean)。
hide(fragment)

隐藏队列中指定的fragment
当队列中存在该fragment时，回调onHiddenChange(boolen)
detach()

会将view从UI中移除,和remove()不同,此时fragment的状态依然由FragmentManager维护。
生命周期调用：onPause()、onStop()、onDestroyView()
attach()

重建view视图，附加到UI上并显示。
生命周期调用：onCreateView()、onActivityCreated()、onStart()、onResume()
addToBackStack()

当移除或替换一个片段并向返回栈添加事务时，系统会停止（而非销毁）移除的片段。 如果用户执行回退操作进行片段恢复，该片段将重新启动。

如果是替换一个片段，这个替换片段相当于add()
移除或替换一个片段并向返回栈添加事务时，被移除片段将被detach()
执行回退操作进行片段恢复，这个片段将被attach()，而上一个片段有两种情况
1、如果是回退栈中还有这个片段那么将被detach()。
2、如果回退栈没有这个片段将被remove()
具体实例可参看：Fragment的addToBackStack()使用

commit()

提交本次事务，可在非主线程中被调用。主要用于多线程处理情况。在onSaveInstanceState之后提交会出现IllegalStateException，可以使用commitAllowingStateLoss代替
commitAllowingStateLoss()

可能会丢掉FragmentManager的状态, 即onSaveInstanceState之后任何被添加或被移除的Fragments.
commitNow()

提交本次事务，只在主线程中被调用。 这时候addToBackStack(string)不可用。
commit(), commitNow()和commitAllowingStateLoss()区别分析

实例：

//addToBackStack

FragmentManager fragmentManager = getFragmentManager();
FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
fragmentTransaction.replace(R.id.fragment12, fragment1);
fragmentTransaction.addToBackStack(null);
fragmentTransaction.commitNow();

//添加Fragment到FragmentList中
private void addFragment(Fragment fragment, String tag){
        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        transaction.add(R.id.fragment_container,fragment,tag);
        transaction.commit();
    }

// 清空fragmentList的所有Fragment，替换成新的Fragment，注意Fragment里面的坑
private void replaceFragment(Fragment fragment, String tag){
        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        transaction.replace(R.id.fragment_container,fragment,tag);
        transaction.commit();
    }

//移除指定的Fragment
private void removeFragment(Fragment fragment){
        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        transaction.remove(fragment);
        transaction.commit();
    }

//把Fragment设置成显示状态，但是并没有添加到FragmentList中
private void showFragment(Fragment fragment){
        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        transaction.show(fragment);
        transaction.commit();
    }

//把Fragment设置成显示状态，但是并没有添加到FragmentList中
private void hideFragment(Fragment fragment){
        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        transaction.hide(fragment);
        transaction.commit();
    }

// 效果和show相近，创建视图，添加到containerid指定的Added列表，FragmentList依然保留，但是会引起生命周期的变化
private void attachFragment(Fragment fragment){
        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        transaction.attach(fragment);
        transaction.commit();
    }

// 效果和hide相近，清除视图，从containerid指定的Added列表移除，FragmentList依然保留，但是会引起生命周期的变化
private void detachFragment(Fragment fragment){
        FragmentManager fragmentManager = getSupportFragmentManager();
        FragmentTransaction transaction = fragmentManager.beginTransaction();
        transaction.detach(fragment);
        transaction.commit();
    }

数据传递

使用setArguments(Bundle args)传递，在onCreate中使用getArguments()取出。和Activity的Intent恢复机制类似。

常见坑

1、如果你需要在Fragment中用到宿主Activity对象，建议在你的基类Fragment定义一个Activity的全局变量，在onAttach中初始化，这不是最好的解决办法，但这可以有效避免一些意外Crash。

protected Activity mActivity;
@Override
public void onAttach(Activity activity) {
super.onAttach(activity);
this.mActivity = activity;
}

2、onHiddenChanged的回调时机

当使用add()+show()，hide()跳转新的Fragment时，旧的Fragment回调onHiddenChanged()，不会回调生命周期方法，而新的Fragment在创建时是不会回调onHiddenChanged()

Google 官方推荐的做法:

谷歌爸爸推荐的做法是对于 Fragment 栈里没有的，先添加进栈里，第二次需要展示时再将目标 Fragment 采用 show 的方式 显示，再将其他的 Fragment 隐藏，以下是这种的思想的流程图：

这种思想的实现为：

/***
     * 所有fragment生命周期的只会加载一次
     * @param layout 加载的容器id
     * @param currentFragment 要显示fragment
     * @param preFragment 前一个fragment
     */
    public void switchFragment(int layout, Fragment currentFragment, Fragment preFragment) {
        FragmentTransaction fragmentTransaction = manager.beginTransaction();
        // 先判断是否被add过
        if (!currentFragment.isAdded()) {
            if (preFragment != null) {
                // 隐藏当前的fragment，add下一个到Activity中
            fragmentTransaction.hide(preFragment).add(layout, currentFragment).commitAllowingStateLoss();             
        } else {
            fragmentTransaction.add(layout, currentFragment).commitAllowingStateLoss();
            }
        } else {
            if (preFragment != null) {
fragmentTransaction.hide(preFragment).show(currentFragment).commitAllowingStateLoss();  // 隐藏当前的fragment，显示下一个
            } else {
fragmentTransaction.show(currentFragment).commitAllowingStateLoss();
            }
        }
    }

这种方法的一个 特点：
所有的 Fragment 的生命周期只有在 add 这个操作的时候才会走，下次 show 或者 hide 时不会再走上面的提过的生命周期（onAttach-onCreate-onCreateView-onActivityCreated-onStart-onResume-onPause-onStop-onDestoryView-onDestory-onDetach）当 add 完一个 Fragment 之后，下次再次进入这个 Fragment 时，只会走onHinddenChange 这个回调。

举个例子：

当处于 AFragment时：此时生命周期如下：

AFragment 生命周期
此时界面如下：

AFragment 从生命周期中可以看到确实跟我们平时接触到的知识一样，走到了 onResume 时呈现界面。此时切换到 BFragment  切换 BFragment 可以看到先走到 BFragment 的 onCreate 方法之后，接着调用 A 的 onHinddenChange 此时返回 true。最后走的是 BFragment 的 onResume 因此界面显示的是 BFragment。 因此，可以得出： 当某个 Fragment 不可见 时，该 Fragment 的 onHinddenChange 返回 true。 ###### replace 切换

除了上面的 add+show/hide 切换 fragment 的方式之外，还可以调用 replace 方法进行切换：
依旧是先获取 Fragment 的管理器，接着开启事物，然后调用 replace 方法，最后提交这个事物

FragmentManager manager = getSupportFragmentManager();
FragmentTransaction fragmentTransaction = manager.beginTransaction();
fragmentTransaction.replace(R.id.fl_container, currentFragment).commit();

我们仍旧先把所有的 Fragment 都 add 一遍，此时页面为 AFragment，生命周期为：

跳转到 BFragment 时：

可以看到先是走了BFragment 的 onAttach-onCreate 接着走 AFragment 的onStop-> onDetach，最后再到 BFragment 的 onResume，这个过程有点类似于 Activity 的跳转过程。
此时再从 BFragment 回到 AFragment ，此时的生命周期为：

此时还是先把 BFragment 结束掉，然后重新走 AFragment 的 生命周期。因此：
当使用 replace 进行切换 Fragment 时，会重新走完 Fragment 的生命周期。
在不同的需要场景灵活应用两种不同的加载方式有利于提高 APP 的性能：
对于需要有缓存需求的，可以使用 add+show/hide 方式
对于每次进入都需要刷新界面的需求，则可以使用replace的方式(切换广告视频这种的)