設計模式-6-事件驅動模型

簡介：觀察者模式的另一種形態，觀察者相當於監聽器，被觀察者相當於事件源

目的：事件源產生事件，監聽器監聽事件

總結：事件發生-事件處理模型

 

組成：監聽器，事件源，事件源管理器

1，基礎類

package com.design.f.observer.event.writer;

import java.io.Serializable;
/**
 * 用戶
 */
public class User implements Serializable{
    
    private static final long serialVersionUID = 158957714520271405L;
    private String userName;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    @Override
    public String toString() {
        return super.toString();
    }
    
}

2，監聽器

package com.design.f.observer.event.writer;

import java.util.EventListener;
/**
 * 監聽器接口
 */
public interface WriterListener extends EventListener{

    /**
     * 監聽的動作
     * @param writerEvent
     */
    void addNovel(WriterEvent writerEvent);
}

 

package com.design.f.observer.event.writer;

/**
 * 監聽器
 * 
 * 相當於觀察者
 */
public class Reader implements WriterListener {
    
    //讀者用戶信息
    private User user;
    
    public Reader(String userName){
        user = new User();
        user.setUserName(userName);
    }

    @Override
    public void addNovel(WriterEvent writerEvent) {
        System.out.println("監聽器 ：" + user.getUserName() + ";  收到事件源 : " + writerEvent.getWriter().getUser().getUserName() + 
                ", 發布了 -->" +writerEvent.getWriter().getLastBook());
    }
    
    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }

}

3，事件源

package com.design.f.observer.event.writer;

import java.util.EventObject;
/**
 * 事件源
 */
public class WriterEvent extends EventObject {

    private static final long serialVersionUID = -2594824149603017741L;

    /**
     * 初始化事件源
     * @param writer
     */
    public WriterEvent(Writer writer) {
        super(writer);
    }
    
    /**
     * 獲取事件源
     * @return
     */
    public Writer getWriter(){
        return (Writer) super.source;
    }

    
}

 

package com.design.f.observer.event.writer;

import java.util.HashSet;
import java.util.Set;
/**
 * 事件源
 * 
 * 相當於被觀察者
 */
public class Writer {

    //作者用戶信息
    private User user;
    //作者新書
    private String lastBook;
    //監聽器列表
    Set<WriterListener> writerListenerList = new HashSet<>();
    
    public Writer(String userName){
        super();
        //初始化用戶信息
        user = new User();
        user.setUserName(userName);
        
        //將作者添加到作者管理器中
        WriterManager.getInstance().addWriter(this);
    }
    
    //作者發布新書動作
    public void pushBook(String bookName){
        System.out.println("事件源 : " + user.getUserName() + ";   發布了新書: " + bookName + " ... ... ");
        lastBook = bookName;
        
        //設置被觀察發生改變的狀態,並通知所有監聽器
        triggerEvent();
    }
    
    //觸發事件通知所有監聽器
    private void triggerEvent(){
        WriterEvent writerEvent = new WriterEvent(this);
        for(WriterListener writerListener : writerListenerList){
            writerListener.addNovel(writerEvent);
        }
    }
    
    //監聽器的添加
    public void addWriterListener(WriterListener writerListener){
        writerListenerList.add(writerListener);
    }
    
    //監聽器的取消
    public void removeWriterListener(WriterListener writerListener){
        writerListenerList.remove(writerListener);
    }
    
    public String getLastBook() {
        return lastBook;
    }
    public void setLastBook(String lastBook) {
        this.lastBook = lastBook;
    }
    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
    
}

4，事件源控制器

package com.design.f.observer.event.writer;

import java.util.HashMap;
import java.util.Map;

/**
 * 觀察者管理器 
 */
public class WriterManager {
    
    //1-作者集合
    private Map<String, Writer> writerMap = new HashMap<String, Writer>();
    
    //2-添加作者
    public void addWriter(Writer writer){
        writerMap.put(writer.getUser().getUserName(), writer);
    }
    
    //3-刪除作者
    public void removeWriter(Writer writer){
        writerMap.remove(writer.getUser().getUserName());
    }
    
    //4-獲取作者
    public Writer getWriter(String writerName){
        return writerMap.get(writerName);
    }
    
    //5-作者是否存在
    public Boolean isWriter(String writerName){
        return writerMap.containsKey(writerName);
    }
    
    //獲取作者集合單例
    private WriterManager(){}
    public static WriterManager getInstance(){
        return WriterManagerInstance.writerManager;
    }
    private static class WriterManagerInstance{
        static WriterManager writerManager = new WriterManager();
    }
    

    public Map<String, Writer> getWriterMap() {
        return writerMap;
    }
    public void setWriterMap(Map<String, Writer> writerMap) {
        this.writerMap = writerMap;
    }

}

5，Main

package com.design.f.observer.event.writer;

/**
 * 觀察者模式-事件驅動模型
 * 觀察者更多的強調的是發布-訂閱式的問題處理,而事件驅動則更多的注重於界面與數據模型之間的問題
 * 被觀察者 = 事件源
 * 觀察者     = 監聽器
 * 
 * 用例：Tomcat的啟動用到的listener監聽器，Spring啟動添加監聽器隨着Tomcat的啟動IOC容器也開始啟動
 */
public class MainTest {
    
    public static void main(String[] args) {
        
        /**
         * 事件驅動模型-(JDK)
         */
        //1-創建監聽器
        Reader readerA = new Reader("讀者A");
        Reader readerB = new Reader("讀者B");
        Reader readerC = new Reader("讀者C");
        Reader readerD = new Reader("讀者D");
        
        //2-創建事件源
        Writer writerA = new Writer("莫言");
        Writer writerB = new Writer("路遙");
        
        //3-將監聽器添加到事件源
        writerA.addWriterListener(readerA);
        writerA.addWriterListener(readerB);
        writerA.addWriterListener(readerC);
        writerA.addWriterListener(readerD);
        writerB.addWriterListener(readerA);
        writerB.addWriterListener(readerB);
        
        //5-事件源觸發事件
        writerA.pushBook("平凡的世界");
        writerB.pushBook("悲慘的世界");
        
        //6-從事件源中移除監聽器
        writerB.removeWriterListener(readerA);
        writerB.pushBook("十月圍城");
        
    }

}

6，Result

事件源 : 莫言;   發布了新書: 平凡的世界 ... ... 
監聽器 ：讀者A;  收到事件源 : 莫言, 發布了 -->平凡的世界
監聽器 ：讀者D;  收到事件源 : 莫言, 發布了 -->平凡的世界
監聽器 ：讀者C;  收到事件源 : 莫言, 發布了 -->平凡的世界
監聽器 ：讀者B;  收到事件源 : 莫言, 發布了 -->平凡的世界

事件源 : 路遙;   發布了新書: 悲慘的世界 ... ... 
監聽器 ：讀者A;  收到事件源 : 路遙, 發布了 -->悲慘的世界
監聽器 ：讀者B;  收到事件源 : 路遙, 發布了 -->悲慘的世界

事件源 : 路遙;   發布了新書: 十月圍城 ... ... 
監聽器 ：讀者B;  收到事件源 : 路遙, 發布了 -->十月圍城