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();
}
}
java中委托事件的模型（Delegated Event Model）
六类uml关系
http://www.open-open.com/lib/view/open1328059700311.html
在idea自带的diagram中组合和聚合都是一样的实心箭头，但是多了个create的虚线，
其实标准的来讲组合应该是实心箭头，聚合应该是虚心箭头。
参考
[1]：http://hbohuan.blog.163.com/blog/static/208489820077132225530/
[2]：java语言实现事件委托模式 http://blog.csdn.net/yanshujun/article/details/6494447
