Evenbus思想解决切换网络高级处理(高级篇)

这几年我用了培训多年的高级课程将自己进行了一次脱胎换骨，我想这是我最大的成就。在网易干了1年多，将思想进行了大规模总结，未来我会将课程变成免费的video传播我的思想和技术。让大家能够学习到更优美的技术，让大家都成为架构师，让我们的android溜起来，让大家工资能够顺利突破现状。下面我给你们一张图

可以点击查阅架构师之路是如何实现的。如果你是一个人才想要加入我们，你可以加我的QQ(1073033196)，不过我的思维是让广大人民得到利益，而不是我们本身，我们除了生存之外，都是免费传授技术。如果我们磨合的差不多之后，我们会选择搞培训机构传授更多知识。我们传授的不仅仅是我们的技术，对社会大局观方面我们也是会讲解，例如经济、政治、法律、道家思想、儒家思想、法家思想，融会广通，让你在工作中能够更方便，更顺利，名利两收。

好了，以上是我的个人技术。后期我会将自己的思想和技术变成video在技术网站传授给大家。接下来我讲EventBus的实现融入到其它框架中，带你们玩转EventBus。

1.EventBus上层架构思路

首先使用EventBus.getDefault().register(Object)进行注册，在销毁对象的时候使用EventBus.getDefault().unregister(Object)移除该对象，以防内存泄漏。注册方法以@Subscribe这个注解表示这个方法是EventBus的方法，会通过post来遍历总线发布执行方法，确定参数是否是post中的参数，如果是，执行。这样达到了，总线发布一条消息的时候，下面注册的子类进行回调。

一个简单例子让大家参考

    @Override
    public void onCreate() {
        super.onCreate();
        EventBus.getDefault().register(this);
    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onMessage(ImMessage imMessage) {
        
    }

    public void post(){
        EventBus.getDefault().post(new ImMessage());
    }

2.EventBus底层实现

今天我就不带大家去了解什么底层代码，我自己手写的例子，让你知道他是如何实现的就可以了，因为源码这东西，实际上也没有多少人会仔细去看，大家都是要实战经验。所以我纯手先代码让你们深刻去理解EventBus.

以下例子是在工作中会用到的，如果用户断了网络或切换网络的时候要如何让用户体验到你的产品变化，如果4G网络下看网易音乐有一个弹框提示例如"你的网络是4G，请问是否要使用4G网络看音乐"....这些都是为了更好的让用户体验产品，所以我给你们写了一个有关网络切换的用户体验的例子，有一些如果没有涉及到的可以看我上一篇文章https://blog.csdn.net/aaaaaaaaabaas/article/details/90513168

1).首先要有一个管理器NetworkManager与EventBus对象类似，他是一个单例。这个对象有register方法，将MainActivity或其他对象注册到该容器里面，容器做什么事情呢？做收集对象的方法，EventBus的注解是@Subscribe，我们叫@Network，综上所述，我们的代码结构是这样的

----1.NetworkManager对象

public class NetworkManager {

    private static volatile NetworkManager networkManager;
    private Application application;
    private NetStateReceiver receiver;

    private NetworkManager() {
        receiver = new NetStateReceiver();
    }

    public static NetworkManager getDefault() {
        if (networkManager == null) {
            synchronized (NetworkManager.class) {
                if (networkManager == null) {
                    networkManager = new NetworkManager();
                }
            }
        }
        return networkManager;
    }

    public Application getApplication() {
        return application;
    }

    public void init(Application application) {
        this.application = application;
        IntentFilter intentFilter = new IntentFilter();
        intentFilter.addAction(Constanst.ANDROID_NET_CHANGE_ACTION);
        application.registerReceiver(receiver, intentFilter);
    }

    public void registerObservable(Object observable){
        receiver.registerObservable(observable);
    }

    public void unRegisterObservable(Object observable){
        receiver.unRegisterObservable(observable);
    }

}

-------2.NetStateReceiver对象

public class NetStateReceiver extends BroadcastReceiver {

    private NetType netType;
    private HashMap> networkList;

    public NetStateReceiver() {
        // 初始化网络
        netType = NetType.NONE;
        networkList = new HashMap<>();
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent == null || intent.getAction() == null) {
            Log.e(Constanst.LOG_TAG, "异常");
            return;
        }
        // 处理广播事件
        if (intent.getAction().equalsIgnoreCase(Constanst.ANDROID_NET_CHANGE_ACTION)) {
            Log.e(Constanst.LOG_TAG, "网络发生改变");
            netType = NetworkUtils.getNetType();
            if (NetworkUtils.isNetworkConnected()) { //
                Log.e(Constanst.LOG_TAG, "网络连接成功");
            } else {
                Log.e(Constanst.LOG_TAG, "网络连接失败");
            }
            post(netType);
        }
    }

    // 将注册的对象分发netType对象
    private void post(NetType netType) {
        for (Map.Entry> methodManagerEntry : networkList.entrySet()) {
            List methodManagers = methodManagerEntry.getValue();
            if (methodManagers != null) {
                for (MethodManager methodManager : methodManagers) {
                    // 循环每个方法
                    if (methodManager != null) {
                        // 两者参数比较
                        if (methodManager.getType().isAssignableFrom(netType.getClass())) {
                            switch (methodManager.getNetType()) {
                                case AUTO:
                                    invoke(methodManager, methodManagerEntry.getKey(), netType);
                                    break;
                                case WIFI:
                                    if (netType == NetType.WIFI || netType == NetType.NONE) {
                                        invoke(methodManager, methodManagerEntry.getKey(), netType);
                                    }
                                    break;
                                case CMNET:
                                    if (netType == NetType.CMNET || netType == NetType.NONE) {
                                        invoke(methodManager, methodManagerEntry.getKey(), netType);
                                    }
                                    break;
                                case CMWAP:
                                    if (netType == NetType.CMWAP || netType == NetType.NONE) {
                                        invoke(methodManager, methodManagerEntry.getKey(), netType);
                                    }
                                    break;
                                case NONE:
                                    if (netType == NetType.NONE) {
                                        invoke(methodManager, methodManagerEntry.getKey(), netType);
                                    }
                                    break;
                            }
                        }
                    }
                }
            }
        }
    }

    // 执行注册类的所有加注解的方法
    public void invoke(MethodManager methodManager, Object object, NetType netType) {
        try {
            methodManager.getMethod().invoke(object, netType);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void registerObservable(Object registerObject) {
        List methodManagers = networkList.get(registerObject);
        if (methodManagers == null) {
            // 开始添加方法，将方法添加起来，在post的时候可以执行这些方法
            methodManagers = findAnnotationMethod(registerObject);
            networkList.put(registerObject, methodManagers);
        }
    }

    private List findAnnotationMethod(Object registerObject) {
        List methodManagers = new ArrayList<>();
        Class clazz = registerObject.getClass();
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            Network network = method.getAnnotation(Network.class);
            if (network == null) {
                continue;
            }
            // 方法的参数校验
            Class[] parameterTypes = method.getParameterTypes();
            if (parameterTypes.length != 1) {
                throw new RuntimeException(method.getName() + "方法有且只有一个参数");
            }
            // 过滤方法
            MethodManager methodManager = new MethodManager(parameterTypes[0], network.value(), method);
            methodManagers.add(methodManager);
        }
        return methodManagers;
    }

    public void unRegisterObservable(Object unRegisterObject) {
        // 包含该对象需要移除该对象
        if (networkList.containsKey(unRegisterObject)) {
            networkList.remove(unRegisterObject);
        }
        Log.e(Constanst.LOG_TAG, unRegisterObject.getClass().getName() + "注销成功");
    }
}

-------3.最后横扫千军，将一切障碍物扫除.

    NetworkManager.getDefault().init(getApplication());
    NetworkManager.getDefault().registerObservable(this);
    
    @Network(NetType.WIFI)
    public void network(NetType netType) {
        switch (netType) {
            case WIFI:
                Log.e(Constanst.LOG_TAG, "MainActivity  >>>  WIFI");
                break;
            case CMWAP:
            case CMNET:
                // 流量网络/4G网络
                Log.e(Constanst.LOG_TAG, "MainActivity  >>>  " + netType.name());
                break;
            case NONE:
                Log.e(Constanst.LOG_TAG, "MainActivity  >>>  没有网络");
                break;
        }
    }

    @Override
    public void finish() {
        super.finish();
        NetworkManager.getDefault().unRegisterObservable(this);
    }

看起来是不是很像EventBus的模式，底层通过收集对象下的包含@Network注解的方法，然后在post方法的时候遍历@Network上面的NetType，判断后通过method.invoke执行对象的方法，必须包含@Network注解的方法，而且方法参数只能有且=1，这样就能达到像EventBus的效果了。怎么样干货学到没，如果学到的话就支持我吧，可以加我的微信

我的真名叫冯朝野，请叫我朝野就可以了。谢谢大家的支持