JavaWeb-监听器相关设计模式

监听器相关设计模式
- 观察者设计模式
- 监听器设计模式

监听器相关设计模式

在 Servlet 规范中存在三大组件：Servlet 接口、Listener 接口、Filter 接口。我们在这里要学习监听器接口 Listener。监听器是一种设计模式，是观察者设计模式的一种实现。所以我们需要先学习观察者设计模式，再学习监听器设计模式。

观察者设计模式

从现实角度来说，我们每一个人都是一个观察者，同时也是一个被观察者。作为被观察者，我们会发出一些信息，观察者在接收到这些信息后，会做出相应的反映；而作为观察者，我们是可以被“被观察者”所发出的信息影响的。一个被观察者，可能存在多个观察者。也就是说，一个被观察者所发出的信息，可能会影响到多个观察者。观察者设计模式，定义了一种一对多的关联关系。一个对象 A 与多个对象 B、C、D 之间建立“被观察与观察关系”。当对象 A 的状态发生改变时，通知所有观察者对象 B、C、D。当观察者对象 B、C、D 在接收到 A 的通知后，根据自身实际情况，做出相应改变。当然，观察者与被观察者指的都是具有某一类功能的对象，所以这里的观察者与被观察

代码实现：

// 定义观察者接口
public interface IObserver {
	// 处理被观察者发送来的信息
	void handleNotify(String message);
}

// 定义观察者两个实现类
public class FirstObserver implements IObserver{

	@Override
	public void handleNotify(String message) {
		// TODO Auto-generated method stub
		System.out.println("一号观察者接收到消息["+message+"], 正在处理消息....");
	}
}

public class SecondObserver implements IObserver{

	@Override
	public void handleNotify(String message) {
		// TODO Auto-generated method stub
		System.out.println("二号观察者接收到消息["+message+"], 正在处理消息....");
	}

}

// 定义被观察者接口
public interface IObserverable {
	// 添加观察者
	void addObserver(IObserver observer);
	// 删除观察者
	void removeObserver(IObserver observer);
	// 向观察者发送信息
	void notifyObservers(String message);
}

// 定义被观察者实现类
public class Some implements IObserverable {
	// 声明观察者集合
	private List<IObserver> observers;
	
	// 在被观察者对象创建时，将观察者集合创建
	public Some() {
		observers = new ArrayList<>();
	}
	

	@Override
	public void addObserver(IObserver observer) {
		observers.add(observer);
	}

	@Override
	public void removeObserver(IObserver observer) {
		observers.remove(observer);
	}

	@Override
	public void notifyObservers(String message) {
		// 通知每一个观察者
		for(IObserver observer : observers) {
			observer.handleNotify(message);
		}
	}
}

// 定义测试类
public class MyTest {
	public static void main(String[] args) {
		// 创建多个观察者
		IObserver firstObserver = new FirstObserver();
		IObserver secondObserver = new SecondObserver();
		
		// 创建被观察者
		Some some = new Some();
		
		// 被观察者添加观察者
		some.addObserver(firstObserver);
		some.addObserver(secondObserver);
		
		// 被观察者向所有观察者发送消息
		some.notifyObservers("hello world");
		
		// 被观察者删除一个观察者
		some.removeObserver(firstObserver);
		
		
		// 被观察再次向所有观察者发送消息
		System.out.println("------------------------");
		some.notifyObservers("hello world");
	}
}

监听器设计模式

监听器设计模式，是观察者设计模式的一种实现，它并不是 23 种设计模式之一。

这里的监听器实际对应的就是观察者，而被监听对象，则是指被观察者。当被监听对象的状态发生改变时，也需要通知监听器，监听器在收到通知后会做出相应改变。与观察者设计模式不同点：

被监听者的状态改变，被定义为了一个对象，称为事件；
被监听对象有了个新的名子，称为事件源；
对监听器的通知，称为触发监听器。

其实质与观察者设计模式是相同的。

下面以对被监听者所执行的增删改查 CURD 操作进行监听为例，来演示监听器设计模式的用法。

// 定义监听器接口
public interface IListener {
	// 处理事件
	void handle(ICurdEvent event);
}

// 定义监听器实现类
public class CrudLisntener implements IListener {

	@Override
	public void handle(ICurdEvent event) {
		String eventType = event.getEventType();
		if(ICurdEvent.CRE_EVENT.equals(eventType)) {
			System.out.println("事件源执行 添加 操作");
		} else if(ICurdEvent.DEL_EVENT.equals(eventType)) {
			System.out.println("事件源执行 删除 操作");
		} else if(ICurdEvent.UPD_EVENT.equals(eventType)) {
			System.out.println("事件源执行 更新 操作");
		} else if(ICurdEvent.RET_EVENT.equals(eventType)) {
			System.out.println("事件源执行 查询 操作");
		}
	}
}

// 定义事件接口
// 通常对于事件对象，我们需要从事件对象中获取到事件源对象的
public interface ICurdEvent {
	// 声明事件类型
	public static String CRE_EVENT = "create_event";
	public static String RET_EVENT = "retrive_event";
	public static String UPD_EVENT = "update_event";
	public static String DEL_EVENT = "delete_event";
	
	// 获取事件源对象
	public abstract IListenerable getEventSource();
	
	// 获取事件类型
	public abstract String getEventType();
}

// 定义事件实现类
public class CrudEvent implements ICurdEvent {
	private IListenerable eventSource;
	private String methodName;
	
	public CrudEvent(IListenerable eventSource, String methodName) {
		super();
		this.eventSource = eventSource;
		this.methodName = methodName;
	}

	@Override
	public IListenerable getEventSource() {
		return eventSource;
	}
	
	// 根据事件源执行的不同方法返回不同的事件类型
	@Override
	public String getEventType() {
		String eventType = null;
		if(methodName.startsWith("create")) {
			eventType = CRE_EVENT;
		} else if(methodName.startsWith("update")) {
			eventType = UPD_EVENT;
		} else if(methodName.startsWith("delete")) {
			eventType = DEL_EVENT;
		} else if(methodName.startsWith("find")) {
			eventType = RET_EVENT;
		} else {
			eventType = "not found";
		}
		
		return eventType;
	}
}

// 定义事件源接口
public interface IListenerable {
	// 为事件源注册监听器
	public abstract void setListener(IListener listener);
	
	// 触发监听器
	public abstract void triggerListener(ICurdEvent event);		
}

// 定义事件源实现类
public class Some implements IListenerable {
	private IListener listener;
	
	// 注册监听器
	@Override
	public void setListener(IListener listener) {
		this.listener = listener;
	}
	
	// 触发监听器
	@Override
	public void triggerListener(ICurdEvent event) {
		listener.handle(event);
	}
}

// 定义测试类
public class MyTest {
	public static void main(String[] args) {
		// 定义监听器
		IListener listener = new CrudLisntener();
		
		// 定义事件源
		IListenerable eventSource = new Some();
				
		// 定义事件对象
		ICurdEvent event = new CrudEvent(eventSource, "update table");
		
		// 事件源注册监听器
		eventSource.setListener(listener);
		
		// 事件源触发监听器
		eventSource.triggerListener(event);
	}
}

运行结果：
事件源执行 更新 操作

JavaWeb-监听器相关设计模式

监听器相关设计模式

观察者设计模式

监听器设计模式

Comments