介绍
对回调机制的再实现，有更好方法的请补充！
 
代码
 
核心类
/**
*    
*/
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