观察者模式与事件监听

观察者模式

有时也被称作发布订阅模式，定义了一种一对多的依赖关系，让多个观察者同时观测某一主题对象。一般由抽象观察者，具体观察者，抽象主题，具体具体组成。
ILeader：抽象主题（Subject）

public interface ILeader
{
    // 注册登记
    public void addManager(IManager manager);

    // 移除已注册的
    public void removeManager(IManager manager);

    // 通知所有经理
    public void notifyManagers(String str);
}

MyLeader：具体主题（ConcreteSubject）

public class MyLeader implements ILeader
{
    // 存储所有需注册登记的经理
    private List<IManager> managerList = new ArrayList<IManager>();
    @Override
    public void addManager(IManager manager)
    {
        synchronized (this)
        {
            if (manager != null && !(managerList.contains(manager)))
            {
                managerList.add(manager);
            }
        }
    }
    @Override
    public void removeManager(IManager manager)
    {
        synchronized (this)
        {
            if (managerList.contains(manager))
            {
                managerList.remove(manager);
            }
        }
    }
    @Override
    public void notifyManagers(String str)
    {
        for (IManager iManager : managerList)
        {
            iManager.update(str);
        }
    }
}

IManager：抽象观察者（Observer）

public interface IManager
{

    /**
     * 更新
     * @param str 与ILeader的通知参数一致
     */
    public void update(String str);
}

MarketingManager：具体观察者（ConcreteObserver）

public class MarketingManager implements IManager
{
    @Override
    public void update(String str)
    {
        System.out.print("市场部接收到命令： ");
        doSomething(str);
    }
    private void doSomething(String str)
    {
        if (str.equals("努力"))
        {
            System.out.println("下半年，我们市场部肯定会拓展更多的份额");
        }
    }
}

二 事件监听机制

由事件源，事件对象，事件监听器组成。
事件对象：一般继承自java.util.EventObject类，封装了事件源对象以及与事件相关的信息。它是在事件源和事件监听器之间传递信息的。
事件监听器：实现java.util.EventListener接口,需要注册在事件源上才能被调用。它监听事件，并进行事件处理或者转发。

举例说明

事件对象：

public class DoorEvent extends EventObject
{
    private String doorState = "";  // 表示门的状态，有“开”和“关”两种
    public DoorEvent(Object source)
    {
        super(source);
    }

    public void setDoorState(String doorState)
    {
        this.doorState = doorState;
    }

    public String getDoorState()
    {
        return this.doorState;
    }
}

事件监听器：

public interface IDoorListener extends EventListener
{
    //EventListener是所有事件侦听器接口必须扩展的标记接口、因为它是无内容的标记接口、     
    //所以事件处理方法由我们自己声明如下：
    public void dealDoorEvent(DoorEvent event);
}

public class FrontDoorListener implements IDoorListener
{
    /**
     * 做具体的开门，关门动作
     * @param event 
     */
    @Override
    public void dealDoorEvent(DoorEvent event)
    {
        if (event.getDoorState()!=null && event.getDoorState().equals("open"))
        {
            System.out.println("前门打开");
        }
        else
        {
            System.out.println("前门关闭");
        }
    }   
}

事件源：

public class DoorManager
{
    private List<IDoorListener> listeners = new ArrayList();

    public void addDoorListener(IDoorListener listener)
    {
        synchronized (this)
        {
            if (listener != null && !(listeners.contains(listener)))
            {
                listeners.add(listener);
            }
        }
    }

    public void removeDoorListener(IDoorListener listener)
    {
        synchronized (this)
        {
            if (listeners.contains(listener))
            {
                listeners.remove(listener);
            }
        }
    }

    public void notifyDoors(DoorEvent event)
    {
        for (IDoorListener iDoorListener : listeners)
        {
            iDoorListener.dealDoorEvent(event);
        }
    }

    /**
     * 模拟开门事件
     */
    public void fireOpend()
    {
        if (listeners == null)
        {
            return;
        }
        DoorEvent event = new DoorEvent(this);
        event.setDoorState("open");

        notifyDoors(event);
    }
}