观察者模式 java 举例_java设计模式-观察者模式Observer

观察者模式(Observer Pattern)用于对象关系为一对多的情况。比如说，一个对象发生改变，这个对象的依赖对象会自动接收通知。观察者模型属于表现型。

下面我们就来看看观察者模式的组成部分。

1) 抽象目标角色(Subject)：目标角色知道它的观察者，可以有任意多个观察者观察同一个目标。并且提供注册和删除观察者对象的接口。目标角色往往由抽象类或者接口来实现。

2) 抽象观察者角色(Observer)：为那些在目标发生改变时需要获得通知的对象定义一个更新接口。抽象观察者角色主要由抽象类或者接口来实现。

3) 具体目标角色(Concrete Subject)：将有关状态存入各个Concrete Observer对象。当它的状态发生改变时, 向它的各个观察者发出通知。

4) 具体观察者角色(Concrete Observer)：存储有关状态，这些状态应与目标的状态保持一致。实现Observer的更新接口以使自身状态与目标的状态保持一致。在本角色内也可以维护一个指向Concrete Subject对象的引用。

举例

package com.html580.observer;

import java.util.ArrayList;

import java.util.List;

interface Observer {

public void update();

}

interface Subject {

/* 增加观察者 */

public void add(Observer observer);

/* 删除观察者 */

public void del(Observer observer);

/* 通知所有的观察者 */

public void notifyObservers();

/* 自身的操作 */

public void operation();

/* 获取主题的State */

public int getState();

/* 更新主题State */

public void setState(int state);

}

abstract class AbstractSubject implements Subject {

private Listobservers = new ArrayList();

private int state;

public int getState() {

return state;

}

public void setState(int state) {

this.state = state;

notifyObservers();

}

public void add(Observer observer) {

observers.add(observer);

}

public void del(Observer observer) {

observers.remove(observer);

}

public void notifyObservers() {

for (Observer observer : observers) {

observer.update();

}

}

}

class MySubject extends AbstractSubject {

@Override

public void operation() {

System.out.println("update self!");

notifyObservers();

}

}

abstract class AbstractObserver implements Observer {

protected Subject subject;

public abstract void update();

}

class Observer1 extends AbstractObserver {

public Observer1(Subject subject){

this.subject = subject;

this.subject.add(this);

}

@Override

public void update() {

System.out.println("observer1 has received!");

if(this.subject.getState()!=0){

System.out.println("received State:"+this.subject.getState());

}

}

}

class Observer2 extends AbstractObserver {

public Observer2(Subject subject){

this.subject = subject;

this.subject.add(this);

}

@Override

public void update() {

System.out.println("observer2 has received!");

if(this.subject.getState()!=0){

System.out.println("received State:"+this.subject.getState());

}

}

}

public class Client {

public static void main(String<> args) {

Subject sub = new MySubject();

new Observer1(sub);

new Observer2(sub);

sub.operation();

sub.setState(1);

}

}Observer模式定义对象间的一对多的依赖关系,当一个对象(被观察者)的状态发生改变时, 所有依赖于它的对象(观察者)都得到通知并被自动更新。JDK里提供的observer设计模式的实现由java.util.Observable类和 java.util.Observer接口组成。

1. Observable和Observer对象是一对多的关系,也就是说一旦Observable对象状态变化,它就要负责通知所有和它有关系的Observer对象,然后做相应的改变.

1. Observable对象不会主动去通知各个具体的Observer对象其状态发生了变化,而是提供一个注册接口供Observer对象使用,任何一个Observer对象如果想要被通知,则可以使用这个接口来注册.

3. 在Observable中有一个集合和一个状态控制开关,所有注册了通知的Observer对象会被保存在这个集合中.这个控制开关就是用来控制Observable是否发生了变化,一旦发生了变化,就通知所有的Observer对象更新状态.

下面是模拟了烧水的过程实例

涉及三个对象，Heater(热水器),Display(显示器),Alarm(报警器).

模拟过程：为了便于运行，水的初始化温度为90，沸点为95，显示器依据热水器显示温度，显示器显示温度为95时，报警器开始报警。明显可以看出Heater是subject ,Display 是它的 Obsrver，同时Display亦是subject，因为它要被报警器观察，所以Alarm是Display的Observer.

package com.html580.observer;

import java.util.Observable;

//Heater类

class Heater extends Observable {

private int temperature;

public int getTemperature() {

return temperature;

}

public void setTemperature(int temperature) {

this.temperature = temperature;

}

public void boilWater() {

for (int i = 90; i < 110; i++) {

temperature = i;

this.setChanged();

this.notifyObservers();

}

}

}

// Display类

class Display extends Observable implements java.util.Observer {

private String status = "未开";

public String getStatus() {

return status;

}

public void setStatus(String status) {

this.status = status;

}

public void update(Observable o, Object arg) {

this.displayTemperature(((Heater) o).getTemperature());

}

private void displayTemperature(int temperature) {

if (temperature > 100) {

this.setStatus("沸腾");

this.setChanged();

this.notifyObservers(temperature);

}

System.out.println("状态： " + status + " 现在温度： " + temperature);

}

}

// Alarm类

class Alarm implements java.util.Observer {

public void update(Observable arg0, Object arg1) {

this.makeAlarm((Integer) arg1);

}

private void makeAlarm(int temperature) {

System.out.println("嘀嘀嘀。。。水已经烧开了");

// System.out.println("现在水温是： " + temperature);

}

}

// Client2测试入口类

public class Client2 {

public static void main(String<> args) {

Heater heater = new Heater();

Display display = new Display();

Alarm alarm = new Alarm();

heater.addObserver(display);

display.addObserver(alarm);

heater.boilWater();

}

}优点

支持松耦合和减少依赖性。客户端不再依赖于观察器，因为通过使用主体和 Observer 接口对客户端进行了隔离。许多框架具有此优点，在这些框架中的应用程序组件可以注册为当(低级)框架事件发生时得到通知。结果，框架将调用应用程序组件，但不会依赖于它。

观察器数目可变。观察器可以在运行时附加和分离，因为主体对于观察器数目没有任何假定。此功能在这样的情况下是很有用的：观察器数在设计时是未知的。例如，如果用户在应用程序中打开的每个窗口都需要一个观察器。

缺点

性能降低。在许多实现中，观察器的 update() 方法可能与主体在同一线程中执行。如果观察器列表很长，则执行 Notify() 方法可能需要很长时间。抽取对象依赖性并不意味着添加观察器对应用程序没有任何影响。

内存泄漏。在 Observer 中使用的回调机制(当对象注册为以后调用时)会产生一个常见的错误，从而导致内存泄漏，甚至是在托管的 C# 代码中。假定观察器超出作用范围，但忘记取消对主体的订阅，那么主体仍然保留对观察器的引用。此引用防止垃圾收集在主体对象也被破坏之前重新分配与观察器关联的内存。如果观察器的生存期比主体的生存期短得多(通常是这种情况)，则会导致严重的内存泄漏。

隐藏的依赖项。观察器的使用将显式依赖性(通过方法调用)转变为隐式依赖性(通过观察器)。如果在整个应用程序中广泛地使用观察器，则开发人员几乎不可能通过查看源代码来了解所发生的事情。这样，就使得了解代码更改的含意非常困难。此问题随传播级别急剧增大(例如，充当 Subject 的观察器)。因此，应该仅在少数定义良好的交互(如 Model-View-Controller 模式中模型和视图之间的交互)中使用观察器。最好不要在域对象之间使用观察器。

测试 / 调试困难。尽管松耦合是一项重大的体系结构功能，但是它可以使开发更困难。将两个对象去耦的情况越多，在查看源代码或类的关系图时了解它们之间的依赖性就越难因此，仅当可以安全地忽略两个对象之间的关联时才应该将它们松耦合(例如，如果观察器没有副作用)。