观察者模式简单使用

package com.example.myapplication_java.rxJava;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Set;

public class ObserverManager {

    private static ObserverManager _manager;
    //因为可以有多个地方需要监听同一个事件，所以这里的观察者可能是多个，用Set保存
    private HashMap> mHashMap;
    private static Object _object = new Object();

    public ObserverManager() {
        this.mHashMap = new HashMap>();
    }

    /**
     * 通过单例获取观察者管理对象
     * @return
     */
    public static ObserverManager getInstance() {
        if (_manager == null) {
            synchronized (_object) {
                if (_manager == null) {
                    _manager = new ObserverManager();
                }
            }
        }
        return _manager;
    }

    /**
     * 注册观察者，
     *
     * @param name     观察者注册的标识
     * @param function 观察者对象
     */
    public void registerObserver(String name, Function function) {
        synchronized (_object) {
            Set functionSet;
            if (!this.mHashMap.containsKey(name)) {
                functionSet = new HashSet<>();
                this.mHashMap.put(name, functionSet);
            } else {
                functionSet = this.mHashMap.get(name);
            }
            functionSet.add(function);

        }

    }

    /**
     * 根据标识删除某个观察者
     *
     * @param name
     */
    public void removeObserver(String name) {
        synchronized (_object) {
            if (this.mHashMap.containsKey(name)) {
                this.mHashMap.remove(name);
            }
        }
    }

    /**
     * 根据标识和观察者对象删除某个观察者
     *
     * @param name
     * @param function
     */
    public void removeObserver(String name, Function function) {
        synchronized (_object) {
            if (this.mHashMap.containsKey(name)) {
                Set functions = this.mHashMap.get(name);
                functions.remove(function);
            }
        }
    }

    /**
     * 根据观察者对象删除某个观察者
     *
     * @param function
     */
    public void removeObserver(Function function) {
        synchronized (_object) {
            for (String key : this.mHashMap.keySet()) {
                Set functions = this.mHashMap.get(key);
                functions.remove(function);
            }
        }

    }

    /**
     * 清除所有观察者
     */
    public void clear() {
        synchronized (_object) {
            this.mHashMap.clear();
        }
    }

    /**
     * 通知所有观察者
     *
     * @param name   观察者注册标识
     * @param params 提供给观察者的参数
     */
    public void notify(String name, Object... params) {
        synchronized (_object) {
            if (this.mHashMap.containsKey(name)) {
                Set functions = this.mHashMap.get(name);
                for (Function function : functions) {
                    function.function(params);
                }
            }
        }
    }

public interface Function {
	//在实现类中，可以根据实际情况返回什么数据，然后在ObserverManager中进行其他操作
    Object function(Object... objects);
}
}

在需要注册的地方先实现Function接口，然后调用注册方法

ObserverManager.getInstance().registerObserver("registerId",this);

在需要异步通知的地方调用通知方法

ObserverManager.getInstance().notify("registerId","这里可以传递任意参数");