小谈设计模式（15）—观察者模式

拼搏现实的明天。 2023-10-16 17:22 30阅读 0赞

#### 小谈设计模式（15）—观察者模式 ####

*  专栏介绍
 *   *  专栏地址
     *  专栏介绍
 *  观察者模式
 *   *  核心思想
     *  主要角色
     *   *  Subject（被观察者）
         *  ConcreteSubject（具体被观察者）
         *  Observer（观察者）
         *  ConcreteObserver（具体观察者）
     *  Java程序实现
     *   *  输出结果
         *  程序分析
     *  优缺点分析
     *   *  优点
         *   *  解耦性
             *  可扩展性
             *  一对多关系
         *  缺点
         *   *  观察者过多
             *  循环依赖
             *  更新顺序问题
     *  总结

## 专栏介绍 ##

### 专栏地址 ###

[link][]

### 专栏介绍 ###

主要对目前市面上常见的23种设计模式进行逐一分析和总结，希望有兴趣的小伙伴们可以看一下，会持续更新的。希望各位可以监督我，我们一起学习进步，加油，各位。  
![在这里插入图片描述][38ea20286ec440afa5f8fa41f09528d6.png]

## 观察者模式 ##

观察者模式（Observer Pattern）是一种行为型设计模式，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象，当主题对象发生变化时，它的所有观察者都会收到通知并更新自己。

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

### 核心思想 ###

将观察者和被观察者之间的依赖关系解耦，使其彼此之间可以独立变化。被观察者只需要知道观察者实现了某个接口，而不需要知道具体的观察者类，同样，观察者只需要知道被观察者实现了某个接口，而不需要知道具体的被观察者类。  
![在这里插入图片描述][6673dd5da2a44cb7b5bf660ce147b48a.png]

### 主要角色 ###

#### Subject（被观察者） ####

定义了被观察者的接口，包含注册观察者、移除观察者和通知观察者的方法。

#### ConcreteSubject（具体被观察者） ####

实现了被观察者接口，维护观察者列表，并在状态发生改变时通知观察者。

#### Observer（观察者） ####

定义了观察者的接口，包含更新方法，用于接收被观察者的通知。

#### ConcreteObserver（具体观察者） ####

实现了观察者接口，具体实现更新方法，在接收到被观察者的通知时进行相应的处理。  
![在这里插入图片描述][d08b6e74b26b4b71a15d9d4301f645e6.png]

### Java程序实现 ###

// 定义观察者接口
    interface Observer {
        
        void update(String message);
    }
    
    // 定义被观察者接口
    interface Subject {
        
        void registerObserver(Observer observer);
        void removeObserver(Observer observer);
        void notifyObservers(String message);
    }
    
    // 具体观察者类
    class ConcreteObserver implements Observer {
        
        private String name;
    
        public ConcreteObserver(String name) {
        
            this.name = name;
        }
    
        @Override
        public void update(String message) {
        
            System.out.println(name + " received message: " + message);
        }
    }
    
    // 具体被观察者类
    class ConcreteSubject implements Subject {
        
        private List<Observer> observers = new ArrayList<>();
    
        @Override
        public void registerObserver(Observer observer) {
        
            observers.add(observer);
        }
    
        @Override
        public void removeObserver(Observer observer) {
        
            observers.remove(observer);
        }
    
        @Override
        public void notifyObservers(String message) {
        
            for (Observer observer : observers) {
        
                observer.update(message);
            }
        }
    }
    
    // 测试代码
    public class ObserverPatternExample {
        
        public static void main(String[] args) {
        
            ConcreteSubject subject = new ConcreteSubject();
            Observer observer1 = new ConcreteObserver("Observer 1");
            Observer observer2 = new ConcreteObserver("Observer 2");
    
            subject.registerObserver(observer1);
            subject.registerObserver(observer2);
    
            subject.notifyObservers("Hello, observers!");
    
            subject.removeObserver(observer2);
    
            subject.notifyObservers("Observer 2 has been removed!");
    
        }
    }

#### 输出结果 ####

Observer 1 received message: Hello, observers!
    Observer 2 received message: Hello, observers!
    Observer 1 received message: Observer 2 has been removed!

#### 程序分析 ####

在上述示例中，我们定义了一个观察者接口（Observer）和一个被观察者接口（Subject）。具体观察者类（ConcreteObserver）和具体被观察者类（ConcreteSubject）实现了对应的接口。  
![在这里插入图片描述][fd5c36dab6f34559bf5b0afcdacfa43e.png]

### 优缺点分析 ###

#### 优点 ####

##### 解耦性 #####

观察者模式可以将观察者和被观察者之间的依赖关系解耦，使得它们可以独立变化。当被观察者发生变化时，只需要通知观察者即可，而不需要知道具体有哪些观察者存在。

##### 可扩展性 #####

观察者模式可以很方便地增加新的观察者，而不需要修改被观察者的代码。这符合开闭原则，使得系统更加灵活和可扩展。

##### 一对多关系 #####

观察者模式可以实现一对多的依赖关系，一个被观察者可以有多个观察者。这样可以方便地实现事件监听、消息订阅等功能。

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

#### 缺点 ####

##### 观察者过多 #####

当观察者过多时，被观察者通知观察者的时间可能会较长，影响系统的性能。

##### 循环依赖 #####

如果观察者和被观察者之间存在循环依赖关系，可能会导致系统出现问题，如死锁等。

##### 更新顺序问题 #####

观察者模式中观察者的更新顺序是不确定的，可能会导致观察者之间的依赖关系出现问题。

### 总结 ###

可以提高系统的灵活性和可扩展性。但同时也需要注意观察者过多、循环依赖和更新顺序等问题，以确保系统的稳定性和性能。在使用观察者模式时，需要根据具体的场景和需求进行权衡和设计。

[link]: http://t.csdn.cn/B1YXg
[38ea20286ec440afa5f8fa41f09528d6.png]: https://img-blog.csdnimg.cn/38ea20286ec440afa5f8fa41f09528d6.png
[c8aa965ff1814de18ef5509f60a0b565.png]: https://img-blog.csdnimg.cn/c8aa965ff1814de18ef5509f60a0b565.png
[6673dd5da2a44cb7b5bf660ce147b48a.png]: https://img-blog.csdnimg.cn/6673dd5da2a44cb7b5bf660ce147b48a.png
[d08b6e74b26b4b71a15d9d4301f645e6.png]: https://img-blog.csdnimg.cn/d08b6e74b26b4b71a15d9d4301f645e6.png
[fd5c36dab6f34559bf5b0afcdacfa43e.png]: https://img-blog.csdnimg.cn/fd5c36dab6f34559bf5b0afcdacfa43e.png
[5de168cf0b4b464a9c97399b1cb384f3.png]: https://img-blog.csdnimg.cn/5de168cf0b4b464a9c97399b1cb384f3.png