Java设计模式--观察者模式

应用场合：

主题-观察者，当主题的状态改变时，调用notify方法通知所有的观察者作出相应的处理（即调用观察者的updae方法）。

是一种一对多的关系，主题只有一个，这个主题有一个观察者队列（observerList<Observer>）。

主题和观察者都是接口，虽然说观察者模式解耦了观察者和主题，但是对于这两个接口来说，他们是相互依赖的。

主题

• 这个接口要提供1.添加观察者的方法；2.删除观察者的方法；3.通知观察的方法。
• 其实现类中，有一个List类型的成员变量用来存储观察者。在通知观察的方法中，对List进行变量，调用观察者的update方法。

观察者

• 观察者接口中要有一个update方法，当主题通知观察者时，会调用这个update方法来将业务状态传递给观察者。
  

  ---

每声明一个观察者时，通过构造函数的方式需要绑定一个主题，此时将这个观察者添加到某个主题的队列中。当观察者想要退出主题时，需要调用主题的方法，主题从自己的队列中删除这个观察者。

Subject sub=new Sub();Observer obj=new Observer(sub); //绑定主题sub.notify(); //遍历观察者，调用观察者的update方法sub.removeObserver(obj); //主题将观察者从自己的观察者队列中移除

---

小实例

主题接口

主题接口中提供了三个基础方法：addObserver()用于给主题添加Observer，removeObserver()用于将Observer移除主题的监听队列，notifying()方法用于遍历、通知观察者，即遍历调用Observer的update()方法。

package com.model;public interface Subject{    void addObserver(Observer obj);    void removeObserver(Observer obj);    void notifying(Message message);}

观察者接口

Observer接口中主要是定义了update()方法，主题在通知观察者时，就会调用这个方法

package com.model;public interface Observer{    String getObserverName();    void update(Message message);}

辅助的一个业务类接口

一个辅助类，用于Subject和Observer间传递消息内容

package com.model;public interface Message{    String getMessage();}

主题的实现类

package com.model.impl;import java.util.ArrayList;import java.util.Iterator;import com.model.Message;import com.model.Observer;import com.model.Subject;public class Event implements Subject{    ArrayList<Observer> observerList;    public Event() {        super();        this.observerList = new ArrayList<Observer>();    }    @Override    public void addObserver(Observer obj) {        this.observerList.add(obj);    }    @Override    public void removeObserver(Observer obj) {        this.observerList.remove(obj);    }    public String getObserverList() {        String list="";        for(Iterator<Observer> iter=observerList.iterator();iter.hasNext();) {            list+=iter.next().getObserverName();        }        return list;    }    @Override    public void notifying(Message message) {        for (Iterator iterator = observerList.iterator(); iterator.hasNext();) {            Observer observer = (Observer) iterator.next();            observer.update(message);        }    }}

观察者实现类

- package com.model.impl;import com.model.Message;import com.model.Observer;import com.model.Subject;public class Listener implements Observer{    private String message;    private String listenerName;    Subject sub;    public Listener(Subject sub)    {        this.sub = sub;        sub.addObserver(this);        this.message = "";        this.listenerName = "";    }    @Override    public void update(Message message)    {        this.setMessage(message.getMessage());        System.out.println(this.getRuleMessage());    }    public void setMessage(String message)    {        this.message = message;    }    String getMessage()    {        return this.message;    }    String getRuleMessage()    {        String message = this.getListenerName() + "-->" + this.getMessage();        return message;    }    public String getListenerName()    {        return listenerName;    }    public void setListenerName(String listenerName)    {        this.listenerName = listenerName;    }    @Override    public String getObserverName()    {        return this.getListenerName();    }}

业务实现类

- package com.model.impl;import com.model.Message;public class RuleMessage implements Message{    String message;    public RuleMessage(String message)    {        super();        this.message = message;    }    public void setMessage(String message)    {        this.message = message;    }    @Override    public String getMessage()    {        return this.message;    }}

主方法运行类

场景一

首先定义一个Event，此时他的监听队列是空的。

1号观察者Listener 1注册了Event的监听

Event发生变化后通知自己的观察者队列

场景二

2号观察者Listener 2注册了Event的监听

Event发生变化后通知自己的观察者队列

场景三

1号监听者取消监听Event

Event发生变化后通知自己的观察者队列

package com.model.impl;import com.model.Message;import com.model.Subject;public class Main{    public static void main(String[] args)    {        Subject processorRule = new Event();        System.out.println("This rule event's observerList:{" + ((Event) processorRule).getObserverList() + "}");        Listener processorRuleListener = new Listener(processorRule);        processorRuleListener.setListenerName("listener 1");        System.out.println("listener 1 subscribes!");        System.out.println("This rule event's observerList:{" + ((Event) processorRule).getObserverList() + "}");        System.out.println();        Message ruleMsg1 = new RuleMessage("processor rule1 is fired");        System.out.println("fired rule!");        processorRule.notifying(ruleMsg1);        System.out.println();        Listener processorRuleListener2 = new Listener(processorRule);        processorRuleListener2.setListenerName("listener 2");        System.out.println("listener 2 subscribes!");        System.out.println("This rule event's observerList:{" + ((Event) processorRule).getObserverList() + "}");        Message ruleMsg = new RuleMessage("processor rule2 is fired");        System.out.println("fired rule!");        processorRule.notifying(ruleMsg);        System.out.println();        processorRule.removeObserver(processorRuleListener);        System.out.println("listener 1 leaves!");        System.out.println("This rule event's observerList:{" + ((Event) processorRule).getObserverList() + "}");        Message ruleMsg3 = new RuleMessage("processor rule3 is fired");        System.out.println("fired rule!");        processorRule.notifying(ruleMsg3);    }}

---

业务运行结果：