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);
    }

}

---

业务运行结果：