The observer mode is the publish subscribe mode. The publisher publishes information and the subscriber obtains information. When a publisher changes its state, subscribers who depend on it are notified and automatically updated.

Role partition

Abstract observer role: provides an interface for adding, deleting, and notifying observers.
Specific role of the observed: save all the observed objects with a set to realize the function of adding, deleting and notifying the observer.
Abstract observer role: define an interface for all concrete observers and update themselves when they are notified of a topic.
Specific observer role: the update interface needed to implement the abstract observer role.

Class diagram

Code example

Abstract observer role: observable

public interface Obverable {
    public void registObserver(Observer observer);
    public void removeObserver(Observer observer);
    public void notifyObserver();
}

Specific observed role: Magazine

public class Magazine implements Obverable {

    private List<Observer> observers = new ArrayList<Observer>();
    private String msg;

    @Override
    public void registObserver(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObserver() {
        for (Observer observer: observers) {
            observer.update(msg);
        }
    }

    public void publishNews(String msg) {
        this.msg = msg;
        this.notifyObserver();
    }
}

Abstract Observer role: Observer

public interface Observer {
    public void update(String msg);
}

Specific observer roles: reader a, reader B, reader C

public class ReaderA implements Observer {
    @Override
    public void update(String msg) {
        System.out.println("ReaderA, msg="+msg);
    }
}

public class ReaderB implements Observer {
    @Override
    public void update(String msg) {
        System.out.println("ReaderB, msg="+msg);
    }
}

public class ReaderC implements Observer {
    @Override
    public void update(String msg) {
        System.out.println("ReaderC, msg="+msg);
    }
}

Call Magazine in ObserverTest and register Reader. After Magazine releases the message, each Reader can receive the message.

public class ObserverTest {

    public static void main(String[] args) {
        Magazine magazine = new Magazine();
        ReaderA readerA = new ReaderA();
        ReaderB readerB = new ReaderB();
        ReaderC readerC = new ReaderC();
        magazine.registObserver(readerA);
        magazine.registObserver(readerB);
        magazine.registObserver(readerC);
        magazine.publishNews("msg1");
        magazine.removeObserver(readerA);
        magazine.publishNews("msg2");
    }
}

The operation results are as follows:
ReaderA, msg=msg1
ReaderB, msg=msg1
ReaderC, msg=msg1
ReaderB, msg=msg2
ReaderC, msg=msg2