观察者模式

package com.zkk.functions;

public interface Function<Result,Param> {
	Result function(Param... params);
}

</pre><pre code_snippet_id="1936299" snippet_file_name="blog_20161018_3_61644" name="code" class="java"><pre name="code" class="java">package com.zkk.observable;

import java.util.Set;

public interface ObservableIterface<T,P,R> {
	/**
	 * 根据名称注册观察者
	 * @param name
	 * @param observer
	 */
	void registerObserver(String name,T observer);
	/**
	 * 根据名称反注册观察者
	 * @param name
	 */
	void removeObserver(String name);
	/**
	 * 根据观察者反注册
	 * @param observer
	 */
	void removeObserver(T observer);
	/**
	 * 根据名称和观察者反注册
	 * 
	 */
	void removeObserver(String name,T observer);
	
	/**
	 * 根据名称获取观察者
	 * @param name
	 * @return
	 */
	Set<T> getObserver(String name);
	/**
	 * 清除观察者
	 */
	void clear();
	
	/**
	 * 通知观察者
	 * @param name
	 * @param p
	 * @return
	 */
	R notify(String name,P... p);
	
	
}

package com.kira.com.utils;

import com.kira.com.listener.Function;
import com.kira.com.listener.ObservableIterface;

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

/**
 * Created by Administrator on 2016/11/22 0022.
 */

public class ObservableManager<Param,Result>
        implements ObservableIterface<Function, Param, Result> {
    private static final String TAG = "zhouke";
    private HashMap<String,Set<Function>> _mapping;
    private final Object _lockObj = new Object();
    private static ObservableManager _instance;
    public ObservableManager(){
        this._mapping = new HashMap<String,Set<Function>>();
    }
    public static synchronized ObservableManager newInstance(){
        if(_instance == null){
            _instance = new ObservableManager();
        }
        return _instance;
    }

    @Override
    public void registerObserver(String name, Function observer) {
        synchronized (_lockObj) {
            Set<Function> observers;
            if(!_mapping.containsKey(name)){
                observers = new HashSet<>();
                _mapping.put(name, observers);
            }else{
                observers = _mapping.get(name);
            }
            observers.add(observer);
        }

    }

    @Override
    public void removeObserver(String name) {
        synchronized(_lockObj){
            _mapping.remove(name);
        }
    }


    @Override
    public void removeObserver(Function observer) {
        synchronized(_lockObj){
            for (String key : _mapping.keySet()) {
                Set<Function> observers= _mapping.get(key);
                observers.remove(observer);
            }
        }
    }

    @Override
    public void removeObserver(String name, Function observer) {
        synchronized (_lockObj) {
            if(_mapping.containsKey(name)){
                Set<Function> observers = _mapping.get(name);
                observers.remove(observer);
                _mapping.remove(name);
            }
        }
    }

    @Override
    public Set<Function> getObserver(String name) {
        Set<Function> observers = null;
        synchronized(_lockObj){
            if(_mapping.containsKey(name)){
                observers = _mapping.get(name);
            }
        }
        return observers;
    }

    @Override
    public void clear() {
        synchronized(_lockObj){
            _mapping.clear();
        }
    }

    @Override
    public Result notify(String name, Param... p) {
        synchronized (_lockObj) {
            if(_mapping.containsKey(name)){
                Set<Function> observers = _mapping.get(name);
                for(Function o: observers){
                    return (Result)o.function(p);
                }
            }
        }

        return null;
    }
    public boolean isConstain(String key){
        synchronized (_lockObj) {
            if(_mapping!=null){
                return  _mapping.containsKey(key);
            }
        }
        return false;
    }
}

可以用于activity与fragment 通信