In Java integriertes Beobachtermuster

Ich habe zuvor kurz ein kleines Beispiel für das Beobachtermuster (auch als Publish-Subscribe-Muster bekannt) geschrieben, und dieses Muster wird mittlerweile häufig in Projekten verwendet. Heute werde ich posten, wie man das integrierte Beobachtermuster von Java verwendet.
Die wichtigsten verwendeten Java-APIs sind zwei Klassen:

Observer-Schnittstelle: Observer-Objekt, das Datenänderungen des beobachteten Objekts überwacht und eine entsprechende Reaktion ausführt.

Observable-Klasse: Observable-Objekt, stellt Methoden zum Hinzufügen und Entfernen von Beobachterobjekten bereit und benachrichtigt alle hinzugefügten Beobachterobjekte, wenn die Daten abgeschlossen sind.
Beobachtercodebeispiel:

//Observable是被观察者对象接口，实现该接口就是：目标（被观察者）的具体实现
public class TargetObservable extends Observable {
    // 要观察的数据：消息发生改变时，所有被添加的观察者都能收到通知
    private String message;    
      public String getConent() {        
        return message;
    }    
     public void setMessage(String message) {        
     this.message = message;        
     // 被观察者数据发生变化时，通过以下两行代码通知所有的观察者
        this.setChanged();        
        this.notifyObservers(message);
    }
}

2 Beobachtercodebeispiele:

//Observer对象是观察者，实现Observer的对象就是具体的观察者对象
   public class TargetObserver implements Observer {
    // 定义观察者名称
    private String name;    
      public String getObserverName() {        
          return name;
    }    
          public void setObserverName(String observerName) {        
          this.name = observerName;
    }    
          @Override
    public void update(Observable arg0, Object arg1) {        
          //更新消息数据
        System.out.println(name + "收到了发生变化的数据内容是："
                + ((TargetObservable) arg0).getConent());
    }
}

public class TargetObserver01 implements Observer {
    // 定义观察者名称
    private String name01;    
      public String getObserverName() {        
           return name01;
    }    
           public void setObserverName(String observerName) {        
           this.name01 = observerName;
    }    
           @Override
    public void update(Observable arg0, Object arg1) {        
           //更新消息数据
        System.out.println(name01 + "收到了发生变化的数据内容是："
                + ((TargetObservable) arg0).getConent());
    }
}

Testcode:

public static void main(String[] args) {        
// 创建一个具体的被 观察者
        TargetObservable observable = new TargetObservable();        
        // 创建第一个观察者
        TargetObserver one = new TargetObserver();
        one.setObserverName("我是观察者A");        
        // 创建第二个观察者
        TargetObserver01 two = new TargetObserver01();
        two.setObserverName("我是观察者B");        
        // 注册观察者
        observable.addObserver(one);
        observable.addObserver(two);        
        // 目标更新天气情况
        observable.setMessage("***我要更新的数据***");
    }

}

Ausführungsergebnis:
Ich bin Beobachter B und habe den geänderten Dateninhalt erhalten: —-Die Daten, die ich aktualisieren möchte —-
Ich bin Beobachter A und habe den geänderten Dateninhalt erhalten: —-Ich möchte Daten aktualisieren ——
Mustervorteile :
Ein Beobachter kann mehreren Beobachtern entsprechen. Wenn sich das beobachtete Objekt ändert, kann er die Nachricht allen hinzugefügten Beobachtern mitteilen. Die schnittstellenbasierte Implementierung bietet eine größere Flexibilität für Programme.
Achten Sie bei der Verwendung jedoch darauf, Beobachterobjekte rechtzeitig und entsprechend den Bedingungen hinzuzufügen oder zu entfernen, da es sonst zu unerwarteten Ergebnissen kommen kann.
Fügen Sie abschließend den Originalcode von Observer und Observable hinzu, damit wir wissen, wie wir mit dem Schreiben beginnen sollen:

package java.util;
import java.util.Observable;
public interface Observer {
    void update(Observable var1, Object var2);
}

package java.util;
import java.util.Observer;
import java.util.Vector;
public class Observable {
    private boolean changed = false;    
      private Vector<Observer> obs = new Vector();    
      public Observable() {
    }    
      public synchronized void addObserver(Observer var1) {        
      if(var1 == null) {            
      throw new NullPointerException();
        } else {            
             if(!this.obs.contains(var1)) {                
             this.obs.addElement(var1);
            }

        }
    }    
             public synchronized void deleteObserver(Observer var1) {        
                this.obs.removeElement(var1);
    }    
             public void notifyObservers() {        
                this.notifyObservers((Object)null);
    }      
             public void notifyObservers(Object var1) {
                Object[] var2;        
                    synchronized(this) {            
                       if(!this.changed) {                
                          return;
            }

            var2 = this.obs.toArray();            
                          this.clearChanged();
        }        
                  for(int var3 = var2.length - 1; var3 >= 0; --var3) {
              ((Observer)var2[var3]).update(this, var1);
        }

    }    
                  public synchronized void deleteObservers() {        
                  this.obs.removeAllElements();
    }    
                  protected synchronized void setChanged() {        
                  this.changed = true;
    }    
                  protected synchronized void clearChanged() {        
                  this.changed = false;
    }    
                  public synchronized boolean hasChanged() {        
                  return this.changed;
    }    
                  public synchronized int countObservers() {        
                  return this.obs.size();
    }
}