Java 23种设计模式（18.行为型模式- 观察者模式）

我不是女神ヾ 2024-03-27 11:52 87阅读 0赞

> ## 行为型模式-`观察者模式` ##

## 代码解析 ##

### 类图 ###

![在这里插入图片描述][cbc22b92c148453da5e78a26dbd56ad2.png]

### 代码 ###

abstract class Observer {
        
        abstract void update();
    }

public class ConcreteObserver extends Observer{
        
    
        private String name;
        private String observerState;
        private ConcreteSubject subject;
    
        public ConcreteObserver(String name, ConcreteSubject subject) {
        
            this.name = name;
            this.subject = subject;
        }
    
        @Override
        void update() {
        
            observerState=subject.getSubjectState();
            System.out.println("观察者"+name+"的状态是"+observerState);
    
        }
    
        public ConcreteSubject getSubject() {
        
            return subject;
        }
    
        public void setSubject(ConcreteSubject subject) {
        
            this.subject = subject;
        }
    }

abstract class Subject {
        
        abstract void attach(Observer observer);
        abstract void detach(Observer observer);
        abstract void notice();
    
    }

public class ConcreteSubject extends Subject{
        
        private String subjectState;
        private List<Observer> list = new ArrayList<>();
    
        public String getSubjectState() {
        
            return subjectState;
        }
    
        public void setSubjectState(String subjectState) {
        
            this.subjectState = subjectState;
        }
    
        @Override
        public void attach(Observer observer) {
        
            list.add(observer);
        }
    
        @Override
        public void detach(Observer observer) {
        
            list.remove(observer);
    
        }
    
        public void notice() {
        
            for(Observer o: list){
        
                o.update();
    
            }
    
        }
    }

public class Client {
        
        public static void main(String[] args) {
        
            ConcreteSubject subject = new ConcreteSubject();
    
    
            ConcreteObserver user1 = new ConcreteObserver("Amy",subject);
            ConcreteObserver user2 = new ConcreteObserver("LiLi",subject);
            subject.attach(user1);
            subject.attach(user2);
            subject.setSubjectState("hobbies");
            subject.notice();
    
        }
    }

### 运行结果 ###

观察者Amy的状态是hobbies
    观察者LiLi的状态是hobbies

## 1.概述 ##

定义：

又被称为`发布-订阅（Publish/Subscribe）模式`，它定义了`一种一对多的依赖关系`，让多个观察者对象同时监听某一个主题对象。**这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己**。

## 2.结构 ##

在观察者模式中有如下角色：

● `Subject`：`抽象主题（抽象被观察者）`，抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。  
● `ConcreteSubject`：`具体主题（具体被观察者`），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。  
●`Observer`：`抽象观察者`，是观察者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。  
● `ConcrereObserver`：`具体观察者`，实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。

## 3.类图 ##

【例】微信公众号

在使用微信公众号时，大家都会有这样的体验，当你关注的公众号中有新内容更新的话，它就会推送给关注公众号的微信用户端。我们使用观察者模式来模拟这样的场景，微信用户就是观察者，微信公众号是被观察者，有多个的微信用户关注了程序猿这个公众号。

![在这里插入图片描述][8d92faa0825348bda7b9192fe057817a.png]

## 4.代码 ##

public interface Observer {
        
        abstract void update(String message);
    }

public class WeiXinUser implements Observer {
        
        private String name;// 微信用户名
    
        public WeiXinUser(String name) {
        
            this.name = name;
        }
        @Override
        public void update(String message) {
        
            System.out.println(name+": you receive a new message");
        }
    }

public interface Subject {
        
        abstract void attach(Observer observer);//增加订阅者
        abstract void detach (Observer observer);//删除订阅者
        abstract void notify(String message);//通知订阅者更新消息
    }

public class SubscriptionSubject implements Subject{
        
    
        private List<Observer> weixinUserList = new ArrayList<>();//储存订阅公众号的微信用户
        @Override
        public void attach(Observer observer) {
        
            weixinUserList.add(observer);
        }
    
        @Override
        public void detach(Observer observer) {
        
            weixinUserList.remove(observer);
        }
    
        @Override
        public void notify(String message) {
        
            for(Observer observer:weixinUserList) {
        
                observer.update(message);
            }
        }
    }

public class Client {
        
        public static void main(String[] args) {
        
            SubscriptionSubject subscriptionSubject = new SubscriptionSubject();
    
            WeiXinUser user1 = new WeiXinUser("Amy");//创建微信用户
            WeiXinUser user2 = new WeiXinUser("LiLi");
            WeiXinUser user3 = new WeiXinUser("David");
    
            subscriptionSubject.attach(user1);//订阅公众号
            subscriptionSubject.attach(user2);
            subscriptionSubject.attach(user3);
    
            subscriptionSubject.notify("hello world");//公众号更新发出消息给订阅的微信用户
    
        }
    }

Amy: you receive a new message
    LiLi: you receive a new message
    David: you receive a new message

## 5.优缺点 ##

**优点：**

● **降低了目标与观察者之间的耦合关系**，**两者之间是抽象耦合关系**。  
● 被观察者发送通知，所有注册的观察者都会收到信息【可以实现广播机制】

**缺点：**

● 如果观察者非常多的话，那么所有的观察者收到被观察者发送的通知会耗时  
● **如果被观察者有循环依赖的话，那么被观察者发送通知会使观察者循环调用，会导致系统崩溃**

## 6. 使用场景 ##

● 对象间存在一对多关系，一个对象的状态发生改变会影响其他对象。  
● 当一个抽象模型有两个方面，其中一个方面依赖于另一方面时。

## 7.源码解析 ##

在 Java 中，通过 `java.util.Observable`类和 `java.util.Observer`接口定义了观察者模式，只要实现它们的子类就可以编写观察者模式实例。

### 1.Observable类 ###

Observable 类是抽象目标类（被观察者），它有一个 **Vector 集合成员变量**，用于保存所有要通知的观察者对象，下面来介绍它最重要的 3 个方法。

● `void addObserver(Observer o)`方法：用于将新的观察者对象添加到集合中。  
● `void notifyObservers(Object arg)`方法：调用集合中的所有观察者对象的 update方法，通知它们数据发生改变。通常越晚加入集合的观察者越先得到通知。  
● `void setChange()`方法：用来设置一个 boolean 类型的内部标志，注明目标对象发生了变化。当它为true时，notifyObservers() 才会通知观察者。

### 2.Observer 接口 ###

**Observer 接口是抽象观察者**，它监视目标对象的变化，当目标对象发生变化时，观察者得到通知，并调用 update 方法，进行相应的工作。

小偷是一个被观察者，所以需要继承Observable类

public class Thief extends Observable {
        
        private String name;
    
        public Thief(String name) {
        
            this.name = name;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
        public void steal(){
        
            System.out.println("小偷："+name+"偷东西了，有没有人来抓我！！！");
            super.setChanged();
            super.notifyObservers();
        }
    }

警察是一个观察者，所以需要让其实现Observer接口

public class Policemen implements Observer {
        
        private String name;
    
        public Policemen(String name) {
        
            this.name = name;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        @Override
        public void update(Observable o, Object arg) {
        
            System.out.println("警察：" + ((Thief) o).getName() + "，我已经盯你很久了，你可以保持沉默，但你所说的将成为呈堂证供！！！");
    
        }
    }

public class Client {
        
        public static void main(String[] args) {
        
            Thief t = new Thief(("LaoWang"));
            Policemen p = new Policemen("ZhangPolice");
            t.addObserver(p);
            t.steal();
        }
    
    }

[cbc22b92c148453da5e78a26dbd56ad2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/b9c86320189943e7907fe3081701c19c.png
[8d92faa0825348bda7b9192fe057817a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/27/ce7637c00f1f480595bc2920b2a487f0.png