Java Observer模式如何扩展功能

在Java中，Observer模式是一种行为设计模式，它允许对象（称为观察者）订阅并响应另一个对象（称为主题）的事件。要扩展Observer模式的功能，可以采用以下几种方法：

1. 使用泛型： 通过使用泛型，可以使Observer接口更加通用，从而能够处理不同类型的主题。

   public interface Observer<T> {
       void update(T subject);
   }
   
   public class ConcreteObserver implements Observer<ConcreteSubject> {
       @Override
       public void update(ConcreteSubject subject) {
           // 处理更新
       }
   }
   
   public class ConcreteSubject {
       private List<Observer<ConcreteSubject>> observers = new ArrayList<>();
   
       public void attach(Observer<ConcreteSubject> observer) {
           observers.add(observer);
       }
   
       public void detach(Observer<ConcreteSubject> observer) {
           observers.remove(observer);
       }
   
       public void notifyObservers() {
           for (Observer<ConcreteSubject> observer : observers) {
               observer.update(this);
           }
       }
   }
   

2. 增加通知类型： 可以为主题增加不同的通知类型，观察者可以根据需要订阅特定类型的事件。

   public interface Subject {
       void attach(Observer<Subject> observer, String eventType);
       void detach(Observer<Subject> observer, String eventType);
       void notifyObservers(String eventType);
   }
   
   public class ConcreteSubject implements Subject {
       private Map<String, List<Observer<Subject>>> observers = new HashMap<>();
   
       @Override
       public void attach(Observer<Subject> observer, String eventType) {
           observers.computeIfAbsent(eventType, k -> new ArrayList<>()).add(observer);
       }
   
       @Override
       public void detach(Observer<Subject> observer, String eventType) {
           List<Observer<Subject>> obs = observers.get(eventType);
           if (obs != null) {
               obs.remove(observer);
           }
       }
   
       @Override
       public void notifyObservers(String eventType) {
           List<Observer<Subject>> obs = observers.get(eventType);
           if (obs != null) {
               for (Observer<Subject> observer : obs) {
                   observer.update(this);
               }
           }
       }
   }
   

3. 增加观察者的优先级： 可以为观察者分配优先级，确保高优先级的观察者先收到通知。

   public interface Observer<Subject> extends Comparable<Observer<Subject>> {
       void update(Subject subject);
       int getPriority();
   }
   
   public class ConcreteObserver implements Observer<ConcreteSubject> {
       private int priority;
   
       public ConcreteObserver(int priority) {
           this.priority = priority;
       }
   
       @Override
       public void update(ConcreteSubject subject) {
           // 处理更新
       }
   
       @Override
       public int getPriority() {
           return priority;
       }
   }
   
   public class ConcreteSubject implements Subject {
       private List<Observer<Subject>> observers = new ArrayList<>();
   
       @Override
       public void attach(Observer<Subject> observer, String eventType) {
           observers.add(observer);
           observers.sort(Comparator.comparingInt(Observer::getPriority).reversed());
       }
   
       @Override
       public void detach(Observer<Subject> observer) {
           observers.remove(observer);
       }
   
       @Override
       public void notifyObservers(String eventType) {
           for (Observer<Subject> observer : observers) {
               observer.update(this);
           }
       }
   }
   

4. 使用Lambda表达式： 在Java 8及以上版本中，可以使用Lambda表达式简化观察者的实现。

   public class ConcreteSubject implements Subject {
       private Map<String, List<Consumer<ConcreteSubject>>> observers = new HashMap<>();
   
       @Override
       public void attach(Observer<Subject> observer, String eventType) {
           observers.computeIfAbsent(eventType, k -> new ArrayList<>()).add(observer::update);
       }
   
       @Override
       public void detach(Observer<Subject> observer, String eventType) {
           List<Consumer<ConcreteSubject>> obs = observers.get(eventType);
           if (obs != null) {
               obs.remove(observer::update);
           }
       }
   
       @Override
       public void notifyObservers(String eventType) {
           List<Consumer<ConcreteSubject>> obs = observers.get(eventType);
           if (obs != null) {
               for (Consumer<ConcreteSubject> observer : obs) {
                   observer.accept(this);
               }
           }
       }
   }
   

通过这些方法，可以灵活地扩展Observer模式的功能，使其更加适应不同的应用场景。