Java观察者模式

小咪咪 2022-02-04 13:45 233阅读 0赞

### 文章目录 ###

*  观察者模式(observer)
 *   *  一、概述
     *   *  1.使用的场景
         *  2.UML类图
         *  3.核心角色
         *   *   *  抽象被观察者角色：
                 *  抽象观察者角色：
                 *  具体被观察者角色：
                 *  具体观察者角色：
     *  二、手动实现观察者模式
     *   *  1.定义抽象被观察者角色
         *  2.定义抽象观察者角色
         *  3.定义具体被观察者角色
         *  4.定义具体观察者角色
         *  5.测试
     *  三、Java内置观察者模式实现
     *   *  1.定义具体被观察者
         *  2.定义具体观察者
         *  3.测试
     *  四、开发中的常用场景：

# 观察者模式(observer) #

观察者模式又称为发布/订阅(Publish/Subscribe)模式，在对象之间定义了一对多的依赖，这样一来，当一个对象改变状态，依赖它的对象会收到通知并自动更新。

## 一、概述 ##

### 1.使用的场景 ###

广播机制场景  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDUwMjgwNA_size_16_color_FFFFFF_t_70]  
1.聊天室程序的创建。服务器创建好后，A,B,C三个客户端连上来公开聊天。A向服务器发送数据，服务器端聊天数据改变。我们希望将这些聊天数据分别发给他在线的客户。也就是说，每个客户端需要更新服务器端的数据  
2.网站上，很多人订阅了“java主题”的新闻。当有这个主题新闻时，就会将这些新闻发送给所有订阅的人。  
3.大家一起玩LOL游戏时，服务器需要将每个人的方位变化发送给所有的客户

上面的这些场景，我们都可以使用观察者模式来处理。我们可以把多个订阅者、客户称之为观察者；需要同步给多个订阅者的数据封装到对象中，称之为目标。

### 2.UML类图 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDUwMjgwNA_size_16_color_FFFFFF_t_70 1]

### 3.核心角色 ###

##### 抽象被观察者角色： #####

也就是一个抽象主题，它把所有对观察者对象的引用保存在一个集合中，每个主题都可以有任意数量的观察者。抽象主题提供一个接口，可以增加和删除观察者角色。一般用一个抽象类和接口来实现。

##### 抽象观察者角色： #####

为所有的具体观察者定义一个接口，在得到主题通知是更新自己。

##### 具体被观察者角色： #####

也就是一个具体的主题，在集体主题的内部状态改变时，所有登记过的观察者发出通知。

##### 具体观察者角色： #####

实现抽象观察者角色所需要的更新接口，一边使本事的状态与绘图的状态相协调。

## 二、手动实现观察者模式 ##

### 1.定义抽象被观察者角色 ###

package com.sxt.observer;
    
    import java.util.ArrayList;
    import java.util.List;
    /**
     * 观察者模式：目标对象模板
     * @author IF
     *
     */
    public interface Subject<T> {
    	// 存储订阅者
    	List<Observer> list = new ArrayList<>();
    	// 注册订阅者
    	public void registerObserver(T obs);
    	// 移除订阅者
    	public void removeObserver(T obs);
    	//通知所有的观察者更新状态
    	public void notifyAllObservers();
    }

### 2.定义抽象观察者角色 ###

/**
     * 观察者模式:定义观察者 
     * @author IF
     *
     */
    public interface Observer {
    	void  update(Subject subject);
    }

### 3.定义具体被观察者角色 ###

/**
     * 观察者模式:目标对象(主体对象 topic)
     * @author IF
     *
     */
    public class ConcreteSubject implements Subject<Observer> {
    	
    	
    	private int state;
    
    	public int getState() {
    		return state;
    	}
    
    	public void setState(int state) {
    		this.state = state;
    		//主题对象(目标对象)值发生了变化，请通知所有的观察者
    		this.notifyAllObservers();
    	}
    
    	@Override
    	public void notifyAllObservers() {
    		for (Observer obs : list) {
    			// 更新每一个观察者中的信息
    			obs.update(this);
    		}
    	}
    
    	@Override
    	public void registerObserver(Observer obs) {
    		// TODO Auto-generated method stub
    		list.add(obs);
    	}
    
    
    	@Override
    	public void removeObserver(Observer obs) {
    		// TODO Auto-generated method stub
    		list.remove(obs);
    	}
    }

### 4.定义具体观察者角色 ###

package com.sxt.observer;
    
    /**
     * 观察者模式：观察者 实现
     * @author IF
     *
     */
    public class ObserverA implements Observer {
    	
    	//myState需要跟目标对象的state值保持一致！
    	private int myState;   
    	
    	/**
    	 * 更新为和目标对象的值一致
    	 */
    	@Override
    	public void update(Subject subject) {
    		myState = ((ConcreteSubject)subject).getState();
    	}
    
    	public int getMyState() {
    		return myState;
    	}
    	public void setMyState(int myState) {
    		this.myState = myState;
    	}
    }

### 5.测试 ###

package com.sxt.observer;
    
    public class Client {
    	public static void main(String[] args) {
    		//目标对象
    		ConcreteSubject subject = new ConcreteSubject();
    		
    		//创建多个观察者
    		ObserverA  obs1 = new ObserverA();
    		ObserverA  obs2 = new ObserverA();
    		ObserverA  obs3 = new ObserverA();
    		
    		//将这三个观察者添加到subject对象的观察者队伍中
    		subject.registerObserver(obs1);
    		subject.registerObserver(obs2);
    		subject.registerObserver(obs3);
    		
    		
    		//改变subject的状态
    		subject.setState(3000);
    		System.out.println("########################");
    		//我们看看，观察者的状态是不是也发生了变化
    		System.out.println(obs1.getMyState());
    		System.out.println(obs2.getMyState());
    		System.out.println(obs3.getMyState());
    		
    		//改变subject的状态
    		subject.setState(30);
    		System.out.println("########################");
    		//我们看看，观察者的状态是不是也发生了变化
    		System.out.println(obs1.getMyState());
    		System.out.println(obs2.getMyState());
    		System.out.println(obs3.getMyState());
    		
    		//改变subject的状态
    		subject.setState(99);
    		System.out.println("########################");
    		//我们看看，观察者的状态是不是也发生了变化
    		System.out.println(obs1.getMyState());
    		System.out.println(obs2.getMyState());
    		System.out.println(obs3.getMyState());
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDUwMjgwNA_size_16_color_FFFFFF_t_70 2]

## 三、Java内置观察者模式实现 ##

在java.util包中包含有基本的Observer接口和Observer抽象类。功能上和Subject接口和Observer接口类似。不过在使用上，就方便多了，因为许多功能比如说注册，删除，通知观察者的那些功能已经内置好了

### 1.定义具体被观察者 ###

package com.sxt.observer2;
    
    import java.util.Observable;
    
    /**
     * 目标对象
     * 继承 Observable
     * @author IF
     *
     */
    public class ConcreteSubject extends Observable {
    	
    	private int state; 
    	
    	public void set(int s){
    		state = s;  //目标对象的状态发生了改变
    		setChanged();  //表示目标对象已经做了更改
    		notifyObservers(state);  //通知所有的观察者
    	}
    
    	public int getState() {
    		return state;
    	}
    
    	public void setState(int state) {
    		this.state = state;
    	}
    }

观察者只需要继承Observable父类。发送消息的方法执行如下两行代码即可

setChanged();  //表示目标对象已经做了更改
    notifyObservers(state);  //通知所有的观察者

Observable源码对应的是：  
![在这里插入图片描述][20190507211150804.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDUwMjgwNA_size_16_color_FFFFFF_t_70 3]

### 2.定义具体观察者 ###

package com.sxt.observer2;
    
    import java.util.Observable;
    import java.util.Observer;
    /**
     * 观察者模式：观察者(消息订阅者)
     * 实现Observer接口
     * @author IF
     *
     */
    public class ObserverA implements Observer {
    
    	private int myState;
    	
    	@Override
    	public void update(Observable o, Object arg) {
    		myState = ((ConcreteSubject)o).getState();
    	}
    	public int getMyState() {
    		return myState;
    	}
    	public void setMyState(int myState) {
    		this.myState = myState;
    	}
    }

观察者也就是订阅者只需要实现Observer接口并重写相关update方法即可，在目标实现中我们发现触发的时候执行的就是观察者的update方法。

### 3.测试 ###

package com.sxt.observer2;
    
    public class Client {
    	public static void main(String[] args) {
    		//创建目标对象Obserable
    		ConcreteSubject subject = new ConcreteSubject();
    		
    		//创建观察者
    		ObserverA obs1 = new ObserverA();
    		ObserverA obs2 = new ObserverA();
    		ObserverA obs3 = new ObserverA();
    		
    		//将上面三个观察者对象添加到目标对象subject的观察者容器中
    		subject.addObserver(obs1);
    		subject.addObserver(obs2);
    		subject.addObserver(obs3);
    		
    		//改变subject对象的状态
    		subject.set(3000);
    		System.out.println("===============状态修改了！");
    		//观察者的状态发生了变化
    		System.out.println(obs1.getMyState());
    		System.out.println(obs2.getMyState());
    		System.out.println(obs3.getMyState());
    
    		subject.set(600);
    		System.out.println("===============状态修改了！");
    		//观察者的状态发生了变化
    		System.out.println(obs1.getMyState());
    		System.out.println(obs2.getMyState());
    		System.out.println(obs3.getMyState());
    		
    		//移除一个订阅者
    		subject.deleteObserver(obs2);
    		subject.set(100);
    		System.out.println("===============状态修改了！");
    		//观察者的状态发生了变化
    		System.out.println(obs1.getMyState());
    		System.out.println(obs2.getMyState());
    		System.out.println(obs3.getMyState());	
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDUwMjgwNA_size_16_color_FFFFFF_t_70 4]  
这样就实现了官方提供观察者模式，其实这里的Observable和Observer和我们前面定义的Subject和Observer差不多，只是考虑的比较全面罢了。

## 四、开发中的常用场景： ##

1.聊天室程序的，服务器转发给所有客户端  
2.网络游戏（多人联机对战）场景中，服务器将客户端的状态进行分发  
3.邮件订阅  
4.Servlet中，监听器的实现  
5.Android中，广播机制  
6.JDK的AWT中事件处理模型，基于观察者模式的委派事件模型（DelegationEventModel）  
·事件源-----------目标对象  
·事件监听器----------观察者  
7.京东商城中，群发某商品打折信息

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDUwMjgwNA_size_16_color_FFFFFF_t_70]: /images/20220204/342ad0e0c79c472194625ae6ff0ac319.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDUwMjgwNA_size_16_color_FFFFFF_t_70 1]: /images/20220204/82d3a83ecc8e461d8024253cd8e922bc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDUwMjgwNA_size_16_color_FFFFFF_t_70 2]: /images/20220204/4b41ec4601bf4cf09c830e8b615d468f.png
[20190507211150804.png]: /images/20220204/2f97287f360844668d537b199c2ddc03.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDUwMjgwNA_size_16_color_FFFFFF_t_70 3]: /images/20220204/2b4501659ebb416295eea5864b51db85.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDUwMjgwNA_size_16_color_FFFFFF_t_70 4]: /images/20220204/55130cb20a9e4030b6763870252805e2.png