java里的回调与事件委托

1、java里的回调是什么？

这里讲解的很详细，http://blog.csdn.net/veryitman/article/details/6937468

就是A类中调用B类中的某个方法c，然后B类中c反过来调用A类中的方法d，d这个方法就叫回调方法。

其实strategy**、template**、observer**、visitor**模式全部都是回调的不同应用。简单来说就是本来可以写死在一起的代码给拆开来，让其中一块保持原有的流程，并在流程中挖出一些空，让另一块代码作为参数传进来在流程中合适的地方被调用，也就是UML里所说的聚合。

2、委托到底是什么？

java中没有委托，但是java中有个委托事件的模型。

参考 http://blog.csdn.net/yanshujun/article/details/6494447

1.1、观察者模式与事件委托对比

可以参考博文：http://blog.csdn.net/gdutxiaoxu/article/details/51824769

1.2、事件委托

看个例子,我们先来看一下我们的通知者GoodNotifier是怎样实现的？

public class GoodNotifier extends Notifier {   

    @Override  
    public void addListener(Object object, String methodName, Object... args) {   
        System.out.println("有新的同学委托尽职尽责的放哨人!");   
        EventHandler handler = this.getEventHandler();
        handler.addEvent(object, methodName, args);   
    }   

    @Override  
    public void notifyX() {   
        System.out.println("尽职尽责的放哨人告诉所有需要帮忙的同学：老师来了");   
        try{   
            this.getEventHandler().notifyX();   
        }catch(Exception e){   
            e.printStackTrace();   
        }   
    }   

}

接着我们在来看它的父类Notifier是怎样实现的

  /**
   * 通知者的 抽象类
   */
  public abstract class Notifier {
      private EventHandler eventHandler = new EventHandler();
      public EventHandler getEventHandler() {
          return eventHandler;
      }
      public void setEventHandler(EventHandler eventHandler) {
          this.eventHandler = eventHandler;
      }
      /**
       * 增加需要帮忙 放哨 的 学生
       * 
       * @param object 要执行方法的对象
       * @param methodName 执行方法 的方法名
       * @param args   执行方法的参数
       */
      public abstract void addListener(Object object, String methodName, Object... args);
      /**
       * 告诉所有要帮忙放哨的学生：老师来了
       */
      public abstract void notifyX();
  }

看了上面notifier的代码以后，你是不是有一种似曾相识的感觉，是不是感觉跟我们的观察者模式中的通知者很相似

观察者模式我们的通知者是这样实现的

@Override
    public void notifyAllObserver(Object data) {
        for (Observer observer : mList) {
            observer.update(this,data);
        }

    }

在事件委托中我们是这样实现的

   @Override  
      public void notifyX() {   
          System.out.println("尽职尽责的放哨人告诉所有需要帮忙的同学：老师来了");   
          try{   
              EventHandler handler = this.getEventHandler();
              handler.notifyX();   
          }catch(Exception e){   
              e.printStackTrace();   
          }   
      }

两者的区别其实即使我们将其交给EventHandler去处理

下面我们来看一下EventHandler我们是怎样实现的

  /**
   * 事件的 处理者
   */
  public class EventHandler {   
      //是用一个List   
      private List<Event> objects;   
      public EventHandler(){   
          objects=new ArrayList<Event>();   
      }   
      //添加某个对象要执行的事件，及需要的参数   
      public void addEvent(Object object,String methodName,Object...args){   
          objects.add(new Event(object,methodName,args));   
      }   
      //通知所有的对象执行指定的事件   
      public void notifyX() throws Exception{   
          for(Event e : objects){   
              e.invoke();   
          }   
      }   
  }

其实跟观察者模式一样，我们把我们的事件对象存储在

  objects=new ArrayList<Event>();

当我们添加事件的时候，把事件封装为Event对象，再添加到objects中

  objects.add(new Event(object,methodName,args));

当我们要通知事件的时候，再遍历List，通知每一个事件对象

  for(Event e : objects){   
       e.invoke();   
  }

看到invoke()这个方法，你是不是想到了什么，没错，就是java的反射机制，我们封装在Event类中，下面我们来看一下Event类是怎样实现的

  /**
   * 事件对象的封装类
   */
  public class Event {   
      //要执行方法的对象   
      private Object object;   
      //要执行的方法名称   
      private String methodName;   
      //要执行方法的参数   
      private Object[] params;   
      //要执行方法的参数类型   
      private Class[] paramTypes;   
      public Event(){}   
      public Event(Object object,String methodName,Object...args){   
          this.object=object;   
          this.methodName=methodName;   
          this.params=args;   
          contractParamTypes(this.params);   
      }   
      //根据参数数组生成参数类型数组   
      private void contractParamTypes(Object[] params){   
          this.paramTypes=new Class[params.length];   
          for(int i=0;i<params.length;i++){   
              this.paramTypes[i]=params[i].getClass();   
          }   
      }   


      public Object getObject() {
          return object;
      }

    //这里省略了若干get和set方法

      /**
       * 根据该对象的方法名，方法参数，利用反射机制，执行该方法  
       * @throws Exception
       */
      public void invoke() throws Exception{   
          Method method=object.getClass().getMethod(this.getMethodName(),
                           this.getParamTypes());   
          if(null==method){   
              return;   
          }   
          method.invoke(this.getObject(), this.getParams());   
      }   
  }

在Event类我们invoke()方法所做的工作就是根据我们的对象的方法名，方法参数，利用发射执行方法

运行一下测试代码

  //创建一个尽职尽责的放哨者   
  Notifier goodNotifier=new GoodNotifier();   
  //创建一个玩游戏的同学，开始玩游戏   
  WatchCartoonListener playingGameListener=new WatchCartoonListener();  
  //创建一个看电视的同学，开始看电视   
  WatchingNBAListener watchingTVListener=new WatchingNBAListener();   
  //玩游戏的同学告诉放哨的同学，老师来了告诉一下   
  goodNotifier.addListener(playingGameListener, "stopPlayingGame",new Date());   
  //看电视的同学告诉放哨的同学，老师来了告诉一下   
  goodNotifier.addListener(watchingTVListener, "stopWatchingTV",new Date());   
  try{   
       //一点时间后   
       Thread.sleep(1000);   
      }catch(Exception e){   
        e.printStackTrace();   
      }   
  //老师出现，放哨的人通知所有要帮忙的同学:老师来了   
  goodNotifier.notifyX();

结果如下

WatchCartoonListener 我正在看漫画，开始时间：Mon Jul 04 13:25:34 CST 2016

WatchingNBAListener我正在看NBA,开始时间是： Mon Jul 04 13:25:34 CST 2016

有新的同学委托尽职尽责的放哨人!

有新的同学委托尽职尽责的放哨人!

尽职尽责的放哨人告诉所有需要帮忙的同学：老师来了

WatchCartoonListener 老师来了，不要看漫画了，结束时间：Mon Jul 04 13:25:34 CST 2016

WatchingNBAListener老师来了，快关闭NBA直播 ， 结束时间是：Mon Jul 04 13:25:34 CST 2016

1.3、委托能解决什么问题？（好处）

这里，通知者类完全不知道自己需要通知的是谁，做到了完全解耦(1)，同时也去掉了抽象的观察者类(2)。观察者模式的缺点是抽象通知者依赖抽象观察者，.NET中用委托技术处理这个问题，事件委托扩展性好(3)

即：

1.  放哨者完全不知道做游戏者的存在，完全解耦。（当然，功劳归功于Event和EventHandler，且这两个类具有通用性）
2.  老师来了后游戏者停止游戏回到座位，看NBA者停止看NBA，看漫画这停止看漫画，玩游戏这停止玩游戏。（一次通知，执行了不同类的不同方法）
3.  扩展性很高，再来一个打篮球的学生就先写个打篮球学生类，并在测试代码中告诉放哨者一下就好，放哨者完全没有变。重用性好

3、代理模式(Proxy Pattern)

可以翻译成代理模式，也可以翻译成委托模式。

java中实现代理：

// 抽象角色：
abstract class Subject {
    abstract public void request();
}
// 真实角色：实现了Subject的request()方法
class RealSubject extends Subject {
    public RealSubject() {}
    public void request() {
        System.out.println(" From real subject. ");
    }
}
// 代理角色：
class ProxySubject extends Subject {
    // 以真实角色作为代理角色的属性
    private Subject realSubject;
    public ProxySubject(Subject realSubject) {
        this.realSubject = realSubject;
    }
    // 该方法封装了真实对象的request方法
    public void request() {
        //preRequest();
        System.out.println("代理准备...");
        // 此处执行真实对象的request方法
        realSubject.request();
        //postRequest();
        System.out.println("代理结束...");
    }
}
public class Client {
    public static void main(String[] args) {
        RealSubject real = new RealSubject();
        Subject sub = new  ProxySubject(real);
        sub.request();
    }
}

以下是java中实现动态代理的方式

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
// 抽象角色
interface Subject {
    void request();
}
// 具体角色RealSubject：
class RealSubject implements Subject {
    public RealSubject() {}
    public void request() {
        System.out.println(" From real subject. ");
    }
}
//动态代理对象
class DynamicSubject implements InvocationHandler {
    private Object sub;
    public DynamicSubject() {}
    public DynamicSubject(Object obj) { sub = obj; }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(" before calling " + method);
        Object invoke = method.invoke(sub, args);
        System.out.println(" after calling " + method);
        return invoke;
    }
}
public class Client {
    static public void main(String[] args) throws Throwable {
        RealSubject rs = new RealSubject(); // 在这里指定被代理类
        InvocationHandler ds = new DynamicSubject(rs);
        Class cls = rs.getClass();
       Subject subject = (Subject) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), ds);

        subject.request();
    }
}