目录

• • • • • 1. 说明
        • 2. 应用场景
        • 3. 结构图
        • 4. 构成
        • 5. 优缺点
        • • 5.1 优点
          • 5.2 缺点
          • 6. java示例

            1. 说明

            • 1.定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
            • 2.也称为模型-视图模式、源-收听者模式或从属者模式。

              2. 应用场景

              • 1.当一个抽象模型有两个方面，其中一个方面依赖于另一方面时，可以将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。
              • 2.当对一个对象的改变需要同时改变其他对象，而不知道具体有多少对象需要被改变时。
              • 3.当一个对象必须通知其他对象，而它又不能假定其他对象是谁时，即不希望这些对象是紧密耦合的。

                3. 结构图

                4. 构成

                • 1.Subject（目标、抽象主题）：知道它的观察者，可以有任意多个观察者观察同一个目标；提供注册和删除观察者对象的接口。
                • 2.Observer（观察者）：为那些目标发生改变时需获得通知的对象定义一个更新接口。
                • 3.ConcreteSubject（具体目标）：将有关状态存入各ConcreteObserver对象；当它的状态发生改变时，向它的各个观察者发出通知。
                • 4.ConcreteObserver（具体观察者）：维护一个指向ConcreteSubject对象的引用；存储有关状态，这些状态应与目标的状态保持一致；实现Observer的更新接口，以使自身状态与目标的状态保持一致。

                  5. 优缺点

                  5.1 优点

                  • 1.解耦：观察者和被观察的对象之间是抽象耦合的。这意味着观察者不需要知道具体有多少个被观察者，只需要知道观察者接口即可。同样，被观察者也不需要知道具体有多少个观察者正在观察它。
                  • 2.支持广播通信：当被观察者对象的状态发生变化时，会通知所有注册的观察者对象，实现了一对多的依赖关系管理，无须知道每一个观察者对象，只需维持一个观察者列表。
                  • 3.符合开闭原则：可以在不修改现有代码的情况下增加新的观察者，只需要实现观察者接口并注册到被观察者即可。
                  • 4.支持异步响应：被观察者可以异步地通知观察者，这样观察者可以根据自己的需要决定何时响应。

                    5.2 缺点

                    • 1.性能问题：当观察者模式被滥用时，可能会导致性能问题。例如，当被观察者状态改变时，如果有很多观察者需要被通知，那么可能会消耗大量的系统资源。
                    • 2.循环依赖：如果观察者之间也存在相互依赖的关系，可能会导致循环依赖的问题，使得系统变得复杂且难以维护。
                    • 3.可能引发内存泄漏：如果观察者没有正确地注销自己，那么即使应用程序的其他部分不再需要该观察者，它也可能仍然保持活动状态，从而占用不必要的内存。
                    • 4.依赖关系不明确：由于观察者和被观察者之间的依赖关系是动态的，这可能导致系统的依赖关系变得不明确和难以跟踪。

                      6. java示例

                      • 1.抽象目标类

                        package com.learning.observer.product_price;
                        /**
                         * 抽象目标
                         * 注册、移除、通知观察者
                         * 修改产品价格
                         */
                        public interface Subject {
                            void registerObserver(Observer observer);
                            void removeObserver(Observer observer);
                            void notifyObservers();
                            void setPrice(double price);
                            double getPrice();
                        }
                        

                        • 2.具体目标

                          package com.learning.observer.product_price;
                          import java.util.ArrayList;
                          import java.util.List;
                          /**
                           * 具体目标
                           */
                          public class ConcreteSubject implements Subject {
                              private List observers = new ArrayList<>();
                              private double price;
                              @Override
                              public void registerObserver(Observer observer) {
                                  observers.add(observer);
                              }
                              @Override
                              public void removeObserver(Observer observer) {
                                  observers.remove(observer);
                              }
                              @Override
                              public void notifyObservers() {
                                  for (Observer observer : observers) {
                                      observer.update(this);
                                  }
                              }
                              @Override
                              public void setPrice(double price) {
                                  this.price = price;
                                  // 价格变动时通知所有观察者
                                  notifyObservers();
                              }
                              @Override
                              public double getPrice() {
                                  return price;
                              }
                          }
                          

                          • 3.抽象观察者

                            package com.learning.observer.product_price;
                            /**
                             * 抽象观察者
                             */
                            public interface Observer {
                                void update(Subject subject);
                            }
                            

                            • 4.具体观察者

                              package com.learning.observer.product_price;
                              /**
                               * 具体观察者
                               */
                              public class ConcreteObserver implements Observer {
                                  private String name;  
                                
                                  public ConcreteObserver(String name) {  
                                      this.name = name;  
                                  }  
                                
                                  @Override  
                                  public void update(Subject subject) {  
                                      ConcreteSubject product = (ConcreteSubject) subject;  
                                      System.out.println(name + " 收到通知，商品 " + product.getClass().getSimpleName() + " 的价格已变更为 " + product.getPrice());  
                                  }  
                              }
                              

                              • 5.客户端

                                package com.learning.observer.product_price;
                                public class Client {
                                    public static void main(String[] args) {  
                                        ConcreteSubject product = new ConcreteSubject();  
                                  
                                        Observer user1 = new ConcreteObserver("用户1");  
                                        Observer user2 = new ConcreteObserver("用户2");  
                                  
                                        product.registerObserver(user1);  
                                        product.registerObserver(user2);  
                                  
                                        // 模拟商品价格变动  
                                        product.setPrice(100.0);  
                                  
                                        // 用户不再关注商品，取消订阅  
                                        product.removeObserver(user1);  
                                  
                                        // 再次模拟商品价格变动  
                                        product.setPrice(150.0);  
                                    }  
                                }
                                

                                • 6.示例截图