适用Android 可用与activity 与 fragment相互通信的小框架

    Android 中的activity与fragment通信的方式有很多，类似eventBus、rxBus、handler、static、接口等方式，

但各有优缺点。
    其中接口方式最为出色：
优点：
简单，效率高，方便，解耦和
缺点：
代码冗余，每个需要通信的fragment 都需要定义自己独一无二的接口

    本片文章的内容就是基于接口方式来构思的。
    其中心为通过接口方式，将实现类放置于特定的集合中，通过key来获取所需要的方法实现。

    具体实现的核心代码如下：

    创建一个父类：

public abstract class Funtion {

public String mFunctionName;

public Funtion(String mFunctionName) {
this.mFunctionName = mFunctionName;
}
}
    有不同的子类去定义不同的实现方式：

        第一个子类为无参无返回的方法定义：

public abstract class FunctionNoParamNotResult extends Funtion {

public FunctionNoParamNotResult(String mFunctionName) {
super(mFunctionName);
}

public abstract void function();
}    第二个子类为有参无返回的方法定义：
public abstract class FunctionWithParamOnly<Param> extends Funtion {

public FunctionWithParamOnly(String mFunctionName) {
super(mFunctionName);
}

public abstract void function(Param param);
}第三个子类为无参有返回的方法定义：
public abstract class FunctionWithResultOnly<Resu
4000
lt> extends Funtion {

public FunctionWithResultOnly(String mFunctionName) {
super(mFunctionName);
}

public abstract Result function();
}第四个子类为有参有返回的方法定义：

public abstract class FunctionWithParamAndResult<Result,Param> extends Funtion {

public FunctionWithParamAndResult(String mFunctionName) {
super(mFunctionName);
}

public abstract Result function(Param param);
}在这四个子类中只是将方法名定义出来，并未给具体实现，因为具体实现在具体的逻辑中实现。

方法类已经建立，之后就是方法管理类：
public class FunctionsManager {
private static FunctionsManager ourInstance;

private FunctionsManager() {
mFunctionNoParamNoResult = new HashMap<>();
mFunctionWithParamAndResult = new HashMap<>();
mFunctionWithParamOnly = new HashMap<>();
mFunctionWithResultOnly = new HashMap<>();
}

public static FunctionsManager getInstance() {
if(ourInstance == null){
ourInstance = new FunctionsManager();
}
return ourInstance;
}

private HashMap<String, FunctionNoParamNotResult> mFunctionNoParamNoResult;
private HashMap<String, FunctionWithParamAndResult> mFunctionWithParamAndResult;
private HashMap<String, FunctionWithParamOnly> mFunctionWithParamOnly;
private HashMap<String, FunctionWithResultOnly> mFunctionWithResultOnly;

public FunctionsManager addFunction(FunctionNoParamNotResult function ){
mFunctionNoParamNoResult.put(function.mFunctionName,function);
return this;
}

public void invokeFunction(String functionName) throws FunctionException{

if(TextUtils.isEmpty(functionName)){
return;
}

if(mFunctionNoParamNoResult != null){
FunctionNoParamNotResult f = mFunctionNoParamNoResult.get(functionName);
if(f != null){
f.function();
}
if(f == null){
throw new FunctionException("Has no this function: " + functionName);//FunctionException为Exception子类
}
}
}

public FunctionsManager addFunction(FunctionWithResultOnly function ){
mFunctionWithResultOnly.put(function.mFunctionName,function);
return this;
}

public <Result> Result invokeFunction(String functionName,Class<Result> c) throws FunctionException{

if(TextUtils.isEmpty(functionName)){
return null;
}

if(mFunctionWithResultOnly != null){
FunctionWithResultOnly f = mFunctionWithResultOnly.get(functionName);
if(f !=null){
if(c != null){
return c.cast(f.function());
}else{
return (Result) f.function();
}
}else if(f == null){
throw new FunctionException("Has no this function: " + functionName);
}
}
return null;
}

public FunctionsManager addFunction(FunctionWithParamAndResult function ){
mFunctionWithParamAndResult.put(function.mFunctionName,function);
return this;
}

public <Result,Param> Result invokeFunction(String functionName,Param data,Class<Result> c) throws FunctionException{

if(TextUtils.isEmpty(functionName)){
return null;
}

if(mFunctionWithResultOnly != null){
FunctionWithParamAndResult f = mFunctionWithParamAndResult.get(functionName);
if(f !=null){
if(c != null){
return c.cast(f.function(data));
}else{
return (Result) f.function(data);
}
}else if(f == null){
throw new FunctionException("Has no this function: " + functionName);
}
}
return null;
}

public FunctionsManager addFunction(FunctionWithParamOnly function ){
mFunctionWithParamOnly.put(function.mFunctionName,function);
return this;
}

public <Param> void invokeFunction(String functionName,Param data) throws FunctionException{

if(TextUtils.isEmpty(functionName)){
return;
}

if(mFunctionWithResultOnly != null){
FunctionWithParamAndResult f = mFunctionWithParamAndResult.get(functionName);
if(f !=null){
f.function(data);
}else if(f == null){
throw new FunctionException("Has no this function: " + functionName);
}
}
}

}

因为是管理类，所以该管理类是一个单例模式的。

具体使用方法：
在需要实现的类（activity）中添加该方法（就是上述四个子类中的具体实现）：
public void setFunctionsForFragment(String tag){
Log.e("setFunctionsForFragment","调用--"+tag);
FragmentManager fm = getSupportFragmentManager();
BaseFragment fragment = (BaseFragment) fm.findFragmentByTag(tag);
if(fragment == null){
return;
}
FunctionsManager funcManager = FunctionsManager.getInstance();

funcManager.addFunction(new FunctionNoParamNotResult("方法名") {
@Override
public void function() {
Toast.makeText(MainActivity.this,"成功调用无参无返回值的接口",Toast.LENGTH_SHORT).show();
}
}).addFunction(new FunctionWithParamAndResult<String,String>(FragmentTwo.METHOD_ONE) {
@Override
public String function(String str) {
Toast.makeText(MainActivity.this,"成功调用有参有返回值的接口",Toast.LENGTH_SHORT).show();
return str+"+activity中的数据";
}
});

fragment.setmFunctionsManager(funcManager);
}

在fragment中重写onAttach
@Override
public void onAttach(Context context) {
super.onAttach(context);
if(context instanceof MainActivity){
mBaseActivity = (MainActivity) context;
mBaseActivity.setFunctionsForFragment(getTag());
}
}
在fragment中调用该方法：

btn.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
FunctionsManager funcManager = FunctionsManager.getInstance();
try {
funcManager.invokeFunction(METHOD_ONE);
} catch (FunctionException e) {
e.printStackTrace();
}
}
});

该框架有以上已发现的缺点：

1.在实现类（activity）中setFunctionsForFragment方法会被调用多次（具体为fragment有几个就调用几次）
作者有几点疑问：
1.在fragment中重写onAttach的作用是？
2.在方法为多参数时，是怎么使用泛型的，其原理是？

该框架也可以在其他地方使用，不过更适用于activit和fragment的交互通信！

最后，作者写的该文章主要是借鉴腾讯课堂的某个大牛，具体是谁就不提了（那个大牛的某些课程是要收费的所以就不做广告了）
 欢迎有技术大牛来指出问题，解答疑问，特此感谢！！