Observer와 Observable은 언제 사용해야합니까?

Observer와 Observable은 언제 사용해야합니까?

---

면접관이 나에게 물었다 :

무엇 Observer과 Observable우리는 그것들을 언제 사용해야합니까?

나는 집으로 가지고와에 대해 인터넷 검색을 시작했다 그렇게 할 때, 이러한 용어를 인식하지이었다 Observer그리고 Observable, 내가 다른 자원에서 몇 가지 포인트를 발견 :

1) Observable클래스이며 Observer인터페이스입니다.

2) Observable클래스는의 목록을 유지합니다 Observer.

3) Observable객체가 업데이트되면 update()각 객체의 메소드를 호출하여 Observer변경되었음을 알립니다.

이 예를 찾았습니다.

import java.util.Observable;
import java.util.Observer;

class MessageBoard extends Observable
{
    public void changeMessage(String message) 
    {
        setChanged();
        notifyObservers(message);
    }
}

class Student implements Observer 
{
    @Override
    public void update(Observable o, Object arg) 
    {
        System.out.println("Message board changed: " + arg);
    }
}

public class MessageBoardTest 
{
    public static void main(String[] args) 
    {
        MessageBoard board = new MessageBoard();
        Student bob = new Student();
        Student joe = new Student();
        board.addObserver(bob);
        board.addObserver(joe);
        board.changeMessage("More Homework!");
    }
}

우리가 필요로하지만 왜 이해가 안 Observer와 Observable? 의 방법 setChanged()과 notifyObservers(message)방법은 무엇입니까?

---

학생과 메시지 게시판의 구체적인 예가 있습니다. 학생은 새 메시지가 MessageBoard에 게시 될 때 알림을받을 관찰자 목록에 자신을 추가하여 등록합니다. MessageBoard에 메시지가 추가되면 Observers 목록을 반복하여 이벤트가 발생했음을 알립니다.

트위터를 생각하십시오. 당신이 누군가를 따르고 싶다고 말하면, 트위터는 당신을 팔로어 목록에 추가합니다. 그들이 새 트윗을 보냈을 때 입력 한 내용을 볼 수 있습니다. 이 경우 Twitter 계정은 관찰자이며 팔로우하는 사람은 관찰자입니다.

트위터가 중재자 일 가능성이 높기 때문에 비유가 완벽하지 않을 수 있습니다. 그러나 그것은 요점을 보여줍니다.

---

매우 간단한 용어로 (다른 답변은 모든 공식 디자인 패턴을 참조하기 때문에 자세한 내용은 해당 패턴을 살펴보십시오).

프로그램 생태계의 다른 클래스에서 모니터링하는 클래스를 원한다면 클래스를 관찰 할 수 있다고 말합니다. 즉, 프로그램의 나머지 부분에 브로드 캐스트하려는 상태의 일부 변경 사항이있을 수 있습니다.

이제 이것을하기 위해서는 어떤 종류의 메소드를 호출해야합니다. 우리는 Observable 클래스가 그것을 관찰하고 싶은 클래스와 밀접하게 결합되는 것을 원하지 않습니다. 특정 기준을 충족하는 한 누구인지 신경 쓰지 않습니다. (이것이 라디오 방송국이라고 상상해보십시오. 주파수에 FM 라디오가 튜닝되어있는 한 누가 듣고 있는지 신경 쓰지 않습니다). 이를 위해 Observer라고하는 인터페이스를 사용합니다.

따라서 Observable 클래스에는 Observer 목록 (예 : 보유한 Observer 인터페이스 메서드를 구현하는 인스턴스)이 있습니다. 무언가를 방송하고 싶을 때마다 모든 관찰자에 대해 메소드를 하나씩 호출합니다.

퍼즐을 닫는 마지막 것은 Observable 클래스가 관심있는 사람을 어떻게 알 수 있는가입니다. 따라서 Observable 클래스는 관찰자가 자신의 관심을 등록 할 수있는 메커니즘을 제공해야합니다. addObserver(Observer o)내부적으로 옵저버를 옵저버 목록에 추가하는 등의 방법으로 중요한 사항이 발생하면 목록을 반복하고 각 인스턴스의 옵저버 인터페이스에 대한 각 알림 메소드를 목록에서 호출합니다.

인터뷰에서 그들은 당신에게 java.util.Observer그리고 java.util.Observable일반적인 개념에 대해 명시 적으로 묻지 않았을 수도 있습니다 . 이 개념은 디자인 패턴으로, Java는 필요할 때 신속하게 구현할 수 있도록 즉시 지원을 제공합니다. 따라서 실제 메소드 / 클래스가 아니라 개념을 이해하는 것이 좋습니다 (필요할 때 찾아 볼 수 있음).

최신 정보

귀하의 의견에 따라 실제 java.util.Observable수업은 다음 시설을 제공합니다.

1. java.util.Observer인스턴스 목록 유지 알림에 관심이있는 새로운 인스턴스는을 통해 추가하고을 통해 addObserver(Observer o)제거 할 수 있습니다 deleteObserver(Observer o).

2. 관찰자에게 마지막 알림 이후에 개체가 변경되었는지 여부를 지정하여 내부 상태 유지 이는 Observable변경 사항을 알리는 부분과 변경 사항을 알리는 부분을 구분하기 때문에 유용합니다 . (예 : 여러 변경 사항이 발생하고 각 작은 단계가 아닌 프로세스 종료시에만 알리려는 경우에 유용합니다). 이것은를 통해 이루어집니다 setChanged(). 그래서 당신이 무언가를 바꿀 때 그것을 부르고 Observable나머지는 Observers결국 그것에 대해 알기 를 원합니다 .

3. 모든 관찰자에게 특정 Observable상태가 변경 되었음을 알립니다 . 이것은를 통해 이루어집니다 notifyObservers(). 이것은 setChanged()알림을 진행하기 전에 객체가 실제로 변경되었는지 (즉, 호출되었는지) 확인합니다 . Object알림과 함께 추가 정보를 전달하려는 경우 인수가 없는 버전과 인수가있는 버전이 있습니다 . 내부적으로 일어나는 일은 Observer인스턴스 목록을 반복 update(Observable o, Object arg)하고 각 인스턴스에 대한 메소드를 호출한다는 것입니다. 이것은 Observer어느 Observable 객체가 변경되었고 (여러 개 이상을 관찰 할 수 있음) Object arg추가 정보를 추가 로 전달할 수있는 추가 정보 (통과)를 나타 notifyObservers()냅니다.

---

정의

관찰자 패턴은 하나의 오브젝트가 수정되고 종속 오브젝트에 자동으로 통지되고 모든 종속 오브젝트에 해당 변경이 수행되는 경우와 같이 오브젝트간에 일대 다 관계가있을 때 사용됩니다.

예

1. 영구 주소가 변경되면 여권 당국과 팬 카드 당국에 알려야합니다. 그래서 여기 여권 당국과 팬 카드 당국은 관찰자이며 당신은 주제입니다.

2. Facebook에서 또한 누군가를 구독하면 새로운 업데이트가 발생할 때마다 알림을받습니다.

사용시기 :

1. 한 개체의 상태가 변경되면 일관성을 유지하기 위해 다른 모든 종속 개체가 자동으로 상태를 변경해야합니다

2. 피험자가 보유한 관찰자 수를 모를 때

3. 개체가 누구인지 모른 채 개체가 다른 개체에 알릴 수 있어야하는 경우

1 단계

주제 클래스를 작성하십시오.

Subject.java

  import java.util.ArrayList;
  import java.util.List;

  public class Subject {

  private List<Observer> observers 
        = new ArrayList<Observer>();
  private int state;

  public int getState() {
    return state;
  }

 public void setState(int state) {
   this.state = state;
   notifyAllObservers();
 }

   public void attach(Observer observer){
     observers.add(observer);       
   }

  public void notifyAllObservers(){
    for (Observer observer : observers) {
     observer.update();
  }
}   

}

2 단계

관찰자 클래스를 작성하십시오.

Observer.java

public abstract class Observer {
   protected Subject subject;
   public abstract void update();
}

3 단계

구체적인 관찰자 클래스 만들기

BinaryObserver.java

public class BinaryObserver extends Observer{

  public BinaryObserver(Subject subject){
     this.subject = subject;
     this.subject.attach(this);
  }

  @Override
  public void update() {
     System.out.println( "Binary String: " 
     + Integer.toBinaryString( subject.getState() ) ); 
  }

}

OctalObserver.java

public class OctalObserver extends Observer{

   public OctalObserver(Subject subject){
     this.subject = subject;
    this.subject.attach(this);
 }

  @Override
  public void update() {
    System.out.println( "Octal String: " 
    + Integer.toOctalString( subject.getState() ) ); 
  }

}

HexaObserver.java

public class HexaObserver extends Observer{

  public HexaObserver(Subject subject){
    this.subject = subject;
    this.subject.attach(this);
 }

  @Override
  public void update() {
     System.out.println( "Hex String: " 
    + Integer.toHexString( subject.getState() ).toUpperCase() ); 
}

}

4 단계

피사체와 콘크리트 관찰자 객체를 사용하십시오.

ObserverPatternDemo.java

 public class ObserverPatternDemo {
    public static void main(String[] args) {
       Subject subject = new Subject();

       new HexaObserver(subject);
       new OctalObserver(subject);
       new BinaryObserver(subject);

       System.out.println("First state change: 15");    
       subject.setState(15);
       System.out.println("Second state change: 10");   
       subject.setState(10);
 }

}

5 단계

출력을 확인하십시오.

최초 상태 변경 : 15

16 진 문자열 : F

8 진 문자열 : 17

이진 문자열 : 1111

두 번째 상태 변경 : 10

16 진 문자열 : A

8 진 문자열 : 12

이진 문자열 : 1010

---

이것은 관찰자 디자인 패턴의 일부입니다 . 일반적으로 하나 이상의 관찰자 에게 관찰 가능한 변경 사항에 대한 정보가 제공됩니다 . 프로그래머가 "무언가"의 의미를 정의 할 수있는 "무언가"가 발생했다는 알림입니다.

이 패턴을 사용할 때 두 엔티티를 서로 분리하면 관찰자가 플러그 가능하게됩니다.

---

Observer a.k.a callback is registered at Observable.

It is used for informing e.g. about events that happened at some point of time. It is widely used in Swing, Ajax, GWT for dispatching operations on e.g. UI events (button clicks, textfields changed etc).

In Swing you find methods like addXXXListener(Listener l), in GWT you have (Async)callbacks.

As list of observers is dynamic, observers can register and unregister during runtime. It is also a good way do decouple observable from observers, as interfaces are used.

---

If the interviewer asks to implement Observer design pattern without using Observer classes and interfaces, you can use the following simple example!

MyObserver as observer interface

interface MyObserver {

    void update(MyObservable o, Object arg);
}

MyObservable as Observable class

class MyObservable
{
    ArrayList<MyObserver> myObserverList = new ArrayList<MyObserver>();

    boolean changeFlag = false;

    public void notifyObservers(Object o)
    {
        if (hasChanged())
        {
            for(MyObserver mo : myObserverList) {
                mo.update(this, o);
            }
            clearChanged();
        }
    }


    public void addObserver(MyObserver o) {
        myObserverList.add(o);        
    }

    public void setChanged() {
        changeFlag = true;
    }

    public boolean hasChanged() {
        return changeFlag;
    }

    protected void clearChanged() {
        changeFlag = false;
    }

    // ...
}

Your example with MyObserver and MyObservable!

class MessageBoard extends MyObservable {
  private String message;

  public String getMessage() {
    return message;
  }

  public void changeMessage(String message) {
    this.message = message;
    setChanged();
    notifyObservers(message);
  }

  public static void main(String[] args) {
    MessageBoard board = new MessageBoard();
    Student bob = new Student();
    Student joe = new Student();
    board.addObserver(bob);
    board.addObserver(joe);
    board.changeMessage("More Homework!");
  }
}

class Student implements MyObserver {

  @Override
  public void update(MyObservable o, Object arg) {
    System.out.println("Message board changed: " + arg);
  }

}

---

"I tried to figure out, why exactly we need Observer and Observable"

As previous answers already stated, they provide means of subscribing an observer to receive automatic notifications of an observable.

One example application where this may be useful is in data binding, let's say you have some UI that edits some data, and you want the UI to react when the data is updated, you can make your data observable, and subscribe your UI components to the data

Knockout.js is a MVVM javascript framework that has a great getting started tutorial, to see more observables in action I really recommend going through the tutorial. http://learn.knockoutjs.com/

I also found this article in Visual Studio 2008 start page (The Observer Pattern is the foundation of Model View Controller (MVC) development) http://visualstudiomagazine.com/articles/2013/08/14/the-observer-pattern-in-net.aspx

---

I have written a short description of the observer pattern here: http://www.devcodenote.com/2015/04/design-patterns-observer-pattern.html

A snippet from the post:

Observer Pattern : It essentially establishes a one-to-many relationship between objects and has a loosely coupled design between interdependent objects.

TextBook Definition: The Observer Pattern defines a one-to-many dependency between objects so that when one object changes state, all of its dependents are notified and updated automatically.

Consider a feed notification service for example. Subscription models are the best to understand the observer pattern.

---

Observer pattern is used when there is one-to-many relationship between objects such as if one object is modified, its dependent objects are to be notified automatically.

---

Since Java9, both interfaces are deprecated, meaning you should not use them anymore. See Observer is deprecated in Java 9. What should we use instead of it?

However, you might still get interview questions about them...

참고URL : https://stackoverflow.com/questions/13744450/when-should-we-use-observer-and-observable