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

观察者模式(别名：依赖，发布-订阅)

定义对象间的一种一对多的依赖关系，当一个对象的状态发生变化时，所有依赖它的对象都得到通知并被自动更新。

Observer Pattern(Another Name: Dependents, Publish-Subscribe)

Define a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

类图

模式的结构与使用

观察者模式的结构中包括四个角色。

  • 主题（Subject）：主题是一个接口，该接口规定了具体主题需要实现的方法，比如，添加、删除观察者以及通知观察者更新数据的方法。
  • 具体主题（Concrete Subject）：具体主题是实现主题接口类的一个实例，该实例包含有可以经常发生变化的数据。具体主题需使用一个集合，比如ArrayList，存放观察者的引用，以便数据变化时通知具体观察者。
  • 观察者（Observer）：观察者一个接口或者抽象类，该接口规定了具体观察者用来更新数据的方法。
  • 具体观察者（Concrete Observer）：具体观察者是实现观察者接口类的一个实例。具体观察者包含有可以存放具体主题引用的主题接口变量，以便具体观察者让具体主题将自己的引用添加到具体主题中，使自己成为它的观察者，或让这个具体主题将自己从具体主题的集合中删除，使自己不再是它的观察者。

简单的例子（推数据）

Subject接口类Subject.java

1
2
3
4
5
6
7
package Observer;
public interface Subject {
	public void addObserver(Observer o);
	public void deleteObserver(Observer o);
	public void notifyObservers();
}

ConcreteSubject的实现类SeekJobCenter.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
package Observer;
import java.util.ArrayList;
public class SeekJobCenter implements Subject {
	String mess;
	ArrayList<Observer> personList;
	boolean changed;
	
	public SeekJobCenter() {
		personList = new ArrayList<Observer>();
		mess = "";
		changed = false;
	}
	@Override
	public void addObserver(Observer o) {
		if (!personList.contains(o)) {
			personList.add(o);
		}
	}
	@Override
	public void deleteObserver(Observer o) {
		if (personList.contains(o)) {
			personList.remove(o);
		}
	}
	@Override
	public void notifyObservers() {
		if (changed) {
			for (int i = 0; i < personList.size(); i++) {
				Observer o = personList.get(i);
				o.hearTelephone(this.mess);
			}
			changed = false;
		}
	}
	
	public void giveNewMessage(String str) {
		if (str.equals(mess)) {
			System.out.println("重复信息");
			changed = false;
		} else {
			this.mess = str;
			changed = true;
		}
	}
}

Observer的接口类Observer.java

1
2
3
4
5
package Observer;
public interface Observer {
	public void hearTelephone(String mess);
}

ConcreteObserver的实现类UniversityStudent.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package Observer;
public class UniversityStudent implements Observer {
	Subject subject;
	
	public UniversityStudent(Subject subject) {
		this.subject = subject;
		subject.addObserver(this);
	}
	@Override
	public void hearTelephone(String mess) {
		System.out.println("我是一个大学生");
		System.out.println(mess);
	}
}

ConcreteObserver的实现类MiddleSchoolStudent.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package Observer;
public class MiddleSchoolStudent implements Observer {
	Subject subject;
	
	public MiddleSchoolStudent(Subject subject) {
		this.subject = subject;
		subject.addObserver(this);
	}
	@Override
	public void hearTelephone(String mess) {
		System.out.println("我是一名中学生");
		if (mess.contains("中学生")) {
			System.out.println(mess);
		} else {
			System.out.println("我是中学生，这次信息中没有我需要的信息");
		}
	}
}

测试类Application.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
package Observer;
public class Application {
	
	public static void main(String[] args) {
		SeekJobCenter center = new SeekJobCenter();
		new UniversityStudent(center);
		new MiddleSchoolStudent(center);
		center.giveNewMessage("大学生工作");
		center.notifyObservers();
		center.giveNewMessage("大学生工作");
		center.notifyObservers();
		center.giveNewMessage("中学生工作");
		center.notifyObservers();
	}
}

观察者模式中的“推”数据与“拉”数据

1.推数据方式

推数据方式是指具体主题将变化后的数据全部交给具体观察者，即将变化后的数据传给具体观察者用于更新数据方法的参数。当具体主题认为具体观察者需要这些变化后的全部数据时往往采用推数据方式。

2.拉数据方式

拉数据方式是指具体主题不将变化后的数据交给具体观察者，而是提供了获得这些数据的方法，具体观察者在得到通知后，可以调用具体主题提供的方法得到数据（观察者自己数据“拉”过来），但需要自己判断数据是否发生变化。当具体主题不知道具体观察者是需要这些变换后的数据时往往采用拉数据的方式。

简单的例子（拉数据）

Subject接口类Subject.java

1
2
3
4
5
6
7
package ObserverPull;
public interface Subject {
	public void addObserver(Observer o);
	public void deleteObserver(Observer o);
	public void notifyObserver();
}

ConcreteSubject的实现类ShopSubject.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package ObserverPull;
import java.util.ArrayList;
public class ShopSubject implements Subject {
	String goodsName;
	double oldPrice, newPrice;
	public String getGoodsName() {
		return goodsName;
	}
	public double getOldPrice() {
		return oldPrice;
	}
	public double getNewPrice() {
		return newPrice;
	}
	public ArrayList<Observer> getCustomerList() {
		return customerList;
	}
	ArrayList<Observer> customerList;
	public ShopSubject() {
		customerList = new ArrayList<Observer>();
	}
	@Override
	public void addObserver(Observer o) {
		if (!customerList.contains(o)) {
			customerList.add(o);
		}
	}
	@Override
	public void deleteObserver(Observer o) {
		if (customerList.contains(o)) {
			customerList.remove(o);
		}
	}
	@Override
	public void notifyObserver() {
		for (int i = 0; i < customerList.size(); i++) {
			customerList.get(i).update();
		}
	}
	public void setDiscountGoods(String name, double oldP, double newP) {
		goodsName = name;
		oldPrice = oldP;
		newPrice = newP;
		notifyObserver();
	}
}

Observer的接口类Observer.java

1
2
3
4
5
package ObserverPull;
public interface Observer {
	public abstract void update();
}

ConcreteObserver的实现类CustomerOne.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package ObserverPull;
public class CustomerOne implements Observer {
	
	Subject subject;
	String goodsName,personName;
	
	public CustomerOne(Subject subject, String personName) {
		this.subject = subject;
		this.personName = personName;
		subject.addObserver(this);
	}
	@Override
	public void update() {
		if (subject instanceof ShopSubject) {
			goodsName = ((ShopSubject) subject).getGoodsName();
			System.out.println(personName + "只对打折商品的名字感兴趣");
			System.out.println("打折商品是:" + goodsName);
		}
	}
}

ConcreteObserver的实现类CustomerTwo.java

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package ObserverPull;
public class CustomerTwo implements Observer {
	Subject subject;
	String personName;
	double oldP,newP;
	
	public CustomerTwo(Subject subject, String personName) {
		this.subject = subject;
		this.personName = personName;
		subject.addObserver(this);
	}
	@Override
	public void update() {
		if (subject instanceof ShopSubject) {
			oldP = ((ShopSubject) subject).getOldPrice();
			newP = ((ShopSubject) subject).getNewPrice();
			System.out.println(personName + "只对商品的新旧价格感兴趣");
			System.out.println("商品旧价格是:" + oldP);
			System.out.println("商品新价格是:" + newP);
		}
	}
}

测试类Application.java

1
2
3
4
5
6
7
8
9
10
11
12
package ObserverPull;
public class Application {
	public static void main(String[] args) {
		ShopSubject shop = new ShopSubject();
		new CustomerOne(shop, "yxx");
		new CustomerTwo(shop, "yn");
		shop.setDiscountGoods("pen", 20, 10);
		shop.setDiscountGoods("相机", 1000, 800);
	}
}

观察者与多主体

一个具体观察者可以依赖于多个主题，当所有依赖的任何具体主题的数据发生变化时，该观察者都能得到通知。多主题所涉及的主要问题是观察者如何处理主题中变化后的数据，因为，不同的具体主题所包含有的数据结构可能很大不同。
在处理多主题时，主题应当采用拉数据方式，观察者接口可以将更新数据方法的参数类型设置为主题接口类型，比如update(Subject subject)，即具体主题数据放生变化时将自己的引用传递给具体的观察者，然后具体观察者让这个具体主题调用有关的方法返回该具体主题中的数据。

观察者模式的优点

  • 具体主题和具体观察者是松耦合关系。由于主题接口仅仅依赖于观察者接口，因此具体主题只是知道它的观察者是实现观察者接口的某个类的实例，但不需要知道具体哪个类。同样，由于观察者仅仅依赖于主题接口，因此具体观察者只是知道它依赖的主题是实现主题接口的某个类的实例，但不需要知道具体是哪一个类。
  • 观察模式满足“开-闭原则”。主题接口仅仅依赖于观察者接口，这样，就可以让创建具体主题的类也仅仅是依赖于观察者接口，因此如果增加新的实现观察者接口的类，不必修改创建具体主题的类的代码。同样，创建具体观察者的类仅仅依赖于主题接口，如果增加新的实现主题接口的类，也不必修改创建具体观察者类的代码。

适用观察者模式的情景

  • 当一个对象的数据更新时需要通过其他对象，但这个对象又不希望和被通知的那些对象形成紧耦合。
  • 当一个对象的数据更新时，这个对象需要让其他对象也各自更新自己的数据，但这个对象不知道具体有多少对象需要更新数据。

下载源码请到

MyGitHub

本文标题:Java设计模式--观察者模式

文章作者:yxx

发布时间:2016年09月08日 - 09时24分

最后更新:2016年09月19日 - 08时44分

原始链接:http://yoursite.com/2016/09/08/Java设计模式--观察者模式/

许可协议: "署名-非商用-相同方式共享 3.0" 转载请保留原文链接及作者。

文章目录
  1. 1. 观察者模式(别名：依赖，发布-订阅)
  2. 2. Observer Pattern(Another Name: Dependents, Publish-Subscribe)
  3. 3. 类图
  4. 4. 模式的结构与使用
  5. 5. 简单的例子（推数据）
    1. 5.1. Subject接口类Subject.java
    2. 5.2. ConcreteSubject的实现类SeekJobCenter.java
    3. 5.3. Observer的接口类Observer.java
    4. 5.4. ConcreteObserver的实现类UniversityStudent.java
    5. 5.5. ConcreteObserver的实现类MiddleSchoolStudent.java
    6. 5.6. 测试类Application.java
  6. 6. 观察者模式中的“推”数据与“拉”数据
    1. 6.1. 1.推数据方式
    2. 6.2. 2.拉数据方式
  7. 7. 简单的例子（拉数据）
    1. 7.1. Subject接口类Subject.java
    2. 7.2. ConcreteSubject的实现类ShopSubject.java
    3. 7.3. Observer的接口类Observer.java
    4. 7.4. ConcreteObserver的实现类CustomerOne.java
    5. 7.5. ConcreteObserver的实现类CustomerTwo.java
    6. 7.6. 测试类Application.java
  8. 8. 观察者与多主体
  9. 9. 观察者模式的优点
  10. 10. 适用观察者模式的情景
  11. 11. 下载源码请到