Java设计模式之观察者模式

Java设计模式之观察者模式

一、定义

观察者模式：定义对象间一种一对多的依赖关系，使得每当一个对象改变状态，则所有依赖它的对象都会得到通知并自动更新。

观察者模式的结构中包括中包含四中角色：

1. 被观察者（Subject）
2. 观察者（Observer）
3. 具体被观察者（ConcreteSubject）
4. 具体观察者（ConcreteObserver）

二、UML 类图

三、实例场景

微信订阅模式，订阅者可以接收到推送信息

1、抽象被观察者

/**
 * 抽象别观察者
 * @author molong
 *
 */
public interface Observerable {
	
	/**
	 * 注册观察者
	 * @param o
	 */
	public void registerObserver(Observer o);
	
	/**
	 * 移除观察者
	 * @param o
	 */
	public void removeObserver(Observer o);
	
	/**
	 * 通知
	 */
	public void notifyObserver();
	
}

2、抽象观察者

/**
 * 抽象观察者的
 * @author molong
 *
 */
public interface Observer {

	/**
	 * 更新
	 * @param message
	 */
	public void update(String message);
	
}

3、被观察者

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

public class WeChatServer implements Observerable {
	
	private List<Observer> list;
	private String message;
	
	public WeChatServer() {
		message = null;
		list = new ArrayList<>();
	}

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

	@Override
	public void removeObserver(Observer o) {
		if (!list.isEmpty()) {
			list.remove(o);
		} else {
			System.out.println("暂无订阅者!");
		}
	}

	@Override
	public void notifyObserver() {
		for (Observer o : list) {
			o.update(message);
		}
	}
	
	public void setMessage(String s) {
		this.message = s;
		System.out.println("微信公众号更新消息: [ " + s + " ]");
		this.notifyObserver();
	}
	
}

4、观察者

public class User implements Observer {
	
	private String name;
	private String message;
	
	public User(String name) {
		this.name = name;
	}
	
	@Override
	public String toString() {
		return " [名字 : " + name + "] ";
	}
	

	@Override
	public void update(String message) {
		// TODO Auto-generated method stub
		this.message = message;
		read();
	}
	
	public void read() {
		System.out.println(name + " : 收到推送的消息 =>  [ " + message + " ] ");
	}

}

5、测试类

public class ObserverMain {
	
	public static void main(String args[]) {
		WeChatServer server = new WeChatServer();
		
		Observer user1 = new User("张三");
		Observer user2 = new User("李四");
		Observer user3 = new User("王五");
		
		System.out.println("增加注册者 :" + user1.toString());
		server.registerObserver(user1);
		System.out.println("增加注册者 :" + user2.toString());
		server.registerObserver(user2);
		System.out.println("增加注册者 :" + user3.toString());
		server.registerObserver(user3);
		server.setMessage("人生苦短,我用Python");
		System.out.println("移除注册者 :" + user3.toString());
		server.removeObserver(user3);
		server.setMessage("Java最厉害!");
	}

}

6、运行结果

增加注册者 : [名字 : 张三]
增加注册者 : [名字 : 李四]
增加注册者 : [名字 : 王五]
微信公众号更新消息: [ 人生苦短,我用Python ]
张三 : 收到推送的消息 => [ 人生苦短,我用Python ]
李四 : 收到推送的消息 => [ 人生苦短,我用Python ]
王五 : 收到推送的消息 => [ 人生苦短,我用Python ]
移除注册者 : [名字 : 王五]
微信公众号更新消息: [ Java最厉害! ]
张三 : 收到推送的消息 => [ Java最厉害! ]
李四 : 收到推送的消息 => [ Java最厉害! ]

四、优点

具体主题和具体观察者世松耦合关系。

观察者模式满足“开 - 闭原则”。

五、适用场景

1. 当一个对象的改变需要给变其它对象时，而且它不知道具体有多少个对象有待改变时。

2. 一个抽象某型有两个方面，当其中一个方面依赖于另一个方面，这时用观察者模式可以将这两者封装在独立的对象中使它们各自独立地改变和复用。