Android性能优化---万能接口

最初是在动脑学院的公开上学习到的。主要是解决Activity和Fragment之间通信而来的，我们知道Activity和Fragment之间的通信有很多的方式，比如广播，静态变量，接口回调，Handler，EventBus等等。

而万能接口肯定是对于接口回调的机制来进行封装的。一般我们定义接口回调，如下所示

    private CallBack callBack;

    public interface CallBack{
        void setDate(String s);
    }

    public void setCallBack(CallBack callBack){
        this.callBack = callBack;
    }

最后在相应的地方进行调用和注册，最终通过实现接口来实现数据的回传。

但是上面的方法，弊端是在多个Fragment通信Activity的时候，难道都要去这么创建一个接口，然后去调用吗？

这样就显得非常麻烦。此时，接口通信的万能封装就运运而生了。。。

我们在架构的时候，一般会遇到下面的这四种情况

好，这个时候进行编码。。

首先定义Function.java

package com.zhangy.universalInterface;

public class Function {

    public String functionName;

    public Function(String functionName){
        this.functionName = functionName;
    }

}

下面定义这四种状态的类
无参数无返回值

package com.zhangy.universalInterface;

/**
 * 无参数无返回值
 */
public abstract class FunctionNoParamNoResult extends Function{

    public FunctionNoParamNoResult(String functionName) {
        super(functionName);
    }

    public abstract void function();
}

无参数有返回值

package com.zhangy.universalInterface;

public abstract class FunctionNoParamHasResult<T> extends Function {


    public FunctionNoParamHasResult(String functionName) {
        super(functionName);
    }

    public abstract T function();
}

有参数无返回值

package com.zhangy.universalInterface;

public abstract class FunctionHasParamNoResult<P> extends Function {

    public FunctionHasParamNoResult(String functionName) {
        super(functionName);
    }

    public abstract void function(P p);
}

有参数有返回值

package com.zhangy.universalInterface;

public abstract class FunctionHasParamHasResult<T,P> extends Function {

    public FunctionHasParamHasResult(String functionName) {
        super(functionName);
    }

    public abstract T function(P p);
}

然后，建立一个方法的管理类FunctionManager.java

package com.zhangy.universalInterface;

import android.text.TextUtils;

import java.util.HashMap;
import java.util.Map;

public class FunctionManager {

    private static FunctionManager instance;

    private Map<String,FunctionNoParamNoResult> mNoParamNoResultMap;
    private Map<String,FunctionNoParamHasResult> mNoParamHasResultMap;
    private Map<String,FunctionHasParamNoResult> mNasParamNoResultMap;
    private Map<String,FunctionHasParamHasResult> mHasParamHasResultMap;

    private FunctionManager(){
        mNoParamNoResultMap = new HashMap<>();
        mNoParamHasResultMap = new HashMap<>();
        mNasParamNoResultMap = new HashMap<>();
        mHasParamHasResultMap = new HashMap<>();
    }

    public static FunctionManager getInstance(){
        if(instance == null){
            instance = new FunctionManager();
        }
        return instance;
    }

    //将四种类型的方法添加到FunctionManager;

    /** 添加没有参数，有返回值的方法 */
    public void addFunction(FunctionNoParamHasResult function){
        mNoParamHasResultMap.put(function.functionName,function);
    }

    /** 添加没有参数，没有返回值的方法*/
    public void addFunction(FunctionNoParamNoResult function){
        mNoParamNoResultMap.put(function.functionName,function);
    }

    /** 添加有参数，没有返回值的方法*/
    public void addFunction(FunctionHasParamNoResult function){
        mNasParamNoResultMap.put(function.functionName,function);
    }

    /** 添加有参数，有返回值的方法*/
    public void addFunction(FunctionHasParamHasResult function){
        mHasParamHasResultMap.put(function.functionName,function);
    }

    //执行没有参数，没有返回值的方法
    public void invokeFunction(String functionName){
        if(TextUtils.isEmpty(functionName)){
            return;
        }
        if(mNoParamNoResultMap != null){
            FunctionNoParamNoResult f = mNoParamNoResultMap.get(functionName);
            if(f != null){
                f.function();
            }else{
                try {
                    throw new FunctionNotFoundException("方法不存在");
                } catch (FunctionNotFoundException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    //执行没有参数，有返回值的方法
  public <T> T  invokeFunction(String functionname,Class<T> t){
        if(TextUtils.isEmpty(functionname)){
            return null;
        }

        if(mNoParamNoResultMap != null){
            FunctionNoParamHasResult f = mNoParamHasResultMap.get(functionname);
            if(f!=null){
                //cast就是转换
                return t.cast(f.function());
            }else{
                try {
                    throw new FunctionNotFoundException("方法不存在！");
                } catch (FunctionNotFoundException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
  }

   //执行有参数，没有返回值的方法
   public <P> void invokeFunction(String functionName,P p){
        if(TextUtils.isEmpty(functionName)){
            return;
        }
        if(mNasParamNoResultMap != null){
            FunctionHasParamNoResult f = mNasParamNoResultMap.get(functionName);
            if(f != null){
                f.function(p);
            }else{
                try {
                    throw new FunctionNotFoundException("方法不存在");
                } catch (FunctionNotFoundException e) {
                    e.printStackTrace();
                }
            }
        }
   }

   //执行有参数，有返回值的方法
    public <T,P> T invokeFunction(String functionName,P p ,Class<T> t){
        if(TextUtils.isEmpty(functionName)){
            return null;
        }
        if(mHasParamHasResultMap != null){
            FunctionHasParamHasResult f = mHasParamHasResultMap.get(functionName);
            if(f != null){
                return t.cast(f.function(p));
            }else{
                try {
                    throw new FunctionNotFoundException("方法不存在");
                } catch (FunctionNotFoundException e) {
                    e.printStackTrace();
                }
            }
        }
        return null;
    }


}

最后在Activity里面进行注册


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

        initFunction();
    }

    private void initFunction() {

        //无参 无返回
        FunctionManager.getInstance().addFunction(new FunctionNoParamNoResult("NoParamNoResult") {
            @Override
            public void function() {

            }
        });

        //无参 有返回值
        FunctionManager.getInstance().addFunction(new FunctionNoParamHasResult("NoParamHasResult") {
            @Override
            public String function() {
                return "Hello from the MainActivity";
            }
        });
    }

Fragnemt里面进行调用

   FunctionManager.getInstance().invokeFunction("NoParamHasResult",String.class);

注意：上面的参数functionName要前后一致哟！！！

Android性能优化---万能接口

猜你喜欢