设计模式-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;  收到事件源 : 路遥, 发布了 -->十月围城