Java 내장 관찰자 패턴

이전에 관찰자 패턴(게시-구독 패턴이라고도 함)의 작은 예를 간략하게 작성했는데, 이제 이 패턴이 프로젝트에서 일반적으로 사용됩니다. 오늘은 자바 내장 옵저버 패턴 사용법을 포스팅하겠습니다.
사용되는 주요 Java API는 두 가지 클래스입니다.

관찰자 인터페이스: 관찰된 개체의 데이터 변경을 모니터링하는 관찰자 개체는 데이터가 변경되면 그에 따라 응답합니다.

Observable 클래스: Observable 객체로, 관찰자 ​​객체를 추가 및 제거하는 메소드를 제공하고, 데이터가 완료되면 추가된 모든 관찰자 객체에 이를 알립니다.
옵저버 코드 예시:

//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개:

//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());
    }
}

테스트 코드:

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("***我要更新的数据***");
    }

}

실행 결과:
나는 관찰자 B이고 변경된 데이터 내용을 받았습니다: —-업데이트하려는 데이터 —-
나는 관찰자 A이고 변경된 데이터 내용을 받았습니다: —-데이터를 업데이트하고 싶습니다. ——
패턴 장점 :
한 명의 관찰자가 여러 명의 관찰자에 대응할 수 있으며, 관찰 대상이 변경되면 추가된 모든 관찰자에게 메시지를 알릴 수 있습니다. 인터페이스 기반 구현은 프로그램에 더 큰 유연성을 제공합니다.
그러나 사용 시에는 조건에 따라 시간에 맞춰 관찰자 개체를 추가하거나 제거하도록 주의하세요. 그렇지 않으면 예상치 못한 결과가 발생할 수 있습니다.
마지막으로 Observer 및 Observable의 원본 코드를 첨부하여 작성 시 시작하는 방법을 알 수 있습니다.

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();
    }
}