How to implement observer pattern in JAVA

Concept

The observer pattern is also called publish-subscribe pattern. It is a one-to-many relationship between objects. When the state of an object changes , all objects that depend on it are notified and automatically updated

Composition

Abstract theme role (Subject)

Also called abstract target class, the abstract subject knows which observers it has, and provides methods to delete and add observers and abstract methods to notify observers , which are determined by abstract classes or Interface implementation

Abstract Observer role (Observer)

contains an updated abstract method, called when receiving an update notification from a specific subject, implemented by an abstract class or interface

Concrete subject role (Concrete Subject)

Also called the specific target class, it implements the notification method of the abstract target class. When the specific topic changes, it notifies all observers who subscribe to itself

Specific Observer role (Concrete Observer)

Abstract method to implement the abstract observer role, Change its own status after receiving the topic change notification

Implementation

Abstract ObserverObserverInterface

Contains an observer method to receive notifications and change its own status

public interface Observer {
	//收到通知，改变自身状态
    void update();
}

Specific observersObserverOne and ObserverTwo

Implement the update method in the Observer interface

public class ObserverOne implements Observer{
    @Override
    public void update() {
        System.out.println("第一个观察者收到通知，状态更新了");
    }
}

public class ObserverTwo implements Observer {
    @Override
    public void update() {
        System.out.println("第二个观察者收到通知，状态更新了");
    }
}

SubjectInterface

Contains methods to add, delete, and notify observers, It is implemented by the abstract target class, and there is also a method of its own operation, which is implemented by the specific target class

public interface Subject {
    //添加观察者
    void add(Observer observer);
    //删除观察者
    void remove(Observer observer);
    //通知所有观察者
    void notifyObservers();
    //自身操作
    void operation();
}

Abstract target classAbstractSubject

Abstract class , because the number of observers is not fixed, use Vector dynamic array to store observers and implement the add, remove, notifyObservers methods in the Subject interface. The operation method is implemented by the specific target class

public abstract class AbstractSubject implements Subject{
    Vector<Observer> vector = new Vector<Observer>();
    @Override
    public void add(Observer observer){
        vector.add(observer);
    }
    @Override
    public void remove(Observer observer){
        vector.remove(observer);
    }
    @Override
    public void notifyObservers(){
        for (Observer observer : vector) {
            observer.update();
        }
    }
}

Specific target classMySubject

Inherit the AbstractSubject class, implement the operation method, and call the notifyObservers method in the operation method to Achieve the effect of notifying observers after its own state changes

public class MySubject extends AbstractSubject{
    @Override
    public void operation() {
        System.out.println("具体目标状态改变");
        System.out.println("正在通知观察者。。。");
        notifyObservers();
        System.out.println("通知完毕！");
    }
}

Test classTest

public class Test {
    public static void main(String[] args) {
        MySubject mySubject = new MySubject();
        mySubject.add(new ObserverOne());
        mySubject.add(new ObserverTwo());
        mySubject.operation();
    }
}

Summary

What problems does the observer pattern mainly solve

Under low coupling conditions, when the state of an object changes, other objects will receive notifications

When to use the observer pattern

When the state of an object changes, all dependent objects will receive broadcast notifications

Advantages of the observer pattern

The observer and the target are abstractly coupled, low coupling, and a set of trigger mechanisms

Disadvantages of the observer pattern

• ①If there are many direct observers and indirect observers that depend on a target, it will take a lot of time to notify all observers

• ②If there are many direct observers and indirect observers in a target If there are cyclic dependencies, cyclic calls may occur, causing the system to crash

• ③The observer cannot know how the target state changes, only that the target state has changed

Notes on the Observer Pattern

• ①There are already support classes for the Observer Pattern in JAVA and can be used directly

• ②Avoid circular calls

• ③If the update method of the observer is executed sequentially, an observer error will cause the system to get stuck. Generally, asynchronous is used Way.

The above is the detailed content of How to implement observer pattern in JAVA. For more information, please follow other related articles on the PHP Chinese website!