观察者模式

观察者模式

 

package com;

public class ConcreteObserver extends Observer{
	private String name;
	private String observerState;
	private ConcreteSubject subject=new ConcreteSubject();
	
	public ConcreteObserver(ConcreteSubject subject,String name){
		this.name=name;
		this.subject=subject;
	}

	@Override
	public void update() {
		// TODO Auto-generated method stub
		observerState=subject.getSubjectState();
		System.out.println("观察者的新状态："+name+" "+observerState);
		
	}

}
*******************************
package com;

public class ConcreteSubject extends Subject{
	private String subjectState;

	public String getSubjectState() {
		return subjectState;
	}

	public void setSubjectState(String subjectState) {
		this.subjectState = subjectState;
	}

	
	

}
*********************************
package com;

public abstract class Observer {
	public abstract void update();

}
********************************
package com;

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

public abstract class Subject {
	//subject可以有多个观察者
	private List<Observer> observers=new ArrayList<Observer>();
	//对观察者的操作
	public void attach(Observer observer){
		observers.add(observer);
	}
	public void detach(Observer observer){
		observers.remove(observer);
	}
	//通知观察者进行更新，调用观察者的方法
	public void notifyToObserver(){
		for(Observer observer:observers){
			observer.update();
		}
	}
	
	

}
**************************
package com;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		ConcreteSubject s=new ConcreteSubject();
		
		s.attach(new ConcreteObserver(s,"x"));
		s.attach(new ConcreteObserver(s, "y"));
		s.attach(new ConcreteObserver(s,"z"));
		s.setSubjectState("abc");
		s.notifyToObserver();

	}

}

 

优点

1. 观察者模式实现了观察者和目标之间的抽象耦合
2.  观察者模式实现了动态联动
3.    观察者模式支持广播通信

 

缺点

1.    观察者模式可能会引起无谓的操作

 

本质

触发联动。

应用场景

建议在如下情况中，选用观察者模式：

• 当一个抽象模型有两个方面，其中一个方面的操作依赖于另一个方面的状态变化，那么就可以选用观察者模式，将这两者封装成观察者和目标对象，当目标对象变化的时候，依赖于它的观察者对象也会发生相应的变化。这样就把抽象模型的这两个方面分离开了，使得它们可以独立的改变和复用。
• 如果在更改一个对象的时候，需要同时连带改变其它的对象，而且不知道究竟应该有多少对象需要被连带改变，这种情况可以选用观察者模式，被更改的那一个对象很明显就相当于是目标对象，而需要连带修改的多个其它对象，就作为多个观察者对象了。
• 当一个对象必须通知其它的对象，但是你又希望这个对象和其它被它通知的对象是松散耦合的，也就是说这个对象其实不想知道具体被通知的对象，这种情况可以选用观察者模式，这个对象就相当于是目标对象，而被它通知的对象就是观察者对象了。

 

相关模式

观察者模式和状态模式
    观察者模式和状态模式是有相似之处的。
    观察者模式是当目标状态发生改变时，触发并通知观察者，让观察者去执行相应的操作。而状态模式是根据不同的状态，选择不同的实现，这个实现类的主要功能就是针对状态的相应的操作，它不像观察者，观察者本身还有很多其它的功能，接收通知并执行相应处理只是观察者的部分功能。
    当然观察者模式和状态模式是可以结合使用的。观察者模式的重心在触发联动，但是到底决定哪些观察者会被联动，这时就可以采用状态模式来实现了，也可以采用策略模式来进行选择需要联动的观察者。

l          观察者模式和中介者模式
    观察者模式和中介者模式是可以结合使用的。
    前面的例子中目标都只是简单的通知一下，然后让各个观察者自己去完成更新就结束了。如果观察者和被观察的目标之间的交互关系很复杂，比如：有一个界面，里面有三个下拉列表组件，分别是选择国家、省份/州、具体的城市，很明显这是一个三级联动，当你选择一个国家的时候，省份/州应该相应改变数据，省份/州一改变，具体的城市也需要改变。

例题：订阅报纸的过程
/**
 * 报纸对象，具体的目标实现
 */
public class NewsPaper extends  java.util.Observable   {
    /**
     * 报纸的具体内容
     */
    private String content;
    /**
     * 获取报纸的具体内容
     * @return 报纸的具体内容
     */
    public String getContent() {
       return content;
    }
    /**
     * 示意，设置报纸的具体内容，相当于要出版报纸了
     * @param content 报纸的具体内容
     */
    public void setContent(String content) {
       this.content = content;
       //内容有了，说明又出新报纸了，那就通知所有的读者
       //注意在用Java中的Observer模式的时候，下面这句话不可少
       this.setChanged();
       //然后主动通知，这里用的是推的方式
       this.notifyObservers(this.content);
       //如果用拉的方式，这么调用
       //this.notifyObservers();
    }
}
/**
 * 真正的读者，为了简单就描述一下姓名
 */
public class Reader implements   java.util.Observer   {
/**
     * 读者的姓名
     */
    private String name;
    public String getName() {
       return name;
    }
    public void setName(String name) {
       this.name = name;
    }
public void update(Observable o, Object obj) {
       //这是采用推的方式
       System.out.println(name
+"收到报纸了，阅读先。目标推过来的内容是==="+obj);
 
//这是获取拉的数据
System.out.println(name
+"收到报纸了，阅读先。主动到目标对象去拉的内容是==="
+((NewsPaper)o).getContent());
    }
}
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("李四");
 
       Reader reader3 = new Reader();
       reader3.setName("王五");
 
       //注册阅读者
       subject.addObserver(reader1);
       subject.addObserver(reader2);
       subject.addObserver(reader3);
 
       //要出报纸啦
       subject.setContent("本期内容是观察者模式");
    }
}

package com;

public class Boss extends Subject{
	public String bossState;

	public String getBossState() {
		return bossState;
	}

	public void setBossState(String bossState) {
		this.bossState = bossState;
	}
	
	

}
********************
package com;

public class NBAObserver extends Observer{
	public NBAObserver(Boss boss,String name){
		this.boss=boss;
		this.name=name;
	}

	@Override
	public void update() {
		// TODO Auto-generated method stub
		this.observerState=boss.bossState;
		System.out.println("看NBA的观察者状态："+name+" "+observerState+"关掉NBA");
		
	}

}
******************
package com;

public abstract class Observer {
	protected String name;
	protected String observerState;
	protected Boss boss=new Boss();
	public abstract void update();
}
*********************
package com;

public class StockObserver extends Observer{

	public StockObserver(Boss boss,String name) {
		super();
		this.name=name;
		this.boss = boss;
	}


	@Override
	public void update() {
		// TODO Auto-generated method stub
		this.observerState=boss.bossState;
		System.out.println("看股票的观察者状态："+name+" "+observerState+"关掉股票");
	}

}
*******************
package com;

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

public abstract class Subject {

	List<Observer> observerList=new ArrayList<Observer>();
	public void attach(Observer observer){
		observerList.add(observer);
	}
	public void detach(Observer observer){
		observerList.remove(observer);
	}
	public void notifyToObserver(){
		for(Observer observer:observerList){
			observer.update();
		}
	}
}
***************
package com;

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Boss boss=new Boss();
		boss.attach(new StockObserver(boss, "小A"));
		boss.attach(new StockObserver(boss, "小B"));
		boss.attach(new NBAObserver(boss, "小C"));
		boss.attach(new NBAObserver(boss, "小D"));
		
		boss.setBossState("老板回来啦！");
		boss.notifyToObserver();

	}

}