Fragment与Fragment之间进行通信

1、大部分的Fragmtn与Activity之前的通信方式 ：主流的是一个Activity数组+许多的Fragment的架构模式。

首先,F1到MainActivity， 然后MainActivity到F2
其次,F2到MainActivity, 然后MainActivity到F3

下面我们来讲解这个主题

1、Fragment之间通信的原则是什么？

两个Fragment之间不能直接进行通信。如果它们直接进行通信，那么Fragment之间的耦合度就会非常的高，所以就会导致我们的Fragment之间就没有办法进行复用。

2、Fragment和Activity之间各自的优缺点是什么？

Fragment的好处：

1、Android2.3以后推出，是为了解决屏幕适配的问题
2、系统开销非常的小。单独的处理View的显示，不需要进行太多的数据操作。
3、Fragment有个FragmentManager，可以非常的方便管理Fragment栈。
4、Fragment界面的耦合度非常的低，我们只要把界面赋值上去就可以了。不需要去管Fragment之间的关系。

3、通信的方式

EventBus
是一个万金油，哪里都有它。
优点：方便，快捷，使用起来也很简单
缺点：
1、反射、性能打折。效率比较低。—会导致卡顿
2、代码很难维护
3、数据无法返回，单向传送

handler

缺点：
 1、耦合性很低
 2、内存泄漏
 3、无法获得Activity的结果   单向传播的方式

static

缺点：
  1、静态的变量，会占用很大的内存

广播

缺点：
  1、性能比较差，延迟
  2、因为是监听系统级别的，比如电话，蓝牙等。所以通信体系比较大
  3、传播数据有限
  4、单一数据源，多个数据发送
  5、代码不复杂，但是实现机制是比较复杂的
  6、代码冗余

接口
简单，效率比较高，方便，解耦合
缺点：
代码冗余，每个需要通信的Fragment都要有自己的一个接口

4、万能接口

首先，用面向对象的方式把接口抽象出来

1、抽象Name

public abstract Function{
  public String FunctionName;
  
  public Function(String FunctionName)
    this.FunctionName=FunctionName
}

2、抽象参数
分为这么几种情况

1、没有参数，没有返回值

public abstract FunctionNoParamNoResult extends Function{
   public FuncitonNoParamNoParamNoResult(String FunctionName){
     super(FunctionName)
   }
   //定义没有实现的函数体
   public abstract void function();
}

2、有参数，没有返回值

  public abstract FunctionwithParamNoResult<Param> extends Function{
   public FuncitonNoParamNoParamNoResult(String FunctionName){
     super(FunctionName)
   }
   //定义没有实现的函数体
   public abstract void function(Param param);
}

3、没有参数，有返回值

  public abstract FunctionwithParamNoResult<Result> extends Function{
   public FuncitonNoParamNoParamNoResult(String FunctionName){
     super(FunctionName)
   }
   //定义没有实现的函数体
   public abstract Result function();
}
``` 
   4、有参数，有返回值

public abstract FunctionwithParamNoResult<Result,Param> extends Function{
public FuncitonNoParamNoParamNoResult(String FunctionName){
super(FunctionName)
}
//定义没有实现的函数体
public abstract Result function(Param param);
}

5、定义一个管理类
FunctionManager 一般都是管理类

public class FunctionManager{
private static FunctionManager instance;
private FunctionManager(){
mFunctionNoParamNoResult=new HashMap<>();
FunctionNoParamResult=new HashMap<>();
FunctionParamNoResult=new HashMap<>();
FunctionParamResult=new HashMap<>();
}

public static FunctionManager getInstance(){
if(instance==null){
instance =new FunctionManager();
}
return instance;
}
//创建一个容器来保存上面的一些状态

private HashMap<String,FunctionNoParamNoResult> mFunctionNoParamNoResult;
private HashMap<String,FunctionNoParamResult> FunctionNoParamResult;
private HashMap<String,FunctionParamNoResult> FunctionParamNoResult;
private HashMap<String,FunctionParamResult> FunctionParamResult;

public FunctionManager addFunction(FunctionNoParamNoResult function){
mFunctionNoParamNoResult.put(function.mFunctionName,function);
return this;
}

public void invokeFunction(String functionName){

      if(TextUtils.isEmpty(functionName)==true){
          return;
       }
     if(mFunctionNoParamNoResult!=null){
    FunctionNoParamNoResult f=mFunctionNoParamNoResult.get(functionName);
    if(f !=null){
     f.function()
    }
    if(f==null){
       //抛出一个异常
       throw new FunctionException("Has no this function:"+functionName)
    }
  }
}

}
}

6、定义一个异常

public class FunctionException extends Exception{
public FunctionException(String exception){
super(exception);
}

7、定义一个BaseFragment,给所以的Fragment用

public class BaseFragment extends Fragment{
proteced FunctionManager mFunctionManager;
prvate MainActivity mBaseActivity;

 public void setFunctionManager(FunctionManager functionManager){
   this.mFunctionManager=functionManager;
 }

 //绑定
 public void onAttach(Context context){
 super.onAttach(context)
 if(context instanceof MainActivity){
   mBaseActivity=(MainActivity)context;
   mBaseActivity.setFunctionForFragment(getTag())
 }else{

 }
}

}

### 下来就是接口的使用了
 1、fragment里面定义接口
 2、在activity里面实现接口
 3、将接口和fragment和Activity进行绑定，暴露
 4、使用

Fragment定义接口,并继承BaseFragment

public static final Srring INTERFACE = BlankFragment.class.getName()+”NPNR”;

//调用暴露
mFunctionManager.invokeFunc(INTERFACE);

Activity里面实现

public void setFunctionForFragment(String tag){
FragmentManager fm=getSupportFragmentManager();
BaseFragment bs=(BaseFragment)fm.findFragmentByTag(tag);
bs.setFunctionManager(FunctionManager.getInstance().addFunction(new FunctionNoParamNoResult(BlankFragment.INTERFACE){

@Override
public void function(){
Toast.......
}

}));

}
`

具体代码可以查看FragmentStruct