⑴ java设计模式-回调、事件监听器、观察者模式
转自( https://my.oschina.net/u/923324/blog/792857 )
背景
关于设计模式，之前笔者写过工厂模式，最近在使用gava ListenableFuture时发现事件监听模型特别有意思，于是就把事件监听、观察者之间比较了一番，发现这是一个非常旁春重要的设计模式，在很多框架里扮演关键的作用。
回调函数
为什么首先会讲回调函数呢？因为这个是理解监听器、观察者模式的关键。
什么是回调函数
所谓的回调，用于回调的函数。 回调函数只是一个功能片段，由用户按照回调函数调用约定来实现的一个函数。 有这么一句通俗的定义：就是程序员A写了一段程序（程序a），其中预留有回调函数接口，并封装好了该程序。程序员B要让a调用自己的程序b中的一个方法，于是，他通过a中的接口回调自己b中的方法。
举个例子：
这里有两个实体：回调抽象接口、回调者（即程序a）
回调接口（ICallBack ）
public interface ICallBack {
public void callBack();
}
回调者（用于调用回调函数的类）
public class Caller {
}
回调测试：
public static void main(String[] args) {
Caller call = new Caller();
call.call(new ICallBack(){
控制台输出：
start...
终于回调成功了！
end...
还有一种写法
或实现这个ICallBack接口类
class CallBackC implements ICallBack{
@Override
public void callBack() {
System.out.println("终于回调成功了！");
}
}
有没有发现这个模型和执行一个线程，Thread很像。 没错，Thread就是回调者，Runnable就是一个回调接口。
new Thread(new Runnable(){
@Override
public void run() {
System.out.println("回调一个新线程！");
}}).start();
Callable也是一个回调接口，原来一直在用。 接下来我们开始讲事件监听器
事件监听模式
什么是事件监听器
监听器将监听自己感兴趣的事件一旦镇启颤该事件被触发或改变，立即得到通知，做出响应。例如：android程序中的Button事件。
java的事件监听机制可概括为3点：
java的事件监听机制涉及到 事件御败源，事件监听器，事件对象 三个组件,监听器一般是接口，用来约定调用方式
当事件源对象上发生操作时，它将会调用事件监听器的一个方法，并在调用该方法时传递事件对象过去
事件监听器实现类,通常是由开发人员编写，开发人员通过事件对象拿到事件源，从而对事件源上的操作进行处理
举个例子
这里我为了方便，直接使用jdk，EventListener 监听器，感兴趣的可以去研究下源码，非常简单。
监听器接口
public interface EventListener extends java.util.EventListener {
//事件处理
public void handleEvent(EventObject event);
}
事件对象
public class EventObject extends java.util.EventObject{
private static final long serialVersionUID = 1L;
public EventObject(Object source){
super(source);
}
public void doEvent(){
System.out.println("通知一个事件源 source :"+ this.getSource());
}
}
事件源
事件源是事件对象的入口，包含监听器的注册、撤销、通知
public class EventSource {
//监听器列表，监听器的注册则加入此列表
private Vector<EventListener> ListenerList = new Vector<EventListener>();
//注册监听器
public void addListener(EventListener eventListener){
ListenerList.add(eventListener);
}
//撤销注册
public void removeListener(EventListener eventListener){
ListenerList.remove(eventListener);
}
//接受外部事件
public void notifyListenerEvents(EventObject event){
for(EventListener eventListener:ListenerList){
eventListener.handleEvent(event);
}
}
}
测试执行
public static void main(String[] args) {
EventSource eventSource = new EventSource();
}
控制台显示：
通知一个事件源 source :openWindows
通知一个事件源 source :openWindows
doOpen something...
到这里你应该非常清楚的了解，什么是事件监听器模式了吧。 那么哪里是回调接口，哪里是回调者，对！EventListener是一个回调接口类，handleEvent是一个回调函数接口，通过回调模型，EventSource 事件源便可回调具体监听器动作。
有了了解后，这里还可以做一些变动。 对特定的事件提供特定的关注方法和事件触发
public class EventSource {
...
public void onCloseWindows(EventListener eventListener){
System.out.println("关注关闭窗口事件");
ListenerList.add(eventListener);
}
}
public static void main(String[] args) {
EventSource windows = new EventSource();
/**
* 另一种实现方式
*/
//关注关闭事件，实现回调接口
windows.onCloseWindows(new EventListener(){
}
这种就类似于，我们的窗口程序，Button监听器了。我们还可以为单击、双击事件定制监听器。
观察者模式
什么是观察者模式
观察者模式其实原理和监听器是一样的，使用的关键在搞清楚什么是观察者、什么是被观察者。
观察者(Observer)相当于事件监器。有个微博模型比较好理解，A用户关注B用户，则A是B的观察者，B是一个被观察者，一旦B发表任何言论，A便可以获得。
被观察者(Observable)相当于事件源和事件，执行事件源通知逻辑时，将会回调observer的回调方法update。
举个例子
为了方便，同样我直接使用jdk自带的Observer。
一个观察者
public class WatcherDemo implements Observer {
@Override
public void update(Observable o, Object arg) {
if(arg.toString().equals("openWindows")){
System.out.println("已经打开窗口");
}
}
}
被观察者
Observable 是jdk自带的被观察者，具体可以自行看源码和之前的监听器事件源类似。
主要方法有
addObserver() 添加观察者，与监听器模式类似
notifyObservers() 通知所有观察者
类Watched.java的实现描述：被观察者，相当于事件监听的事件源和事件对象。又理解为订阅的对象 主要职责：注册/撤销观察者（监听器），接收主题对象（事件对象）传递给观察者（监听器），具体由感兴趣的观察者（监听器）执行
/**
}
测试执行
public static void main(String[] args) {
Watched watched = new Watched();
WatcherDemo watcherDemo = new WatcherDemo();
watched.addObserver(watcherDemo);
watched.addObserver(new Observer(){
@Override
public void update(Observable o, Object arg) {
if(arg.toString().equals("closeWindows")){
System.out.println("已经关闭窗口");
}
}
});
//触发打开窗口事件，通知观察者
watched.notifyObservers("openWindows");
//触发关闭窗口事件，通知观察者
watched.notifyObservers("closeWindows");
控制台输出：
已经打开窗口
已经关闭窗口
总结
从整个实现和调用过程来看，观察者和监听器模式基本一样。
有兴趣的你可以基于这个模型，实现一个简单微博加关注和取消的功能。 说到底，就是事件驱动模型，将调用者和被调用者通过一个链表、回调函数来解耦掉，相互独立。
“你别来找我，有了我会找你”。
整个设计模式的初衷也就是要做到低耦合，低依赖。
再延伸下，消息中间件是什么一个模型？ 将生产者+服务中心（事件源）和消费者（监听器）通过消息队列解耦掉. 消息这相当于具体的事件对象，只是存储在一个队列里（有消峰填谷的作用），服务中心回调消费者接口通过拉或取的模型响应。 想必基于这个模型，实现一个简单的消息中间件也是可以的。
还比如gava ListenableFuture，采用监听器模式就解决了future.get()一直阻塞等待返回结果的问题。
有兴趣的同学，可以再思考下观察者和责任链之间的关系， 我是这样看的。
同样会存在一个链表，被观察者会通知所有观察者，观察者自行处理，观察者之间互不影响。 而责任链，讲究的是击鼓传花，也就是每一个节点只需记录继任节点，由当前节点决定是否往下传。 常用于工作流，过滤器web filter。
⑵ java 鼠标左键 加 ctrl 选中是什么监听事件
事件源。
java的事件监听机制包含三个组件事件源事件监听器事件对象，当事件源上发生操作，时它将会调用事件监听器的一个方法，并且会传递一个事件对象过来，事件监听器由开发人员编写，开发人员在事件监听器中，可以拿到事件源，从而对事件源上的操作进行处理。
⑶ 简述java事件处理机制
java事件处理机制你必须得明确以下几个概念：
核心：java采用的是事件源——事件监听器模型
1：事件（event）:是指一个状态的改变，或者一个活动的发生。例如，简单常见的是单击一个按钮，或者输入一个按键都是一个事件。
2：事件源(event source)：能够产生事件的对象称为事件源，如文本框，按钮，下拉列表等。
3：事件监听器(event listener)：需要一个对象对事件源进行监听，以便对发生的事件做出处理,该对象就是事件监听器。事件源通过调用相应的方法将某个对象作为自己的监听器。无论应用程序还是小程序都采用这一机制。
例，对于按钮,注册监听器的方法是 addActionListener(监视器)；:
4： 事件源获得监听器之后，相应的操作就会导致事件的发生，并通知监听器，监听器就会做出相应的处理。
5：处理事件的接口：监听器负责处理事件源发生的事件。为了处理事件源发生的事件,监听器会自动调用一个方法来处理事件，该方法定义在相应事件的接口中。
⑷ 在java事件中。WindowEvent与WindowListener的区别是什么
Event就是事件，listener就是监听器，用于监听事件，即当发生某个事件时触发一些操作。
事件监听机制如下：
监听源比如一个按钮，调用addMouseListener，为其自身添加一个鼠标监听器，那么在该按钮上发生的相关鼠标事件比如鼠标按下，松开等将通知到该监听器，同时回调该监听器的相应方法。UI程序也是通过这样的方式来处理这些界面事件的。
同样的道理，WindowEvent和WindowListener你应该可以明白是做什么的了，就是窗口事件和窗口事件的监听器。窗口事件就比如窗口最大化最小化之类。
⑸ java的listener是什么原理
回调，
Java的事件监听机制是这样的:
事件的观察者向事件的发出者进行注册，当事件发生时，事件的发出者调用之前注册的洞禅回调函数，将相关事件信息通知到事件的观察者。这个过程中，当然不用事件的观察者进行轮询。
你可能有个问题：那么事件的发出者如何得知事件发生呢？实际上举个例子来说如窗口类，有个窗口关闭事件可以注册，作为窗口类来说内部有相关关闭窗口的方法，只要这些方法被调用，当然就知道窗口被关闭了，只要这些方法在合适的时机调用回调函数即可。
事件的观察者可以没有，有一个或多个，只要再事件的发出者内部维护一个List<XxxListener>即可，到时候迭代列表依次发出事件即可。（这里一般不设计为多线程，而是单线程依次发送，所以事件处理函数最好不要阻塞太长时间，否则会影响到下一个观察者，甚至事件发出方代码的调用）
Java 事件处理方法是基于授权事件模型
事件源生成事件并将其发送至一个或多个监听器
监听器简单地等待，直到它收到一个事件。一旦事件被接受，监听器将处理这些事件，然后返回。
事件：在授权事件模型中，事件是一个描述事件源状态改变的对象 。
通过鼠标、键盘与 GUI 界面直接或间接交互都会生成事件。 如：按下一个按钮、通过键盘输入一个字符、选择列表框中的一项、点击一下鼠标等。
事件源键键：事件源是一个生成事件的对象
一个事件源可能会生成不同类型的事件
事件源提供了一组方法，用于为事件注册一个或多个监听器。
每种事件的类型都有其自己的注册方法。一般形式为：
public void add<EventType>Listener (TypeListener e)
AWT采取的事件控制过程：监听器对象属于一个类的实例，这个类实现了一个特殊的接口，名为“监听者接口”
事件源是一个对象，它可以注册一个或多个监听器对象，并向其发送事件对象。
事件源将在发生事件时向所有注册的监听器发送事件对象。
监听器对象使用事件对象中的信息来确定它们纳亮尘对事件的响应
事件模型：
1.基于代理(授权)事件模型
事件处理是一个事件源授权到一个或者多个事件监听器。其基本原理是：组件激发事件，事件监听器监听和处理事件，可以调用组件的add<EventType>Listener方法向组件注册监听器。把其加入到组件以后，如果组件激发了相应类型的事件，那么定义在监听器中的事件处理方法会被调用。
2.此模型主要由以三种对象为中心组成
事件源 由它来激发产生事件
是产生或抛出事件的对象。
事件监听器 由它来处理事件
实现某个特定EventListener 接口,此接口定义了一种或多种方法，事件源调用它们以响应该接口所处理的每一种特定事件类型 。
事件 具体的事件类型
事件类型封装在以java.util.EventObject为根的类层次中。当事件发生时，事件记录发生的一切事件，并从事件源传播到监听器对象
⑹ java中的事件监听是怎样实现随时监听的，是通过线程吗
java中的事件监听不是通过线程实现的，它是通过一种注册--通知机制实现的。在专java的设计模式中，有一种模属式叫：观察者模式，和这个类似。
⑺ 浅析Java与C#的事件处理机制（一）
Java与C#的事件处理都是实现了事件源 事件响应者机制 但又不完全相同 Java实现的是一种事件源与事件响应者两级实体对象方式 这里的事件响应者也是事件监听者 而C#实现的是一种事件源 代理 事件响应者三级实体对象方式 下面就这两种方式来具体说明
Java事件处理
从概念上讲 事件是一种在 源对象 和 监听者对象 之间 某种状态发生变化的传递机制 事件有许多不同的用途 例如在Windows系统中常要处理的鼠标事件 窗口边界改变事件 键盘事件等 在Java中则是定义了一个普通的 可扩充的事件机制 这种机制能够
对事件类型和传递的模型的定义和扩充提供一个公共框架 并适合于广泛的应用
与Java语言和环境有较高的集成度
事件能被描述环境捕获和触发
能使其它构造工具采取某种技术在设计时直接控制事件 以及事件源和事件监听者之间的联系
事件机制本身不依赖于复杂的开发工具
事件从事件源到监听者的传递是通过对目标监听者对象的Java方法调用进行的 对每个明确的事件的发生 都相应地定义一个明确的Java方法 这些方法都集中定义在事件监听者（EventListener）接口中 这个接口要继承java util EventListener 实现了事件监听者接口中一些或全部方法的类就是事件监听者 伴随着事件的发生 相应的状态通常都封装在事件状态对象中 该对象必须继承自java util EventObject 事件状态对象作为单参传递给应响应该事件的监听者方法中 发出某种特定事件的事件源的标识是 遵从规定的设计格式为事件监听者定义注册方法 并接受对指定事件监听者接口实例的引用 有时 事件监听者不能直接实现事件监听者接口 或者还有其它的额外动作时 就要在一个源与其它一个或多个监听者之间插入一个事件适配器类的实例 来建立它们之间的联系
事件状态对象（Event State Object）
与事件发生有关的状态信息一般都封装在一个事件状态对象中 这种对象是java util EventObject的子类 按设计习惯 这种事件状态对象类的名应以Event结尾 例如
public class MouseMovedExampleEvent extends java util EventObject{ protected int x y /*创建一个鼠标移动事件MouseMovedExampleEvent */MouseMovedExampleEvent(java awt Component source Point location) {super(source);x = location x;嫌银携y = location y;}/* 获取鼠标位置*/public Point getLocation() {return new Point(x y);}}
事件监听者接口（芹伏EventListener Interface）与事件监听者
由于Java事件模型是基于方法调用 因而需要一个定义并组织事件操纵方法的方式 事件操纵方法都被定义在继承了java util EventListener类的EventListener接口中 按规定 EventListener接口的命名要以Listener结尾 任何一个类如果想操纵在EventListener接口中定义的方法都必须以实现这个接口方式进行 这个类也就是事件监听者 例如
搏岁/*先定义了一个鼠标移动事件对象*/public class MouseMovedExampleEvent extends java util EventObject {// 在此类中包含了与鼠标移动事件有关的状态信息 }/*定义了鼠标移动事件的监听者接口*/interface MouseMovedExampleListener extends java util EventListener {/*在这个接口中定义了鼠标移动事件监听者所应支持的方法*/void mouseMoved(MouseMovedExampleEvent mme);}
在接口中只定义方法名 方法的参数和返回值类型 如 上面接口中的mouseMoved方法的具体实现是在下面的ArbitraryObject类中定义的
class ArbitraryObject implements MouseMovedExampleListener {public void mouseMoved(MouseMovedExampleEvent mme){ }}
ArbitraryObject就是MouseMovedExampleEvent事件的监听者
事件监听者的注册与注销
为了各种可能的事件监听者把自己注册入合适的事件源中 建立源与事件监听者间的事件流 事件源必须为事件监听者提供注册和注销的方法 在前面的bound属性介绍中已看到了这种使用过程 在实际中 事件监听者的注册和注销要使用标准的设计格式
public void add< ListenerType>(< ListenerType> listener) public void remove< ListenerType>(< ListenerType> listener)
首先定义了一个事件监听者接口
public interface ModelChangedListener extends java util EventListener {void modelChanged(EventObject e);}
接着定义事件源类
lishixin/Article/program/net/201311/14840
⑻ java监听器原理
Java最新的事件处理方法是基于授权事件模型，事件源生成事件并将其发送至一个或多个监听器，监听器简单地等待，直到它收到一个事件。一旦事件被接受，监听器将处理这些事件，然后返回。
事件：在授权事件模型中，事件是一个描述事件源状态改变的对象。 通过鼠标、键盘与GUI界面直接或间接交互都会生成事件。如：按下一个按钮、通过键盘输入一个字符、选择列表框中的一项、点击一下鼠标等。
事件源：事件源是一个生成事件的对象
一个事件源可能会生成不同类型的事件，事件源提供了一组方法，用于为事件注册一个或多个监听器。
每种事件的类型都有其自己的注册方法。一般形式为：publicvoidadd<EventType>Listener(TypeListenere)
AWT采取的事件控制过程：监听器对象属于一个类的实例，这个类实现了一个特殊的接口，名为“监听者接口”
事件源是一个对象，它可以注册一个或多个监听器对象，并向其发送事件对象。
事件源将在发生事件时向所有注册的监听器发送事件对象。
监听器对象使用事件对象中的信息来确定它们对事件的响应
事件模型：
基于代理(授权)事件模型，事件处理是一个事件源授权到一个或者多个事件监听器。其基本原理是：组件激发事件，事件监听器监听和处理事件，可以调用组件的add<EventType>Listener方法向组件注册监听器。把其加入到组件以后，如果组件激发了相应类型的事件，那么定义在监听器中的事件处理方法会被调用。
此模型主要由以三种对象为中心组成
事件源由它来激发产生事件
是产生或抛出事件的对象。
事件监听器由它来处理事件
实现某个特定EventListener接口,此接口定义了一种或多种方法，事件源调用它们以响应该接口所处理的每一种特定事件类型。
事件具体的事件类型
事件类型封装在以java.util.EventObject为根的类层次中。当事件发生时，事件记录发生的一切事件，并从事件源传播到监听器对象
⑼ java 自定义事件的触发及监听
JAVA事件响应机制
1，先自定义一个事件
public class MyEvent extends java.util.EventObject{
public MyEvent(Object source)
{
super(source);
}
}
2，再自定义一个监听器
public class MyListener implements java.util.EventListener{
//这里是当事件发生后的响应过程
public void EventActivated(MyEvent me)
{
System.out.println("事件已经被触发");
}
}
3，以下这个类为触发事件的事件源
public class MyObject {
private Vector vectorListeners=new Vector();
public synchronized void addMyListener(MyListener ml)
{
vectorListeners.addElement(ml);
}
public synchronized void removeMyListener(MyListener ml)
{
vectorListeners.removeElement(ml);
}
protected void activateMyEvent()
{
Vector tempVector=null;
MyEvent e=new MyEvent(this);
synchronized(this)
{
tempVector=(Vector)vectorListeners.clone();
for(int i=0;i<tempVector.size();i++)
{
MyListener ml=(MyListener)tempVector.elementAt(i);
ml.EventActivated(e);
}
}
}
//定义一个公用方法用于触发事件
public void test()
{
activateMyEvent();
}
}
4，测试类
public class Test {
public static void main(String[] args)
{
MyObject mo=new MyObject();
//注册该事件
mo.addMyListener(new MyListener());
//触发该事件
mo.test();
}
}