java设计模式--观察者模式(Observer)

java设计模式--观察者模式(Observer)

java设计模式--观察者模式(Observer)

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

认识观察者模式:
1.目标和观察者之间的关系:
按照模式的定义,目标和观察者之间是典型的一对多的关系。
但是要注意，如果观察者只有一个，也是可以的，这样就变相的实现了目标和观察者之间
一对一的关系。

 

2.观察者模式中有四种对象：
Subject(目标对象),
Observer(定义观察者接口),
ConcreteSubject(具体的目标实现对象),
ConcreteObserver(观察者的具体实现对象)

一个目标可以有任意多个观察者对象，一旦目标的状态发生了改变，所有注册的观察者都会等到通知，
然后各个观察者会对通知作出相应的响应，执行相应的业务功能处理，并使自己的状态和目标的状态保存一致。

Subject:目标对象接口，提供如下功能：
a.一个目标可以被多个观察者观察
b.目标提供对观察者注册和退订的维护
c.当目标的状态发生变化时,目标负责通知所有注册的，有效的观察者

Observer:观察者的接口，提供目标通知时对应的更新方法，这个方法进行相应的业务处理，可以在这个方法
里面回调目标对象，以获取目标对象的数据。

ConcreteSubject：具体的目标实现对象，用来维护目标状态，当目标对象的状态发生改变时，通知
所有注册的、有效的观察者，让观察者执行相应的处理。

ConcreteObserver：观察者的具体实现对象，用来接收目标的通知，并进行相应的后续处理，比如更新
自身的状态以保持和目标的相应状态一致。

 

举例：

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

/**
 * 功能:
 *         目标对象,作为被观察者,它知道观察它的观察者,并提供注册和删除观察者的接口
 * @author Administrator
 *
 */
public class Subject
{
    //用来保存注册的观察者对象,也就是报纸的订阅者
    private List<Observer> readers = new ArrayList<Observer>();
    
    /**
     * 功能:
     *         注册观察者对象（报纸的读者需要向报社订阅,先要注册）
     * @param observer 观察者对象
     */
    public void attach(Observer reader)
    {
        readers.add(reader);
    }
    
    /**
     * 功能:
     *         删除观察者对象（报纸的读者可以取消订阅）
     * @param observer
     */
    public void detach(Observer reader)
    {
        readers.remove(reader);
    }
    
    /**
     * 功能:
     *         通知所有的观察者
     *         （当有报纸出版后，就要主动的送到读者手中，相当于通知读者）
     */
    protected void notifyAllObservers()
    {
        for(Observer reader : readers)
        {
            reader.update(this);
        }
    }
}

 

/**
 * 功能:
 *         具体的目标对象,负责把有关状态存入到相应的观察者对象
 *         并在自己状态发生改变时,通知各个观察者
 *         （报纸对象）
 * @author Administrator
 *
 */
public class NewPaper extends Subject
{
    //报纸的具体内容
    private String content;

    /**
     * 功能:
     *         获取报纸的具体内容
     * @return
     */
    public String getContent()
    {
        return content;
    }

    /**
     * 功能:
     *         设置报纸的具体内容，相当于出版报纸
     * @param content
     */
    public void setContent(String content)
    {
        this.content = content;
        
        //通知所有注册的读者
        this.notifyAllObservers();
    }
}

 

/**
 * 功能:
 *         观察者接口,定义一个更新的接口给那些在目标发生改变的时候被通知的对象
 *         （报纸的读者）
 * @author Administrator
 *
 */
public interface Observer
{
    /**
     * 功能:
     *         更新的接口
     * @param subject 传入目标对象,方便获取相应的目标对象的状态
     */
    public void update(Subject subject);
}

 

/**
 * 功能:
 *         具体的观察者对象,实现更新的方法,使自身的状态和目标的状态保存一致
 *         （真正的读者）
 * @author Administrator
 *
 */
public class Reader implements Observer
{
    //读者的姓名
    private String name;
    
    @Override
    public void update(Subject subject)
    {
        //这里采用拉的方式
        System.out.println(name + "收到报纸，内容为: "+ ((NewPaper)subject).getContent());
    }

    public String getName()
    {
        return name;
    }

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

 

public class Client
{
    public static void main(String[] args)
    {
        //创建一个报纸，作为被观察者
        NewPaper subject = new NewPaper();
        
        //创建阅读者,也就是观察者
        Reader reader1 = new Reader();
        reader1.setName("罗纳尔多");
        
        Reader reader2 = new Reader();
        reader2.setName("贝克汉姆");
        
        //注册观察者
        subject.attach(reader1);
        subject.attach(reader2);
        
        subject.setContent("世界杯要开始了哦.....");
    }
}

 

 

对上面的模式进行讲解：
一、目标和观察者之间的关系
按照模式的定义，目标和观察者之间是典型的一对多的关系。
但是，观察者也可以只有一个，这样就实现了目标和观察者之间一对一的关系。

同样，一个观察者可以观察多个目标。

 

观察者模式中的: 推模型和拉模型

推模型：
目标对象主动向观察者推送目标的详细信息，不管观察者是否需要，推送的信息通常是
目标对象的全部或部分数据

拉模型：
目标对象在通知观察者的时候，只传递少量信息。如果观察者需要更具体的信息，
由观察者主动到目标对象中获取，相当于观察者从目标对象中拉数据。

 

将上面的代码通过推模型进行实现：

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


/**
 * 功能:
 *         目标对象，作为被观察者，使用推模型
 * @author Administrator
 *
 */
public class Subject
{    
    //用来保存注册的观察者对象（报纸订阅者）
    private List<Observer> readers = new ArrayList<Observer>();
    
    /**
     * 功能:
     *         注册观察者对象（报纸的读者需要向报社订阅,先要注册）
     * @param observer 观察者对象
     */
    public void attach(Observer reader)
    {
        readers.add(reader);
    }
    
    /**
     * 功能:
     *         删除观察者对象（报纸的读者可以取消订阅）
     * @param observer
     */
    public void detach(Observer reader)
    {
        readers.remove(reader);
    }
    
    /**
     * 功能:
     *         通知所有的观察者
     *         （当有报纸出版后，就要主动的送到读者手中，相当于通知读者）
     */
    protected void notifyAllObservers(String content)
    {
        for(Observer reader : readers)
        {
            reader.update(content);
        }
    }
}

 

public class NewsPaper extends Subject
{
    private String content;

    public String getContent()
    {
        return content;
    }

    public void setContent(String content)
    {
        this.content = content;
        //通知所有注册的观察者(读者)
        this.notifyAllObservers(content);
    }
}

 

/**
 * 功能:
 *         观察者（报纸的读者）
 * @author Administrator
 *
 */
public interface Observer
{
    /**
     * 功能:
     *         被通知的方法,直接把报纸的内容推送过来
     * @param content
     */
    public void update(String content);
}

 

public class Reader implements Observer
{
    //读者的姓名
    private String name;
    
    @Override
    public void update(String content)
    {
        //这里采用推的方式
        System.out.println(name + "收到报纸了，内容是:" + content);
    }

    public String getName()
    {
        return name;
    }

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

 

public class Client
{
    public static void main(String[] args)
    {
        //创建一个报纸，作为被观察者
        NewsPaper subject = new NewsPaper();
        
        //创建阅读者,也就是观察者
        Reader reader1 = new Reader();
        reader1.setName("罗纳尔多");
        
        Reader reader2 = new Reader();
        reader2.setName("贝克汉姆");
        
        //注册观察者
        subject.attach(reader1);
        subject.attach(reader2);
        
        subject.setContent("世界杯要开始了哦.....");
    }
}

 

两种模型的比较：

（1）推模型是假定目标对象知道观察者需要的数据；而拉模型是目标对象不知道观察者具体
需要什么数据，没有办法的情况下，把自身传给观察者，让观察者自己去按需取值。
（2）推模型可能会使得观察者对象难以复用，因为观察者定义的update方法是按需而定义的，
可能无法兼顾没有考虑到的使用情况。这就意味着出现新情况的时候，就可能需要提供新的update方法，
或者干脆重新实现观察者。



java中的观察者

在java.util包里面有一个类Observable,实现了大部分目标的功能。
java.util包里面有一个类Observer，其中定义了update的方法，就是观察者的接口

 

 

import java.util.Observable;

public class NewsPaper extends Observable
{
    //报纸的具体内容
    private String content;

    /**
     * 功能:
     *         获取报纸的具体内容
     * @return
     */
    public String getContent()
    {
        return content;
    }

    /**
     * 功能:
     *         设置报纸的具体内容,相当于出版报纸
     * @param content
     */
    public void setContent(String content)
    {
        this.content = content;
        
        //通知观察者
        this.setChanged();
        this.notifyObservers(this.content);//采用推的方法
        
    }
}

 

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

/**
 * 功能:
 *         观察者（读者）
 * @author Administrator
 *
 */
public class Reader implements Observer
{
    private String name;
    
    public String getName()
    {
        return name;
    }

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

    @Override
    public void update(Observable arg0, Object obj)
    {
        System.out.println(name + "收到报纸了，内容为:"+obj);
    }
}

 

public class Client
{
    public static void main(String[] args)
    {
        //创建一个报纸，作为被观察者
        NewsPaper subject = new NewsPaper();
        
        //创建阅读者，也就是观察者
        Reader reader1 = new Reader();
        reader1.setName("罗纳尔多");
        
        Reader reader2 = new Reader();
        reader2.setName("贝克汉姆");
        
        //注册阅读者
        subject.addObserver(reader1);
        subject.addObserver(reader2);
        
        //出版报纸
        subject.setContent("世界杯要开始了咯");
    }
}

 

观察者模式的本质：触发联动

当修改目标对象的状态的时候，就会触发相应的通知，然后会循环的调用所有注册的观察者对象
的相应方法，其实就相当于联动调用这些观察者的方法。

这个联动还是动态的，可以通过注册和取消注册来控制观察者，因而可以可以在程序运行期间，
通过动态的控制观察者，来变相地实现添加和删除某些功能处理，这些功能就是观察者在update的
时候执行的功能。