1. 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。
2. 如何用JAVA代碼監聽某個開放埠
比如我要監聽1234這個埠，代碼如下：
String ip = "127.0.0.1";
int port = 1234;
try {
Socket socket = new Socket(ip, port);
socket.setSoTimeout(5539900);
java.io.OutputStream out = socket.getOutputStream();
byte[] date = "hello world".getBytes();
out.write(data);
out.flush();
byte[] buffer = new byte[1024];
int len = -1;
java.io.FileOutputStream fout = new java.io.FileOutputStream(
"d:/response.txt");
java.io.ByteArrayOutputStream bout = new java.io.ByteArrayOutputStream();
java.io.InputStream in = socket.getInputStream();
while ((len = in.read(buffer, 0, buffer.length)) > 0) {
bout.write(buffer, 0, len);
}
in.close();
bout.flush();
bout.close();
byte[] rdata = bout.toByteArray();
System.out.println(new String(rdata));
fout.write(rdata);
fout.flush();
fout.close();
socket.close();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
伺服器端的
ServerSocket ss = new ServerSocket(1234);
Socket socket=null;
BufferedReader in;
PrintWriter out;
while (true) {
socket = ss.accept();
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new PrintWriter(socket.getOutputStream(),true);
String line = in.readLine();
out.println("you input is :" + line);
out.close();
in.close();
socket.close();
}
3. java如何實現在伺服器開一個監聽，如果客戶
1. className 此Valve 實現的Java 類名
2. debug 調試等級，0 表示不調試，而正數則表示不同程度的調試等級，數字愈高，顯示的調試信息就愈詳細。默認值是0
3. escapeQuotes 在執行請求前，決定此Valve 是否要轉義請求消息中的任何引號（包括雙及單引號）。默認值為false
4. escapeAngleBrackets 在執行請求前，決定此Valve 是否要轉義請求消息中的任何尖括弧。默認值為false
5. escapeJavaScript 決定此Valve是否要轉義請求消息中任何對JavaScript函數與對象的可能有危險的引用。默認值為false
6. allow 此Valve 允許的正則表示式清單，以逗號分隔 [可選]
7. deny 此Valve 禁止的正則表示式清單，以逗號分隔 [可選]
4. java客戶端怎麼監聽伺服器的狀態，如果伺服器關閉了，我客戶端就一直連接客戶端，直到連接到伺服器為止
客戶端連接伺服器，如果伺服器斷開會產生一個異常的。你在異常處理里把客戶端關了或者做其他處理就行了
5. 什麼是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();
6. java socket客戶端一直監聽服務端返回數據
監聽你系統通信所用的埠，有數據就獲取顯示就可以了。例如你的伺服器ip是168.12.1.16，使用的是2000埠號，Socket socket=new Socket("168.12.1.16",2000);
DataOutputStream in=new DataOutputStream(socket.getInputStream());