事件委托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<params.length;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<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 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＃的委托了，这样也改掉了观察者模式的缺点，通知者类完全不知道自己需要通知的是谁，做到了完全解耦，同时也去掉了抽象的观察者类。