自己实现全局通信messenger

怼烎@ 2022-03-21 04:50 165阅读 0赞

参考[MVVM Light Toolkit使用指南][MVVM Light Toolkit]中的messenger实现方式

这里只讲关键代码，完整代码参考[https://github.com/Kelin-Hong/MVVMLight/tree/master/library/src/main/java/com/kelin/mvvmlight/messenger][https_github.com_Kelin-Hong_MVVMLight_tree_master_library_src_main_java_com_kelin_mvvmlight_messenger]

注册监听有两种方式：

/**
         * @param recipient    消息接收者
         * @param token     当发送消息携带相同的token时，这个唯一的token的接收者会收到message
         * @param  receiveDerivedMessagesToo   是否衍生类也可以收到消息，这个衍生类指的是消息类型的衍生类
         * @param action         回调
         */
        public void register(Object recipient, Object token, boolean receiveDerivedMessagesToo, BindingAction action) {}

和

/**
         * see {}
         *
         * @param recipient     同上
         * @param token     同上
         * @param receiveDerivedMessagesToo    同上
         * @param action     带参数回调
         * @param tClass     消息类型
         * @param <T>      消息类型
         */
        public <T> void register(Object recipient, Object token, boolean receiveDerivedMessagesToo, BindingConsumer<T> action, Class<T> tClass) {}

以第一种注册为例：

public void register(Object recipient, Object token, boolean receiveDerivedMessagesToo, BindingAction action) {
    		// Type是Java 编程语言中所有类型的公共高级接口（官方解释），也就是Java中所有类型的“爹”
            Type messageType = NotMsgType.class;
    
            HashMap<Type, List<WeakActionAndToken>> recipients;
            
    		// receiveDerivedMessagesToo为true，则给添加到recipientsOfSubclassesAction列表，为false则添加到recipientsStrictAction 列表
            if (receiveDerivedMessagesToo) {
                if (recipientsOfSubclassesAction == null) {
                    recipientsOfSubclassesAction = new HashMap<Type, List<WeakActionAndToken>>();
                }
                recipients = recipientsOfSubclassesAction;
            } else {
                if (recipientsStrictAction == null) {
                    recipientsStrictAction = new HashMap<Type, List<WeakActionAndToken>>();
                }
                recipients = recipientsStrictAction;
            }
    
            List<WeakActionAndToken> list;
    
            if (!recipients.containsKey(messageType)) {
                list = new ArrayList<WeakActionAndToken>();
                recipients.put(messageType, list);
            } else {
                list = recipients.get(messageType);
            }
    
            WeakAction weakAction = new WeakAction(recipient, action);
    
            WeakActionAndToken item = new WeakActionAndToken(weakAction, token);
            list.add(item);
            cleanup();
        }

发送消息：

/**
         *
         * @param message 任何类型都可以
         * @param token  前面解释过了
         * @param target   目标类
         */
        private <T> void sendToTargetOrType(T message, Type messageTargetType, Object token) {
            Class messageType = message.getClass();
    
    		// 衍生类
            if (recipientsOfSubclassesAction != null) {
    		    List<Type> listClone = new ArrayList<>();
                listClone.addAll(recipientsOfSubclassesAction.keySet());
                for (Type type : listClone) {
                    List<WeakActionAndToken> list = null;
    
                    if (messageType == type
                    		// 是否是超类
                            || ((Class) type).isAssignableFrom(messageType)
                            // 是否是实现类
                            || classImplements(messageType, type)) {
                        list = recipientsOfSubclassesAction.get(type);
                    }
    
                    sendToList(message, list, messageTargetType, token);
                }
            }
    
    		// 严格类，必须是本身类
            if (recipientsStrictAction != null) {
                if (recipientsStrictAction.containsKey(messageType)) {
                    List<WeakActionAndToken> list = recipientsStrictAction.get(messageType);
                    sendToList(message, list, messageTargetType, token);
                }
            }
    
            cleanup();
        }

相应的，发送消息的方法也分为是否携带message参数，发送消息的实现方法（有参数的例子）：

private static <T> void sendToList(
               T message,
               Collection<WeakActionAndToken> list,
               Type messageTargetType,
               Object token) {
           if (list != null) {
               ArrayList<WeakActionAndToken> listClone = new ArrayList<>();
               listClone.addAll(list);
    
               for (WeakActionAndToken item : listClone) {
                   WeakAction executeAction = item.getAction();
                   if (executeAction != null
                           && item.getAction().isLive()
                           && item.getAction().getTarget() != null
                           && (messageTargetType == null
                           || item.getAction().getTarget().getClass() == messageTargetType
                           || classImplements(item.getAction().getTarget().getClass(), messageTargetType))
                           && ((item.getToken() == null && token == null)
                           || item.getToken() != null && item.getToken().equals(token))) {
                       // 调用回调方法
                       executeAction.execute(message);
                   }
               }
           }
       }

其实就是用一个值为List的Map来存放接收者，发送的时候进行遍历，中间有用到弱引用。

[MVVM Light Toolkit]: https://www.jianshu.com/p/43ea7a531700
[https_github.com_Kelin-Hong_MVVMLight_tree_master_library_src_main_java_com_kelin_mvvmlight_messenger]: https://github.com/Kelin-Hong/MVVMLight/tree/master/library/src/main/java/com/kelin/mvvmlight/messenger