学习笔记：打造自己的万能接口，实现类似eventbus的功能

学习地址：study.163.com/smartSpec/i…

1.项目目录

目录下包含两个两个文件夹和一个Class文件
annotation文件夹是模仿eventbus使用模式需要用到的注解文件
functionBeans文件夹是回调方法实体类
FunctionManager是管理和使用类

2.编写回调方法实体类

定义一个function基类

public class Function {

    // 一个方法可以没有返回，没有参数，但是必须要有方法名
    //定义方法名
    public String functionName; 

    // 标记，用于移除方法
    public String tag; 

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

在定义回调方法的时候，只有四种类型的方法：

没参数，没返回： public void function();
有参数，没返回： public void function(Obeject obj);
没参数，有返回： public Object function();
有参数，有返回： public Object function(Obeject obj);

所有回调方法都逃不脱这以上四种，所以把这四种类型抽象成javaBean。

没参数，没返回： public void function();

/**
 * @作者 huzhuoren
 * @创建日期 2019-09-08 14:04
 * @描述: 没参数，没返回
 */
public abstract class NoParamNoResultFunction extends Function {
    public NoParamNoResultFunction(String functionName, String tag) {
        super(functionName, tag);
    }

    public abstract void function();
}

有参数，没返回： public void function(Obeject obj);

/**
 * @作者 huzhuoren
 * @创建日期 2019-09-08 14:03
 * @描述: 有参数，没返回
 * 参数 P 不确定参数类型，所以用了泛型
 * 参数有可能会有多个，所以用了 P... p
 */
public abstract class HasParamNoResultFunction<P> extends Function {
    public HasParamNoResultFunction(String functionName, String tag) {
        super(functionName, tag);
    }

    public abstract void function(P... p);
}

没参数，有返回： public Object function();

 /**
* @作者 huzhuoren
* @创建日期 2019-09-08 14:04
* @描述: 没参数，有返回
* 返回 T
*/
public abstract class NoParamHasResultFunction<T> extends Function {
    public NoParamHasResultFunction(String functionName,String tag) {
        super(functionName,tag);
    }

    public abstract T function();
}

有参数，有返回： public Object function(Obeject obj);

 /**
 * @作者 huzhuoren
 * @创建日期 2019-09-08 14:03
 * @描述: 有参数，有返回
 * 参数 P  返回 T
 */
public abstract class HasParamHasResultFunction<T, P> extends Function {
    public HasParamHasResultFunction(String functionName,String tag) {
        super(functionName,tag);
    }

    public abstract T function(P... p);
}

3.编写FunctionManager类

//这个类里面是做方法FunctionBean的管理工作的，所有的方法的添加，移除，执行操作都在这里
    public class FunctionManager {

    //单例
    public static FunctionManager instance;


    //定义存放function的map
    private HashMap<String, NoParamNoResultFunction> mNoParamNoResultMap;
    private HashMap<String, NoParamHasResultFunction> mNoParamHasResultMap;
    private HashMap<String, HasParamNoResultFunction> mHasParamNoResultMap;
    private HashMap<String, HasParamHasResultFunction> mHasParamHasResultMap;

    private FunctionManager() {
        //初始化存放四种类型的方法的map
        mNoParamNoResultMap = new HashMap<>();
        mNoParamHasResultMap = new HashMap<>();
        mHasParamNoResultMap = new HashMap<>();
        mHasParamHasResultMap = new HashMap<>();
    }
    //单例
    public static FunctionManager getInstance() {
        if (instance == null) {
            instance = new FunctionManager();
        }
        return instance;
    }

    /**
     * 无参数无返回
     **/
    public void addFunction(NoParamNoResultFunction function) {
        mNoParamNoResultMap.put(function.functionName, function);
    }
    //执行
    public void invokeFunction(String functionName) {
        if (TextUtils.isEmpty(functionName)) {
            return;
        }
        if (mNoParamNoResultMap != null) {
            NoParamNoResultFunction f = mNoParamNoResultMap.get(functionName);
            if (f != null) {
                f.function();
            }
        } else {
            Log.e("FunctionManager", "没有找到该方法：" + functionName);
        }

    }


    /**
     * 有参数无返回
     **/
    public void addFunction(HasParamNoResultFunction function) {
        mHasParamNoResultMap.put(function.functionName, function);
    }

    //执行
    public <P> void invokeFunction(String functionName, P p) {
        if (TextUtils.isEmpty(functionName)) {
            return;
        }
        if (mHasParamNoResultMap != null) {
            HasParamNoResultFunction f = mHasParamNoResultMap.get(functionName);
            if (f != null) {
                f.function(p);
            }
        } else {
            Log.e("FunctionManager", "没有找到该方法：" + functionName);
        }
    }


    /**
     * 无参数有返回
     **/
    public void addFunction(NoParamHasResultFunction<Object> function) {
        mNoParamHasResultMap.put(function.functionName, function);
    }
    
     //执行
    public <T> T invokeFunction(String functionName, Class<T> t) {
        if (TextUtils.isEmpty(functionName)) {
            return null;
        }
        if (mNoParamHasResultMap != null) {
            NoParamHasResultFunction<Object> f = mNoParamHasResultMap.get(functionName);
            if (f != null) {
                return t.cast(f.function());
            }
        } else {
            Log.e("FunctionManager", "没有找到该方法：" + functionName);
        }

        return null;
    }


    /**
     * 有参数有返回
     **/
    public void addFunction(HasParamHasResultFunction function) {
        mHasParamHasResultMap.put(function.functionName, function);
    }

    //执行
    public <T, P> T invokeFunction(String functionName, P p, Class<T> t) {
        if (TextUtils.isEmpty(functionName)) {
            return null;
        }
        if (mHasParamHasResultMap != null) {
            HasParamHasResultFunction f = mHasParamHasResultMap.get(functionName);
            if (f != null) {
                return t.cast(f.function(p));
            }
        } else {
            Log.e("FunctionManager", "没有找到该方法：" + functionName);
        }

        return null;
    }



    //根据tag去遍历所有的map，移除对应的方法
    public void deleteFunction(String tag) {

        Iterator<Map.Entry<String, NoParamNoResultFunction>> mNoParamNoResultIterator = mNoParamNoResultMap.entrySet().iterator();
        while (mNoParamNoResultIterator.hasNext()) {
            HashMap.Entry<String, NoParamNoResultFunction> map = mNoParamNoResultIterator.next();
            if (map.getValue().tag.equals(tag)) {
                mNoParamNoResultIterator.remove();
            }
        }

        Iterator<Map.Entry<String, NoParamHasResultFunction>> mNoParamHasResultIterator = mNoParamHasResultMap.entrySet().iterator();
        while (mNoParamHasResultIterator.hasNext()) {
            HashMap.Entry<String, NoParamHasResultFunction> map = mNoParamHasResultIterator.next();
            if (map.getValue().tag.equals(tag)) {
                mNoParamHasResultIterator.remove();
            }
        }

        Iterator<Map.Entry<String, HasParamNoResultFunction>> mHasParamNoResultIterator = mHasParamNoResultMap.entrySet().iterator();
        while (mHasParamNoResultIterator.hasNext()) {
            HashMap.Entry<String, HasParamNoResultFunction> map = mHasParamNoResultIterator.next();
            if (map.getValue().tag.equals(tag)) {
                mHasParamNoResultIterator.remove();
            }
        }

        Iterator<Map.Entry<String, HasParamHasResultFunction>> mHasParamHasResultIterator = mHasParamHasResultMap.entrySet().iterator();
        while (mHasParamHasResultIterator.hasNext()) {
            HashMap.Entry<String, HasParamHasResultFunction> map = mHasParamHasResultIterator.next();
            if (map.getValue().tag.equals(tag)) {
                mHasParamHasResultIterator.remove();
            }
        }
    }
}

4.使用FunctionManager，进行组建间通信（传递数据）

在A界面实现你的回调方法，并添加到Manager中去，并在onDestroy的时候deleteFunction

在B界面调用，调用是通过方法名调用的，也就是“test”这个方法名

实现在B界面打印A界面的log

5.总结：大体的思路是把所有的回调方法都丢到一个集合里面去，需要调用的时候就去集合里面取。