java事件委托机制实现_java实现事件委托

事件委托

委托就像是拿另一种方法替代了原本的方法，交给现在这个替代后的方法使用，使用时和原来的方法没有区别。

在c＃里面语法中就有委托这个概念，所以实现起来十分的方便，可是在java中没有，就只能自己用发射的一些机制来实现了。

在java中实现委托，首先需要定义一个事件类，里面包含了调用的对象，调用的方法名，方法所需参数，和参数的类型

package com.suski.delegate;

import java.lang.reflect.Method;

public class Event {

private Object object;

private String methodName;

private Object[] params;

private Class[] paramTypes;

public Event(Object object,String method,Object...args)

{

this.object = object;

this.methodName = method;

this.params = args;

contractParamTypes(this.params);

}

private void contractParamTypes(Object[] params)

{

this.paramTypes = new Class[params.length];

for (int i=0;i

{

this.paramTypes[i] = params[i].getClass();

}

}

public void invoke() throws Exception

{

Method method = object.getClass().getMethod(this.methodName, this.paramTypes);//判断是否存在这个函数

if (null == method)

{

return;

}

method.invoke(this.object, this.params);//利用反射机制调用函数

}

}

事件类定义完成了，就可以使用委托了，把调用方法的对象，方法名，和参数传进来就好了。

弥补观察者模式缺点

如果想做到昨天观察者模式实现的效果(一个类改变通知好几个类)，那么就还需要定义一个事件管理队列的类

package com.suski.delegate;

import java.util.ArrayList;

import java.util.List;

public class EventHandler {

private List objects;

public EventHandler()

{

objects = new ArrayList();

}

public void addEvent(Object object, String methodName, Object...args)

{

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

}

public void notifyX() throws Exception

{

for (Event event : objects)

{

event.invoke();

}

}

}

这个类就是把事件都放入一个List中，到时候在一次取出来

队列定义完了，那么就可以定义通知的抽象类了

package com.suski.delegate;

public abstract class Notifier {

private EventHandler eventHandler = new EventHandler();

public EventHandler getEventHandler()

{

return eventHandler;

}

public void setEventHandler(EventHandler eventHandler)

{

this.eventHandler = eventHandler;

}

public abstract void addListener(Object object,String methodName, Object...args);

public abstract void notifyX();

}

再定义具体的实现类

package com.suski.delegate;

public class ConcreteNotifier extends Notifier{

@Override

public void addListener(Object object, String methodName, Object... args) {

this.getEventHandler().addEvent(object, methodName, args);

}

@Override

public void notifyX() {

try {

this.getEventHandler().notifyX();

} catch (Exception e) {

// TODO: handle exception

e.printStackTrace();

}

}

}

这时再定义需要通知的对象类就可以了

package com.suski.delegate;

import java.util.Date;

public class WatchingTVListener {

public WatchingTVListener()

{

System.out.println("watching TV");

}

public void stopWatchingTV(Date date)

{

System.out.println("stop watching" + date);

}

}

package com.suski.delegate;

import java.util.Date;

public class PlayingGameListener {

public PlayingGameListener()

{

System.out.println("playing");

}

public void stopPlayingGame(Date date)

{

System.out.println("stop playing" + date);

}

}

测试的方法

package com.suski.delegate;

import java.util.Date;

public class Test {

public static void main (String[] args)

{

Notifier goodNotifier = new ConcreteNotifier();

PlayingGameListener playingGameListener = new PlayingGameListener();

WatchingTVListener watchingTVListener = new WatchingTVListener();

goodNotifier.addListener(playingGameListener, "stopPlayingGame", new Date());

goodNotifier.addListener(watchingTVListener, "stopWatchingTV", new Date());

goodNotifier.notifyX();

}

}

这样就相当于c＃的委托了，这样也改掉了观察者模式的缺点，通知者类完全不知道自己需要通知的是谁，做到了完全解耦，同时也去掉了抽象的观察者类。

昨天完全不明白java委托要怎么做，后来终于找到了一个，感觉这个还不错，就写出来和大家分享一下。