观察者模式(发布-订阅模式)

观察者模式定义了一对多的依赖，当一个对象状态发生变化时，他的所有依赖者都会收到通知并自动更新。属于行为型模式。

主要解决

一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作

关键代码

在抽象类里又一个ArrayList存放观察者们

优点

1. 观察者和被观察者是抽象耦合的
2. 建立一套触发机制

缺点

1. 如果一个被观察者对象有很多直接或间接的观察者，将所有观察者都通知到，会花费很多的时间
2. 如果在观察者和观察目标之间有循环依赖的时候，观察目标会触发他们之间进行循环调用，导致系统的崩溃
3. 观察模式没有相应的机制让观察者知道所观察的目标对象是怎样发生变化的，而仅仅是知道观察目标发生了变化。

使用场景

1. 一个抽象模型有两个方面，其中一个方面依赖于另一个方面。将这些方面封装在独立的对象中使他们可以各自独立的改变和复用
2. 一个对象的改变将导致其他一个或多个对象的改变，而不知道具体有多少对象发生改变，可以降低对象之间的耦合度
3. 一个对象必须通知其他对象，而并不知道这些对象是谁
4. 需要在一个系统中创建触发链，A对象行为将影响B对象，B影响C…

案例1

微信公众号服务，关注者可收到推送消息，取消关注无法收到

package demo;
/**
* 抽象被观察者接口
* @author missj
*
*/
public interface Observerable {
public void registerObserver(Observer o);
public void removeObserver(Observer o);
public void notifyObserver();
}

package demo;

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

/**
* 定义被观察者
* 微信公众号服务
* @author missj
*
*/
public class WechatServer implements Observerable {
// 观察者，面向接口编程
private List<Observer> list;

private String message;



public WechatServer() {
list = new ArrayList<>();
}

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

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

@Override
public void notifyObserver() {
for (Observer observer : list) {
observer.update(message);
}
}

public String getMessage() {
return message;
}

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

package demo;

/**
* 抽象观察者 定义了一个update（）方法，当被观察者调用notifyObsever（）方法时，观察者的update（）方法会被调用
* 
* @author missj
*
*/
public interface Observer {
public void update(String message);
}

package demo;

public class User implements Observer {
private String name;
private String message;

public User(String name) {
super();
this.name = name;
}

@Override
public void update(String message) {
this.message = message;
read();
}

public void read() {
System.out.println(name + "推送消息" + message);
}
}

package demo;

import java.util.Date;

public class Test {
public static void main(String[] args) {
WechatServer server = new WechatServer();
server.setMessage("测试");
// 定义三个观察者
Observer u1 = new User("u1");
Observer u2 = new User("u2");
Observer u3 = new User("u3");

server.registerObserver(u1);
server.registerObserver(u2);
server.registerObserver(u3);

System.out.println(new Date());
server.notifyObserver();

server.removeObserver(u3);
server.setMessage("测试2");
}
}

案例2

使用java提供的Observer实现案例1

package demo2;

import java.util.Observable;
/**
* 模拟公众号
* @author missj
*
*/
public class WechatServer extends Observable {
private String message;
public void sendMessage(String message) {
this.setChanged();
this.notifyObservers(message);
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
sendMessage(message);
}
}

package demo2;

import java.util.Observable;
import java.util.Observer;

public class User implements Observer {
private String name;

@Override
public void update(Observable o, Object arg) {
System.out.println(this.name + "收到推送消息:" + arg);
}

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public User(String name) {
super();
this.name = name;
}
}

package demo2;

import java.util.Observer;

public class Test {
public static void main(String[] args) {
WechatServer server = new WechatServer();
Observer user1 = new User("u1");
Observer user2 = new User("u2");
Observer user3 = new User("u3");
server.addObserver(user1);
server.addObserver(user2);
server.addObserver(user3);
server.setMessage("测试");
server.deleteObserver(user3);
System.out.println("===========");
server.setMessage("测试2");
}
}