CallBack机制再实现

介绍

对回调机制的再实现，有更好方法的请补充！

 

代码

 

核心类

/**
*    
*/
package callback;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
*    This is a callback controller
* @author daniel zhou
*
*/
public class CallbackDispatcher {

  private Map _ifaceToHandler =new HashMap();
    
  private static class CallbackHandler implements InvocationHandler{
    
    private Set _listeners = new HashSet();
    private CallbackType _type;
    
    public CallbackHandler(CallbackType type){
      _type=type;
    }
    
    private void addListener(Object o){
      synchronized (_listeners) {
        _listeners.add(o);
      }
    }
    
    private void removeListener(Object o) {
                         synchronized (_listeners) {
                                 _listeners.remove(o);
                         }
         }
        
    public Object invoke(Object proxy, Method meth, Object[] methArgs) throws Throwable{
      Set listeners;
      synchronized(_listeners){
        listeners = new HashSet(_listeners);
      }
      return _type.callListeners(meth, methArgs, listeners);
    }
  }

  /**
    * register an listener
    * @param iFace
    * @param o
    */
  public void registerListener(Class iFace, Object o){
    CallbackHandler handler;
    //check registered or not
    if (!iFace.isAssignableFrom(o.getClass())) {
      throw new IllegalArgumentException("Object [" + o + "] does not " +
                                        "implement [" + iFace.getName() +
                        "]");
    }
    //try to get the callbackhandler
    synchronized(_ifaceToHandler){
      handler = (CallbackHandler) _ifaceToHandler.get(iFace);
    }
    //not register and warn
    if (handler==null) {
        throw new IllegalArgumentException("No callback for interface [" +
                                         iFace.getName() + "] exists");
    }
    //register
    handler.addListener(o);
  }

  /**
    * unregister
    * @param iFace
    * @param o
    */
  public void unregisterListener(Class iFace, Object o){
    CallbackHandler handler;
    //get the callback handler
    synchronized(_ifaceToHandler){
      handler = (CallbackHandler) _ifaceToHandler.get(iFace);
    }
    //unregister
    if (handler!=null) {
      handler.removeListener(o);
    }    
  }
    
  /**
         * Generates a caller with the callback type of    
         * {@link CallbackType.RETURN_LAST}
         *    
         * @see #generateCaller(Class, CallbackType)
         */
        public Object generateCaller(Class iFace) {
                return generateCaller(iFace, CallbackType.RETURN_LAST);
        }
        
        /**
         * Generates the 'caller' side of the caller/listener relationship.    
         *    
         * When methods on the returned object are invoked, the listeners    
         * registered via {@link #registerListener(Class, Object)} for the given
         * interface will be executed.
         *    
         * The execution of the callbacks, the order they are called, the    
         * exception handling, values returned etc. are all handled by the passed    
         * {@link CallbackType}.
         *    
         * @param iFace Interface to generate the caller for
         * @param type    Type specifying the way that the caller will process
         *                            callbacks
         *
         * @return An object implementing the passed interface.    The methods on
         *                 this object will execute callbacks on registered listeners.
         */
        public Object generateCaller(Class iFace, CallbackType type) {
                CallbackHandler newHandler;
                Object src;
                
                if (!iFace.isInterface()) {
                        throw new IllegalArgumentException("Class [" + iFace.getName() +
                                                                                             "] is not an interface");
                }
                
                newHandler = new CallbackHandler(type);
                src = Proxy.newProxyInstance(iFace.getClassLoader(),    
                                                                         new Class[] { iFace }, newHandler);
                synchronized(_ifaceToHandler) {
                        if (_ifaceToHandler.containsKey(iFace)) {
                                throw new IllegalArgumentException("Caller already generated " +
                                                                                                     " for interface [" +    
                                                                                                     iFace.getName() + "]");
                        }
                        
                        _ifaceToHandler.put(iFace, newHandler);
                }
                return src;
        }


}

 

测试类

/**
*    
*/
package schedular;

import callback.CallbackDispatcher;

/**
* @author daniel zhou
*
*/
public class Schedulaer_Test {


  /**
    * @param args
    */
  public static void main(String[] args) {
    //callbacks handler
    CallbackDispatcher    _callbacks = new CallbackDispatcher();
    //caller handler
    ShutdownCallback _caller = (ShutdownCallback) _callbacks.generateCaller(ShutdownCallback.class);    
    //new implement
    ShutdownCallback _shutdown = new ShutdownCallback(){

      @Override
      public void shutdown() {
        System.out.println("I have been called!");        
      }
        
    };
    //register
    _callbacks.registerListener(ShutdownCallback.class, _shutdown);
    
    //call    
    _caller.shutdown();
         }
}

 

Source Code Download