java dispatchevent_java事件处理机制
java中的事件機制的參與者有3種角色：
1.event object：就是事件產生時具體的“事件”，用于listener的相應的方法之中，作為參數，一般存在與listerner的方法之中
2.event source：具體的接受事件的實體，比如說，你點擊一個button，那么button就是event source，這樣你必須使button對某些事件進行相應，你就需要注冊特定的listener，比如說MouseEvent之中的MouseClicked方法，這是他就必須有了add方法
3.event listener：具體的對監聽的事件類，當有其對應的event object產生的時候，它就調用相應的方法，進行處理。在windows程序設計里邊這種相應使用callback機制來實現的
先看看jdk提供的event包：
public interface EventListener：所有事件偵聽器接口必須擴展的標記接口。
public class EventObject extends Object implements Serializable所有事件狀態對象都將從其派生的根類。 所有 Event 在構造時都引用了對象 "source"，在邏輯上認為該對象是最初發生有關 Event 的對象。
在Java2處理事件時，沒有采用dispatchEvent()-postEvent()-handleEvent()方式，采用了監聽器類，每個事件類都有相關聯的監聽器接口。事件從事件源到監聽者的傳遞是通過對目標監聽者對象的Java方法調用進行的。 ? ? ?對每個明確的事件的發生，都相應地定義一個明確的Java方法。這些方法都集中定義在事件監聽者(EventListener)接口中，這個接口要繼承 java.util.EventListener。
實現了事件監聽者接口中一些或全部方法的類就是事件監聽者。 ? ? ?伴隨著事件的發生，相應的狀態通常都封裝在事件狀態對象中，該對象必須繼承自java.util.EventObject。事件狀態對象作為單參傳遞給應響應該事件的監聽者方法中。發出某種特定事件的事件源的標識是：遵從規定的設計格式為事件監聽者定義注冊方法，并接受對指定事件監聽者接口實例的引用。 ? ?開始之前首先問個問題：您熟悉java.util.EventObject 和java.util.EventListener兩個類以及他們已有的子類嗎？
如果你已經能夠熟練使用jdk為我們提供的事件監聽器，并且很熟悉MouseEvent, KeyEvent, WindowEvent等等這些jdk為我們準備好的事件，那么想必你對java的事件機制已經有所理解。但是也許你還是覺得雖然用起來沒什么問題，但是原理還是有些糊涂，那么下面我們再進一步自己實現這些事件和監聽器，我們把這個取名為自定義事件。 ? 其實自定義事件在java中很有用處，我們有的時候想讓自己的程序產生一個事件，但有不希望(或者不可能)用鼠標，鍵盤之類的輸入設備進行操作，比如你寫一個應用程序，在這個程序中一旦收到郵件就對郵件進行相關處理，對于“收到郵件”這個事件，jdk中就沒有定義。對于這樣的事件，以及對于這樣的事件的監聽器，我們只能自己動手完成了。
其實呢，java事件處理機制就是觀察者模式，我這里詳細的整理一下，在并發編程中，動不動就給某一個主題注冊一個監聽，然后當主題狀態發生變化的時候，監聽就會被觸發。好了，廢話不多說了，我貼出幾篇代碼好了。
第一步：
/**
*
*/
package test;
/**
* @author LinkinPark
* @date 2015年8月31日 下午3:07:34
* @Description:
* 前面我已經整理了觀察者模式，這里對照這個設計模式來整理下java事件
* 這里先寫個最簡單的模擬
*/
public class Util
{
public static void main(String[] args)
{
// 首先初始化一個被觀察者，然后在初始化一個觀察者
// 然后將觀察者綁定到被觀察者上面，然后使用被觀察者看看觀察者里面的事件有沒有被觸發
Observable observable = new Observable();
Observer observer = new Observer();
observable.setObserver(observer);
observable.test();//事件被成功的觸發了
}
}
//這個模擬被觀察者
class Observable
{
//綁定到被觀察者上面的觀察者
private Observer observer;
//被觀察者對外面提供的操作
public void test()
{
observer.test();
}
public Observer getObserver()
{
return observer;
}
public void setObserver(Observer observer)
{
this.observer = observer;
}
}
// 這個模擬觀察者
class Observer
{
// 這個模擬事件
public void test()
{
System.out.println("這里就是事件。。。");
}
}
第二步：
/**
*
*/
package test;
import java.util.ArrayList;
import java.util.List;
/**
* @author LinkinPark
* @date 2015年8月31日 下午3:07:34
* @Description:
* 現在在原來的基礎上稍微復雜一點，現在不在被觀察者身上只綁一個觀察者了。
* 現在綁定多個觀察者。
*/
public class Util
{
public static void main(String[] args)
{
// 首先初始化一個被觀察者，然后在初始化2個觀察者
// 然后將觀察者綁定到被觀察者上面，然后使用被觀察者看看觀察者里面的事件有沒有被觸發
Observable observable = new Observable();
Observer observer1 = new Observer();
Observer observer2 = new Observer();
observable.registObserver(observer1);
observable.registObserver(observer2);
//調用外部事件，看看觀察者里面的事件執行了沒有
observable.notifyObserver("被觀察者觸發了操作了呢");
}
}
// 這個模擬被觀察者
class Observable
{
// 綁定到被觀察者上面的觀察者
private List observers = new ArrayList();
// 添加一個觀察者到被觀察者身上
public void registObserver(Observer observer)
{
observers.add(observer);
}
// 從綁定的觀察者集合中去掉當前這個
public void removeObserver(Observer observer)
{
observers.remove(observer);
}
// 定義外部執行
public void notifyObserver(String str)
{
for (Observer observer : observers)
{
observer.test(str);
}
}
}
// 這個模擬觀察者
class Observer
{
// 這個模擬事件
public void test(String str)
{
System.out.println("這里就是事件-->" + str);
}
}
第三步：
/**
*
*/
package test;
import java.util.ArrayList;
import java.util.List;
/**
* @author LinkinPark
* @date 2015年8月31日 下午3:07:34
* @Description:
* 現在在原來的基礎上稍微復雜一點，現在不在被觀察者身上只綁一個觀察者了。
* 現在綁定多個觀察者。現在在稍微復雜一點，觀察者和被觀察者都面向接口編程，里面提供多個實現
*/
public class Util
{
public static void main(String[] args)
{
// 首先初始化一個被觀察者，然后在初始化2個觀察者
// 然后將觀察者綁定到被觀察者上面，然后使用被觀察者看看觀察者里面的事件有沒有被觸發
Iobservable observable = new Observable();
Iobserver observer = new Observer();
Iobserver observer1 = new Observer1();
observable.registObserver(observer);
observable.registObserver(observer1);
// 調用被觀察者的外部事件，看看觀察者里面的事件執行了沒有
observable.notifyObserver("被觀察者觸發了操作了呢");
}
}
// 被觀察者對外提供的接口，其實這里定義成抽象類，也就是模板好一點。
interface Iobservable
{
// 綁定到被觀察者上面的觀察者
public List observers = new ArrayList();
// 添加一個觀察者到被觀察者身上
void registObserver(Iobserver observer);
// 從綁定的觀察者集合中去掉當前這個
void removeObserver(Iobserver observer);
// 定義外部執行
public void notifyObserver(String str);
}
// 觀察者對外提供的接口。
interface Iobserver
{
// 這個模擬事件
public void test(String str);
}
// 這個模擬被觀察者
class Observable implements Iobservable
{
public void registObserver(Iobserver observer)
{
observers.add(observer);
System.out.println("這里添加一個被觀察者-->" + observer.getClass());
}
public void removeObserver(Iobserver observer)
{
observers.remove(observer);
System.out.println("這里溢出一個被觀察者-->" + observer.getClass());
}
public void notifyObserver(String str)
{
for (Iobserver observer : observers)
{
observer.test(str);
}
}
}
// 這個模擬觀察者0
class Observer implements Iobserver
{
public void test(String str)
{
System.out.println("這里就是Observer事件-->" + str);
}
}
// 這個模擬觀察者1
class Observer1 implements Iobserver
{
public void test(String str)
{
System.out.println("這里就是Observer1事件-->" + str);
}
}
第四步：
/**
*
*/
package test;
import java.util.ArrayList;
import java.util.List;
/**
* @author LinkinPark
* @date 2015年8月31日 下午3:07:34
* @Description:
* 現在在原來的基礎上稍微復雜一點，現在不在被觀察者身上只綁一個觀察者了。
* 現在綁定多個觀察者。現在在稍微復雜一點，觀察者和被觀察者都面向接口編程，里面提供多個實現。
* 最后現在提供一個最完美的觀察者模式，其實和我前面那篇博客寫的差不多
*/
public class Util
{
public static void main(String[] args)
{
// 首先初始化一個被觀察者，然后在初始化2個觀察者
// 然后將觀察者綁定到被觀察者上面，然后使用被觀察者看看觀察者里面的事件有沒有被觸發
Iobservable observable = new Observable();
Iobserver observer = new Observer();
Iobserver observer1 = new Observer1();
observable.registObserver(observer);
observable.registObserver(observer1);
// 調用被觀察者的外部事件，看看觀察者里面的事件執行了沒有
System.out.println("===========華麗麗的分割線=============");
observable.notifyObserver("LinkinPark...");
}
}
// 被觀察者對外提供的接口，其實這里定義成抽象類，也就是模板好一點。
abstract class Iobservable
{
// 綁定到被觀察者上面的觀察者
public List observers = new ArrayList();
// 添加一個觀察者到被觀察者身上
abstract void registObserver(Iobserver observer);
// 從綁定的觀察者集合中去掉當前這個
abstract void removeObserver(Iobserver observer);
// 通知給觀察者，讓其開始做相關處理
public void notifyObserver(String str)
{
for (Iobserver observer : observers)
{
observer.test(str);
}
}
}
// 觀察者對外提供的接口。
interface Iobserver
{
// 這個模擬事件
public void test(String str);
}
// 這個模擬被觀察者
class Observable extends Iobservable
{
private String name;
public String getName()
{
return name;
}
// 在給這個被觀察者重新設值name的時候，也就說現在觀察者狀態發生改變了，那么就要通知給觀察者，讓他也來做相關的處理
public void setName(String name)
{
this.name = name;
notifyObserver(name);
}
public void registObserver(Iobserver observer)
{
observers.add(observer);
System.out.println("這里添加一個被觀察者-->" + observer.getClass());
}
public void removeObserver(Iobserver observer)
{
observers.remove(observer);
System.out.println("這里移除一個被觀察者-->" + observer.getClass());
}
}
// 這個模擬觀察者0
class Observer implements Iobserver
{
public Observer()
{
System.out.println("Observer:觀察者原來的name-->" + getName());
}
private String name = "Observer";
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public void test(String str)
{
System.out.println("Observer:原來的name-->" + getName());
setName(str);
System.out.println("被觀察者狀態改變后本地的同步name-->" + getName());
}
}
// 這個模擬觀察者1
class Observer1 implements Iobserver
{
public Observer1()
{
System.out.println("Observer1:觀察者原來的name-->" + getName());
}
private String name = "Observer1";
public String getName()
{
return name;
}
public void setName(String name)
{
this.name = name;
}
public void test(String str)
{
System.out.println("Observer1:原來的name-->" + getName());
setName(str);
System.out.println("被觀察者狀態改變后本地的同步name-->" + getName());
}
}
最后一步：java事件監聽了呢。
package test;
import java.util.ArrayList;
import java.util.EventListener;
import java.util.EventObject;
import java.util.Iterator;
import java.util.List;
/**
* @author LinkinPark
* @date 2015年9月1日 下午1:46:52
* @Description: java事件監聽機制
*/
public class Linkin
{
// 初始化主題-->被觀察者
DemoSource source = new DemoSource();
// 初始化監聽-->觀察者
DemoListener Listener1 = new Listener1();
DemoListener Listener2 = new Listener2();
public Linkin()
{
source.addDemoListener(Listener1).addDemoListener(Listener2).addDemoListener(new DemoListener()
{
@Override
public void demoEvent(DemoEvent demoEvent)
{
System.out.println("匿名內部類收到主題推送-->" + demoEvent.getSource().getClass());
}
});
System.out.println("主題原來的狀態-->" + name);
}
private String name = "nameOld";
/**
* @return the name
*/
public String getName()
{
return name;
}
/**
* @param name the name to set
*/
public void setName(String name)
{
this.name = name;
System.out.println("主題現在的狀態-->" + name);
source.notifyDemoEvent();
}
public static void main(String[] args)
{
new Linkin().setName("nameNew");
}
}
// 就是事件產生時具體的“事件”，用于listener的相應的方法之中，作為參數，一般存在與listerner的方法之中
class DemoEvent extends EventObject
{
private static final long serialVersionUID = 1L;
Object obj;
public DemoEvent(Object source)
{
super(source);
obj = source;
}
public Object getSource()
{
return obj;
}
}
// 具體的對監聽的事件類，當有其對應的event?object產生的時候，它就調用相應的方法，進行處理。
interface DemoListener extends EventListener
{
void demoEvent(DemoEvent demoEvent);
}
// 這個相當于觀察者
class Listener1 implements DemoListener
{
@Override
public void demoEvent(DemoEvent demoEvent)
{
System.out.println("Listener1監聽收到了主題的推送消息" + demoEvent.getSource());
}
}
// 這個相當于觀察者
class Listener2 implements DemoListener
{
@Override
public void demoEvent(DemoEvent demoEvent)
{
System.out.println("Listener2監聽收到了主題的推送消息" + demoEvent.getSource());
}
}
// 具體的接受事件的實體，也就是觀察者模式中的被觀察者。比如說，你點擊一個button，那么button就是event source，
// 這樣你必須使button對某些事件進行相應，你就需要注冊特定的listener，比如說MouseEvent之中的MouseClicked方法，這是他就必須有了add方法
class DemoSource
{
private List repository = new ArrayList();
DemoListener dl;
public DemoSource()
{
}
// 添加監聽
public DemoSource addDemoListener(DemoListener dl)
{
repository.add(dl);
return this;
}
// 狀態改變被觸發
public void notifyDemoEvent()
{
Iterator it = repository.iterator();
while (it.hasNext())
{
dl = (DemoListener) it.next();
dl.demoEvent(new DemoEvent(this));
}
}
}
總結
以上是生活随笔為你收集整理的java dispatchevent_java事件处理机制的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： sed mysql配置文件_shell解
- 下一篇： python读取tiff文件进行波段计算