观察者设计模式

最新推荐文章于 2024-05-01 23:44:07 发布

Bee大前端

最新推荐文章于 2024-05-01 23:44:07 发布

阅读量411

点赞数

分类专栏：设计模式-行为型模式文章标签：设计模式类继承

本文链接：https://blog.csdn.net/u011625768/article/details/40183037

版权

设计模式-行为型模式专栏收录该内容

8 篇文章 0 订阅

订阅专栏

观察者模式是对象的行为模式，又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式。

　　观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态上发生变化时，会通知所有观察者对象，使它们能够自动更新自己。

观察者模式的结构

　　一个软件系统里面包含了各种对象，就像一片欣欣向荣的森林充满了各种生物一样。在一片森林中，各种生物彼此依赖和约束，形成一个个生物链。一种生物的状态变化会造成其他一些生物的相应行动，每一个生物都处于别的生物的互动之中。

　　同样，一个软件系统常常要求在某一个对象的状态发生变化的时候，某些其他的对象做出相应的改变。做到这一点的设计方案有很多，但是为了使系统能够易于复用，应该选择低耦合度的设计方案。减少对象之间的耦合有利于系统的复用，但是同时设计师需要使这些低耦合度的对象之间能够维持行动的协调一致，保证高度的协作。观察者模式是满足这一要求的各种设计方案中最重要的一种。

　　下面以一个简单的示意性实现为例，讨论观察者模式的结构。

　观察者模式所涉及的角色有：

　　●　　抽象主题(Subject)角色：抽象主题角色把所有对观察者对象的引用保存在一个聚集（比如ArrayList对象）里，每个主题都可以有任何数量的观察者。抽象主题提供一个接口，可以增加和删除观察者对象，抽象主题角色又叫做抽象被观察者(Observable)角色。

　　●　　具体主题(ConcreteSubject)角色：将有关状态存入具体观察者对象；在具体主题的内部状态改变时，给所有登记过的观察者发出通知。具体主题角色又叫做具体被观察者(Concrete Observable)角色。

　　●　　抽象观察者(Observer)角色：为所有的具体观察者定义一个接口，在得到主题的通知时更新自己，这个接口叫做更新接口。

　　●　　具体观察者(ConcreteObserver)角色：存储与主题的状态自恰的状态。具体观察者角色实现抽象观察者角色所要求的更新接口，以便使本身的状态与主题的状态相协调。如果需要，具体观察者角色可以保持一个指向具体主题对象的引用。

实例源码：笔记本电脑价格，就是抽象主题角色，雷神笔记本是具体主题角色，它的价格会随着时间而变动，我想买，我会关注这个笔记本，我就是具体观察者角色，我关注的是价格。

抽象观察者角色：

package com.java.observer;

//抽象观察者角色
public interface Buyer {

	public  void update(String  price);
	
	
}

抽象主题角色：

package com.java.observer;

import java.util.ArrayList;

// 抽象主题角色
public  abstract class ComputerPrice {

	ArrayList<Buyer>    buyers=new ArrayList<Buyer>();
	
	public ComputerPrice() {

	}
//电脑价格的变动
	public abstract void change(String  price);
	
	
	void add(Buyer  b){
		
		buyers.add(b);
	}
	
	void detach(Buyer b){
		
		buyers.remove(b);
	}
	
	void   NotifyBuyers(String  price){
		
		for (Buyer  buyer : buyers) {
			
			buyer.update(price);
		}
		
		
	}
}

具体观察者角色：

package com.java.observer;

public class I implements Buyer {

	//具体观察者角色 我
	public I() {

	}

	@Override
	public void update(String  price) {
	
           System.out.println("我看到雷神笔记本新的价格是："+price+",好想买啊！~买不起呢~~~~(>_<)~~~~ ");
		
	}

}

package com.java.observer;

public class TuHao implements Buyer {

	//具体观察者角色  土豪兄
	public TuHao() {
		
	}

	@Override
	public void update(String price) {
		
		System.out.println("我是土豪，雷神本的价格是"+price+",这么便宜，买买买！！小Case！！");

	}

}

具体主题角色：

package com.java.observer;

public class LeiShen extends ComputerPrice {


	//具体主题角色  雷神游戏本
	
	public LeiShen() {
	
	}

	@Override
	public void change(String price) {
	
          System.out.println("雷神游戏本新的价格："+price);
		 
		this.NotifyBuyers(price);
	}


}

客户端：

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		LeiShen  ls=new LeiShen();
		I i=new I();
		TuHao  tuhao=new TuHao();
		ls.add(i);
		ls.add(tuhao);
		ls.change("9999");
		
	}

运行结果：

雷神游戏本新的价格：9999
我看到雷神笔记本新的价格是：9999,好想买啊！~买不起呢~~~~(>_<)~~~~
我是土豪，雷神本的价格是9999,这么便宜，买买买！！小Case！！

推模型和拉模型

　　在观察者模式中，又分为推模型和拉模型两种方式。

　　●　　推模型

　　　　主题对象向观察者推送主题的详细信息，不管观察者是否需要，推送的信息通常是主题对象的全部或部分数据。

　　●　　拉模型

　　　　主题对象在通知观察者的时候，只传递少量信息。如果观察者需要更具体的信息，由观察者主动到主题对象中获取，相当于是观察者从主题对象中拉数据。一般这种模型的实现中，会把主题对象自身通过update()方法传递给观察者，这样在观察者需要获取数据的时候，就可以通过这个引用来获取了。

　　根据上面的描述，发现前面的例子就是典型的推模型，下面给出一个拉模型的实例。

　　拉模型的抽象观察者类

　　拉模型通常都是把主题对象当做参数传递。(拉模型传进去具体主题角色，需要什么数据，直接获取，推模型，没有选择的权利，直接给你一个信息。)

把上面的推模型改为拉模型：

package com.java.observer;

//抽象观察者角色
public interface Buyer {

	 //主题角色为参数
	public  void update(ComputerPrice  com);
	
	
}

package com.java.observer;

import java.util.ArrayList;

// 抽象主题角色
public abstract class ComputerPrice {

	ArrayList<Buyer> buyers = new ArrayList<Buyer>();

	public ComputerPrice() {

	}

	// 电脑价格的变动
	public abstract void change();

	void add(Buyer b) {

		buyers.add(b);
	}

	void detach(Buyer b) {

		buyers.remove(b);
	}

	void NotifyBuyers() {

		for (Buyer buyer : buyers) {

			buyer.update(this);  //传进去，观察的具体主题角色
		}

	}
}

package com.java.observer;

public class LeiShen extends ComputerPrice {
	
	String price;
	
	String other; //外形等 其他参数
	
	// 具体主题角色 雷神游戏本
	public LeiShen() {

	}
	
	public String getPrice() {
		return price;
	}

	public void setPrice(String price) {
		this.price = price;
	}

	public String getOther() {
		return other;
	}

	public void setOther(String other) {
		this.other = other;
	}

	@Override
	public void change() {
       
		
		System.out.println("雷神游戏本新的价格：" + price);

		this.NotifyBuyers();
	}

}

package com.java.observer;

public class I implements Buyer {

	//具体观察者角色 我
	public I() {

	}

	@Override
	public void update(ComputerPrice com) {
	
		     LeiShen  ls=(LeiShen) com;
		
           System.out.println("我看到雷神笔记本新的价格是："+ls.getPrice()+",好想买啊！~买不起呢~~~~(>_<)~~~~ ,"+ls.getOther());
		   
	}

}

package com.java.observer;

public class TuHao implements Buyer {

	//具体观察者角色  土豪兄
	public TuHao() {
		
	}

	@Override
	public void update(ComputerPrice com) {
		
		LeiShen ls=(LeiShen) com;
		System.out.println("我是土豪，雷神本的价格是"+ls.getPrice()+",这么便宜，买买买！！小Case！！"+ls.getOther());

	}

}

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		LeiShen  ls=new LeiShen();
		I i=new I();
		TuHao  tuhao=new TuHao();
		ls.add(i);
		ls.add(tuhao);
		ls.setOther("外形没有变化，还是那么帅呢！");
		ls.setPrice("9999元");
		ls.change();
		
	}

运行结果：

雷神游戏本新的价格：9999元
我看到雷神笔记本新的价格是：9999元,好想买啊！~买不起呢~~~~(>_<)~~~~ ,外形没有变化，还是那么帅呢！
我是土豪，雷神本的价格是9999元,这么便宜，买买买！！小Case！！外形没有变化，还是那么帅呢！

　两种模式的比较

　　■　　推模型是假定主题对象知道观察者需要的数据；而拉模型是主题对象不知道观察者具体需要什么数据，没有办法的情况下，干脆把自身传递给观察者，让观察者自己去按需要取值。

　　■　　推模型可能会使得观察者对象难以复用，因为观察者的update()方法是按需要定义的参数，可能无法兼顾没有考虑到的使用情况。这就意味着出现新情况的时候，就可能提供新的update()方法，或者是干脆重新实现观察者；而拉模型就不会造成这样的情况，因为拉模型下，update()方法的参数是主题对象本身，这基本上是主题对象能传递的最大数据集合了，基本上可以适应各种情况的需要。

java.util包中提供的Observable类和Observer接口

·被观察者：内部状态有可能被改变，而且又需要通知外部的对象需要继承Observable类

·观察者：需要对内部状态的改变做出响应的对象需要实现Observer接口

观察者想要成为被观察者的观察者，需要调用被观察者的调用addObserver(Observer 观察者) 下面引用作者waldmer的一个例子

<pre name="code" class="java">import java.util.* ;  
class House extends Observable{ // 表示房子可以被观察  
    private float price ;// 价钱  
    public House(float price){  
        this.price = price ;  
    }  
    public float getPrice(){  
        return this.price ;  
    }  
    public void setPrice(float price){  
        // 每一次修改的时候都应该引起观察者的注意  
        super.setChanged() ;    // 设置变化点  
        super.notifyObservers(price) ;// 价格被改变  
        this.price = price ;  
    }  
    public String toString(){  
        return "房子价格为：" + this.price ;  
    }  
};   
class HousePriceObserver implements Observer{  
    private String name ;  
    public HousePriceObserver(String name){ // 设置每一个购房者的名字  
        this.name = name ;  
    }  
    public void update(Observable o,Object arg){  
        if(arg instanceof Float){  
            System.out.print(this.name + "观察到价格更改为：") ;  
            System.out.println(((Float)arg).floatValue()) ;  
        }  
    }  
};  
public class ObserDemo01{  
    public static void main(String args[]){  
        House h = new House(1000000) ;  
        HousePriceObserver hpo1 = new HousePriceObserver("购房者A") ;  
        HousePriceObserver hpo2 = new HousePriceObserver("购房者B") ;  
        HousePriceObserver hpo3 = new HousePriceObserver("购房者C") ;  
        h.addObserver(hpo1) ; //加入成为观察者 
        h.addObserver(hpo2) ;  
        h.addObserver(hpo3) ;  
        System.out.println(h) ; // 输出房子价格  
        h.setPrice(666666) ;    // 修改房子价格   观察者对change做出相应，调用update方法
        System.out.println(h) ; // 输出房子价格  
    }  
};

运行结果：

房子价格为：1000000.0

购房者C观察到价格更改为：666666.0

购房者B观察到价格更改为：666666.0

购房者A观察到价格更改为：666666.0

房子价格为：666666.0