Java基础之观察者设计模式201

---

3、观察者模式

1、观察者模式原理

观察者模式定义：简单地说，
观察者模式定义了一个一对多的依赖关系，
让一个或多个观察者对象监察一个主题对象。
这样一个主题对象在状态上的变化能够通知所有的依赖于此对象的那些观察者对象，使这些观察者对象能够自动更新。

---

2、观察者模式实现

• Subject（被观察的对象接口）
  规定ConcreteSubject的统一接口；
  每个Subject可以有多个Observer；
• ConcreteSubject（具体被观察对象）
  维护对所有具体观察者的引用的列表；
  状态发生变化时会发送通知给所有注册的观察者。
• Observer（观察者接口）
  规定ConcreteObserver的统一接口；
  定义了一个update()方法，
  在被观察对象状态改变时会被调用。
• ConcreteObserver（具体观察者）
  维护一个对ConcreteSubject的引用；
  特定状态与ConcreteSubject同步；
  实现Observer接口，通过update()方法
  接收ConcreteSubject的通知。

---

3、观察者模式作用

• 观察者模式在被观察者和观察者之间建立一个抽象的耦合。被观察者角色所知道的只是一个具体观察者列表。
• 由于被观察者和观察者没有紧密地耦合在一起，因此它们可以属于不同的抽象化层次。
• 如果被观察者和观察者都被扔到一起（耦合），那么这个对象必然跨越抽象化和具体化层次。
• 观察者模式支持广播通讯。被观察者会向所有的登记过的观察者发出通知。

---

发送消息的例子
被观察者接口 发消息

package com.vince.gui.abserver;

/**
 * Created by vince on 2017/7/8.
 * 被观察者的接口
 */
public interface MessageSubject {
    //注册观察者
    public void registerObserver(Observer o);
    //移除观察者
    public void removeObserver(Observer o);
    //通知所有观察者
    public void notifyObservers();
}

观察者接口

package com.vince.gui.abserver;

/**
 * Created by vince on 2017/7/8.
 * 观察者接口
 */
public interface Observer {

    //更新消息
    public void update(String message);
}

对象 Message 具体的被观察者
实现MessageSubject接口

package com.vince.gui.abserver;

import java.util.ArrayList;
import java.util.List;

/**
 * Created by vince on 2017/7/8.
 * 具体的被观察者
 */
public class Message implements MessageSubject{
    //维护的观察者列表
    private List<Observer> list = new ArrayList<>();

    private String message;

    public void setMessage(String message) {
        this.message = message;
        notifyObservers();
    }

    @Override
    public void registerObserver(Observer o) {
        list.add(o);
    }

    @Override
    public void removeObserver(Observer o) {
        list.remove(o);
    }

    @Override
    public void notifyObservers() {
        for (int i=0;i<list.size();i++){
            Observer observer = list.get(i);
            observer.update(message);
        }
    }
}

接下来 用户是具体的观察者
User类

package com.vince.gui.abserver;

/**
 * Created by vince on 2017/7/8.
 * 具体的观察者
 */
public class User implements Observer {
    private String name;
    public User(String name){
        this.name = name;
    }
    @Override
    public void update(String message) {
        System.out.println("["+name+"]收到消息："+message);
    }
}

测试类

package com.vince.gui.abserver;

import org.junit.Test;

/**
 * Created by vince on 2017/7/8.
 */
public class TestDemo {

    @Test
    public void testObserver(){
        Message message = new Message();
        Observer user1 = new User("lily");
        Observer user2 = new User("tom");
        Observer user3 = new User("vince");
        message.registerObserver(user1);
        message.registerObserver(user2);
        message.registerObserver(user3);

        message.setMessage("亲们，么么哒");

        message.removeObserver(user1);

        message.setMessage("有在的吗，我要发红包啦");
    }
}

结果

观察者设计模式的好处
被观察者的具体对象跟观察者具体对象之间没有直接关联
依赖于抽象 不依赖与具体的实现