java監聽
Ⅰ 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偵聽器
1、監聽器也叫Listener，是Servlet的監聽器，它可以監聽客戶端的請求、服務端的操作等。通過監聽器，可以自動激發一些操作，比如監聽在線的用戶的數量。當增加一個HttpSession時，就激發sessionCreated(HttpSessionEvent se)方法，這樣
就可以給在線人數加1。
2、常用的監聽介面有以下幾個：
1）監聽對ServletContext屬性的操作，比如增加、刪除、修改屬性。
2）、ServletContextListener監聽ServletContext。當創建ServletContext時，激發contextInitialized(ServletContextEvent sce)方法；當銷毀ServletContext時，激發contextDestroyed(ServletContextEvent sce)方法。
HttpSessionListener監聽HttpSession的操作。當創建一個Session時，激發session Created(HttpSessionEvent se)方法；當銷毀一個Session時，激發sessionDestroyed (HttpSessionEvent se)方法。
4）HttpSessionAttributeListener監聽HttpSession中的屬性的操作。當在Session增加一個屬性時，激發attributeAdded(HttpSessionBindingEvent se) 方法；當在Session刪除一個屬性時，激發attributeRemoved(HttpSessionBindingEvent se)方法；當在Session屬性被重新設置時，激發attributeReplaced(HttpSessionBindingEvent se) 方法。
3、參考樣例example:隨伺服器啟動
＜web-app＞
<listener>
<listener-class>com.tb.listener.CountStartListener</listener-class>
</listener>
package com.tb.listener;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.http.HttpServlet;
import com.tb.timertask.DoCountTask;
public class CountStartListener extends HttpServlet implements ServletContextListener
{
private static final long serialVersionUID = 1824920962239905170L;
public CountStartListener()
{
// TODO Auto-generated constructor stub
}
public void contextDestroyed(ServletContextEvent arg0)
{
// TODO Auto-generated method stub
}
public void contextInitialized(ServletContextEvent arg0)
{
DoCountTask.dotask();
Ⅲ java中的事件監聽是怎樣實現隨時監聽的，是通過線程嗎
java中的事件監聽不是通過線程實現的，它是通過一種注冊--通知機制實現的。在java的設計模式中，有一種模式叫：觀察者模式，和這個類似。
Ⅳ java監聽器原理
Java最新的事件處理方法是基於授權事件模型，事件源生成事件並將其發送至一個或多個監聽器，監聽器簡單地等待，直到它收到一個事件。一旦事件被接受，監聽器將處理這些事件，然後返回。
事件：在授權事件模型中，事件是一個描述事件源狀態改變的對象。 通過滑鼠、鍵盤與GUI界面直接或間接交互都會生成事件。如：按下一個按鈕、通過鍵盤輸入一個字元、選擇列表框中的一項、點擊一下滑鼠等。
事件源：事件源是一個生成事件的對象
一個事件源可能會生成不同類型的事件，事件源提供了一組方法，用於為事件注冊一個或多個監聽器。
每種事件的類型都有其自己的注冊方法。一般形式為：publicvoidadd<EventType>Listener(TypeListenere)
AWT採取的事件控制過程：監聽器對象屬於一個類的實例，這個類實現了一個特殊的介面，名為「監聽者介面」
事件源是一個對象，它可以注冊一個或多個監聽器對象，並向其發送事件對象。
事件源將在發生事件時向所有注冊的監聽器發送事件對象。
監聽器對象使用事件對象中的信息來確定它們對事件的響應
事件模型：
基於代理(授權)事件模型，事件處理是一個事件源授權到一個或者多個事件監聽器。其基本原理是：組件激發事件，事件監聽器監聽和處理事件，可以調用組件的add<EventType>Listener方法向組件注冊監聽器。把其加入到組件以後，如果組件激發了相應類型的事件，那麼定義在監聽器中的事件處理方法會被調用。
此模型主要由以三種對象為中心組成
事件源由它來激發產生事件
是產生或拋出事件的對象。
事件監聽器由它來處理事件
實現某個特定EventListener介面,此介面定義了一種或多種方法，事件源調用它們以響應該介面所處理的每一種特定事件類型。
事件具體的事件類型
事件類型封裝在以java.util.EventObject為根的類層次中。當事件發生時，事件記錄發生的一切事件，並從事件源傳播到監聽器對象
Ⅳ java怎樣監聽一個值是否發生了變化，具體代碼
java 自定義監聽器監聽屬性變化
import java.util.EventObject;
public class MyEvent extends EventObject
{
private Object obj;
private String sName;
public MyEvent(Object source,String sName)
{
super(source);
this.obj=source;
this.sName=sName;
}
public Object getObj()
{
return obj;
}
public String getsName()
{
return sName;
}
}
import java.util.EventListener;
public interface MyEventListener extends EventListener
{
public void handleEvent (MyEvent me);
}
import java.util.Iterator;
import java.util.Vector;
import demo.DemoEvent;
public class MyEventSource
{
private Vector list=new Vector();
private String sName = "";
public MyEventSource()
{
super();
}
public void addMyEventListener(MyEventListener me)
{
list.add(me);
}
public void deleteMyEventListener(MyEventListener me)
{
list.remove(me);
}
public void notifyMyEvent(MyEvent me)
{
Iterator it=list.iterator();
while(it.hasNext())
{
((MyEventListener) it.next()).handleEvent(me);
}
}
public void setName(String str)
{
boolean bool = false;
if (str == null && sName != null)
bool = true;
else if (str != null && sName == null)
bool = true;
else if (!sName.equals(str))
bool = true;
this.sName = str;
// 如果改變則執行事件
if (bool)
notifyMyEvent(new MyEvent(this, sName));
}
public String getsName()
{
return sName;
}
}
public class Test implements MyEventListener
{
public Test()
{
MyEventSource mes = new MyEventSource();
mes.addMyEventListener(this);
mes.setName("niu");
}
public static void main(String args[])
{
new Test();
}
public void handleEvent(MyEvent me)
{
System.out.println(me.getSource());
System.out.println(me.getsName());
}
}
Ⅵ java監聽文件Error listenerStart錯誤
最近項目中採用開啟java線程來監聽文件目錄 在本地測試正常啟動 但是當採用maven中的mvn tomcat:deploy部署到tomcat中時就報如下錯誤
嚴重: Error listenerStart : : re StandardContext start 嚴重: Context [/cms] startup failed e to previous errors
: : DEBUG (cms templet TempletController: ) – >>>>監聽停止了!! : : re StandardContext listenerStop 嚴重: Exception sending context destroyed event to listener instance of class ut il tools ThemePicFileListenerTools java lang NullPointerException陪搏蘆答祥 at util tools ThemePicFntextDestroyed(ThemePicFileLis tenerTools java: ) at re StandardContext listenerStop(StandardContext java: ) at re StandardContext stop(StandardContext java: ) at re StandardContext start(StandardContext java: ) at re ContainerBase start(ContainerBase java: )
at re StandardHost start(StandardHost java: ) at re ContainerBase start(ContainerBase java: )
at re StandardEngine start(StandardEngine java: ) at apache catalina startup Embedded start(Embedded java: ) at dehaus mojo tomcat AbstractRunMojo startContainer(AbstractRunMo jo java: )舉物 at dehaus mojo tomcat AbstractRunMojo execute(AbstractRunMojo java : ) at apache maven plugin DefaultPluginManager executeMojo(DefaultPlugi nManager java: ) at apache maven lifecycle DefaultLifecycleExecutor executeGoals(Defa ultLifecycleExecutor java: ) at apache maven lifecycle DefaultLifecycleExecutor executeStandalone Goal(DefaultLifecycleExecutor java: ) at apache maven lifecycle DefaultLifecycleExecutor executeGoal(Defau ltLifecycleExecutor java: ) at apache maven lifecycle DefaultLifecycleExecutor executeGoalAndHan dleFailures(DefaultLifecycleExecutor java: ) at apache maven lifecycle DefaultLifecycleExecutor executeTaskSegmen ts(DefaultLifecycleExecutor java: ) at apache maven lifecycle DefaultLifecycleExecutor execute(DefaultLi fecycleExecutor java: ) at apache maven DefaultMaven doExecute(DefaultMaven java: ) at apache maven DefaultMaven execute(DefaultMaven java: ) at apache maven cli MavenCli main(MavenCli java: ) at sun reflect NativeMethodAccessorImpl invoke (Native Method) at sun reflect NativeMethodAccessorImpl invoke(NativeMethodAccessorImpl java: ) at sun reflect DelegatingMethodAccessorImpl invoke(DelegatingMethodAcces sorImpl java: ) at java lang reflect Method invoke(Method java: ) at dehaus classworlds Launcher launchEnhanced(Launcher java: ) at dehaus classworlds Launcher launch(Launcher java: ) at dehaus classworlds Launcher mainWithExitCode(Launcher java: )
at dehaus classworlds Launcher main(Launcher java: )
這個錯誤讓我郁悶了好久 最後找到錯誤原因 是因為監聽的文件夾下面沒有內容 maven在發布項目的時候侯就不創建此文件夾 當程序啟動的時候 找不到此目錄 此時監聽就會停止 報以上錯誤
lishixin/Article/program/Java/hx/201311/26397
Ⅶ java 監聽器中定義參數有什麼意義，可以被調用嗎
java監聽器（Listener）和Servlet是兩個不同功能的JavaWeb組件。
監聽器是實現了javax.servlet.ServletContextListener這個介面的類，斗山豎裡面有兩個方法需要你在唯彎子類實現：
public void contextDestroyed(ServletContextEvent evt) {
//監聽器被銷毀的時候調用
}
public void contextInitialized(ServletContextEvent evt) {
//監聽啟動的時候調用，初始化servletcontext事件
}
創建好後，配置到web.xml中即可。
對於Servlet自己沒有監聽器，只有當空大用戶請求Servlet映射的路徑時會觸發Servlet對應的方法來處理，以此來響應客戶的請求。
監聽參數是用來初始化監聽上下文使用的，不能被其他入口所調用。
<!--Spring ApplicationContext載入-->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<!-- Spring ApplicationContext配置文件的路徑,此參數用於後面的Spring-Contextloader -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:beans.xml</param-value>
</context-param>
<!-- 系統服務初始化 -->
<listener>
<listener-class>pams.servlet.SysInitServlet</listener-class>
</listener>
Ⅷ 怎樣用JAVA來監聽資料庫里的變化
可以使用ContentObserver對象監聽，如下：
public final void registerContentObserver(Uri uri, boolean notifyForDescendents, ContentObserver observer)
功能：為指定的Uri注冊一個ContentObserver派生類實例，當給定的Uri發生改變時，回調該實例對象去處理。
參數：uri 需要觀察的Uri(需要在UriMatcher里注冊，否則該Uri也沒有意義了)
notifyForDescendents 為false 表示精確匹配，即只匹配該Uri
為true 表示可以同時匹配其派生的Uri，舉例如下：
假設UriMatcher 里注冊的Uri共有一下類型：
1 、content://com.qin.cb/student (學生)
2 、content://com.qin.cb/student/#
3、 content://com.qin.cb/student/schoolchild(小學生，派生的Uri)
假設我們當前需要觀察的Uri為content://com.qin.cb/student，如果發生數據變化的 Uri 為
content://com.qin.cb/student/schoolchild ，當notifyForDescendents為 false，那麼該ContentObserver會監聽不到，
但是當notifyForDescendents 為ture，能捕捉該Uri的資料庫變化。
Ⅸ java中為什麼要設置監聽器，有什麼用
豬哥解答：
1、private JButton jb=new JButton("按鈕");這句話聲明了一個按鈕，名字叫jb。
2、jb.addActionListener(this);這里給jb那個按鈕設置了監聽，默認為點擊觸發，當然棚啟你寫的這個監聽有點怪異~
3、點擊按鈕jb觸發監聽處理方法actionPerformed，在這里可以做你想要的操作，你代碼實現的是改變lab這個label標簽的內容。
4、至於java中為什野源么要用監聽，這就像銀行裝監控一樣，監視你的一舉一動，銀行裝監控是為了捕捉每個進銀行的人的動作，預防危險的發生。
java中做監聽同樣是為了監視某個客戶端動作用的，萬一你給我搞破壞怎麼辦（監聽頌和態的作用遠不止如此），當然也像平時生活中不是所有的地方都要放監控，要不就沒法過了，java中也不是所有的地方都要放監聽，具體哪裡要放監聽，不該是在課本里學的，應該根據實際工廠、公司的需求來定。
Ⅹ java監聽鍵盤
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
public class KeyBoardListener extends JFrame {
public KeyBoardListener() throws FileNotFoundException {
this.setTitle("監聽鍵盤事件");
this.setSize(800, 600);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setVisible(true);
this.addKeyListener(new KeyAdapter() {
@Override
public void keyReleased(KeyEvent e) {
char ch = e.getKeyChar();
try {
System.out.println(「結果");
} catch (IOException e1) {
JOptionPane.showMessageDialog(null, "出錯了");
}
}
});
}
public static void main(String[] args) throws FileNotFoundException {
new KeyBoardListener();
}
}