監聽器模式(Listener)

　　　　監聽器模式有三個要素:

　　　　　　事件源:顧名思義，事件發生的源頭，比如點擊的按鈕，可以工作可以運作的機器人，屬於被監聽的對象

　　　　　　事件對象:這個經常和事件源混淆，它經常被用來包裝事件源，或者說執行某個方法，比如點擊事件,機器人程序執行

　　　　　　監聽器:這個是監聽器模式的核心，定義事件發生后的動作，通常事件對象作為監聽器中定義的函數入參

　　當事件源對象上發生操作時，將會調用時間監聽的一個方法，並在調用方法的時候把事件對象傳遞過去

 執行順序：

　　1.給事件源注冊監聽器

　　2.組件接受外部作用，也就是事件觸發

　　3.組件產生一個相應的事件對象，並把此對象傳遞給與之關聯的事件處理器

　　4.事件處理器啟動，並執行相關代碼來處理事件

監聽器模式:事件源注冊監聽器后，當事件源觸發事件，監聽器就可以回調事件對象的方法;

更加形象地說，監聽者模式就是基於:注冊-回調事件/消息通知處理模式，就是被監聽者將消息通知給所有監控者

　　1.注冊監聽器:事件源.setListener

　　2.回調:事件源實現onListener

 

/**
 * 事件源:機器人
 */
public class Robot{
    private RobotListener listener;

    /**
     * 注冊機器人監聽器
     * @param listener
     */
    public void registerListener(RobotListener listener){
        this.listener = listener;
    }

    /**
     * 工作
     *
     */
    public void working() {
        if (listener != null){
            Even even = new Even(this);
            this.listener.working(even);
        }
        System.out.println("robot 開始 工作.......");
    }

    /**
     * 跳舞
     *
     */
    public void dancing() {
        if (listener != null){
            Even even = new Even(this);
            this.listener.dancing(even);
        }
        System.out.println("robot 開始 跳舞.......");
    }
}

 

　　

/**
 * 監聽器接口
 */
public interface RobotListener {
    /**
     * 工作
     * @param even
     */
    void working(Even even);

    /**
     * 跳舞
     * @param even
     */
    void dancing(Even even);
}

　　

public class MyRobotListener implements RobotListener {
    /**
     * 工作
     *
     * @param even
     */
    @Override
    public void working(Even even) {
        Robot robot = even.getRobot();
        System.out.println("機器人開始工作，防止偷窺.....");
    }

    /**
     * 跳舞
     *
     * @param even
     */
    @Override
    public void dancing(Even even) {
        Robot robot = even.getRobot();
        System.out.println("機器人開始跳舞，防止走神.....");
    }
}

　　

/**
 * 事件對象
 */
public class Even {
    private Robot robot;

    public Even() {
        super();
    }

    public Even(Robot robot) {
        super();
        this.robot = robot;
    }
    public Robot getRobot(){
        return robot;
    }

    public void setRobot(Robot robot) {
        this.robot = robot;
    }
}

　　

public class TestListener {
    public static void main(String[] args) {
        Robot robot = new Robot();
        robot.registerListener(new MyRobotListener());
        robot.working();
        robot.dancing();
    }
}

　or

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

    /**
     * 事件處理
     * @param eventObject
     */
    void handleEvent(EventObject eventObject);

}

　　

/**
 * 事件對象
 */
public class EventObject extends java.util.EventObject {

    public EventObject(Object source) {
        super(source);
    }
    public void doEvent(){
        System.out.println("通知一個事件源 source:"+this.getSource());
    }
}

　　

/**
 * 事件源
 */
public class EventSource {
    // 監聽器列表，
    private List<EventListener> listeners =  new ArrayList();

    public  void addListener(EventListener listener){
        listeners.add(listener);
    }
    public  void removeListener(EventListener listener){
        listeners.remove(listener);
    }
    public  void notifyListenerEvent(EventObject eventObject){
        listeners.forEach(x->{
            x.handleEvent(eventObject);
        });
    }
}

　　測試執行

public class EventDome {
    public static void main(String[] args) {
        EventSource eventSource = new EventSource();//事件源
        eventSource.addListener(eventObject -> {
            eventObject.doEvent();
            if (eventObject.getSource().equals("closeWindow")) {
                System.out.println("doClose。。。。。"); //回調
            }
        });
        EventObject eventObject = new EventObject("closeWindow"); // 事件對象
        eventSource.notifyListenerEvent(eventObject); // 觸發事件
    }
}

通知一個事件源 source:closeWindow
doClose。。。。。

　　EventListener是一個回調接口類，handleEvent是一個回調函數接口

 

 

 

 

https://www.cnblogs.com/jackson-yqj/p/7784694.html