This is the 7th day of my participation in the November Gwen Challenge. Check out the details: The last Gwen Challenge 2021
An overview of the
Definition:
Also known as the Publish/Subscribe pattern, it defines a one-to-many dependency that allows multiple observer objects to listen on a subject object simultaneously. The topic object notifies all observer objects of state changes so that they can update themselves automatically.
structure
There are the following roles in Observer mode:
- Abstract topic roles store all observer objects in a collection. Each topic can have any number of observers. Abstract topics provide an interface to add and remove observer objects.
- ConcreteSubject: Concrete topic (concrete observed). This role stores the state in the concrete observer object and notifies all registered observers when the internal state of the concrete topic changes.
- Observer: An abstract class for an Observer that defines an update interface to update itself when notified of a topic change.
- ConcrereObserver: A concrete observer that implements an update interface defined by an abstract observer to update its own state when notified of a topic change.
Case implementation
Wechat official account
In the use of wechat public number, we will have such an experience, when you pay attention to the public number in the new content update, it will be pushed to the wechat user concerned about the public number. We use the observer mode to simulate such a scene. The wechat user is the observer, and the wechat public account is the observed. Multiple wechat users follow the official account of the Program ape.
The class diagram is as follows:
The code is as follows:
Define an abstract observer class that defines an updated method
public interface Observer {
void update(String message);
}
Copy the codeDefine the specific observer class, wechat user is the observer, which implements the update method
public class WeixinUser implements Observer {
// Wechat account name
private String name;
public WeixinUser(String name) {
this.name = name;
}
@Override
public void update(String message) {
System.out.println(name + "-"+ message); }}Copy the codeDefine abstract topic class, provide attach, detach, notify three methods
public interface Subject {
// Add subscribers
public void attach(Observer observer);
// Delete the subscriber
public void detach(Observer observer);
// Notify subscribers of updates
public void notify(String message);
}
Copy the codeWechat public account is a specific theme (specific observed), which stores the wechat users who subscribe to the public account, and implements the method in the abstract theme
public class SubscriptionSubject implements Subject {
// Store wechat users who subscribe to public accounts
private List<Observer> weixinUserlist = new ArrayList<Observer>();
@Override
public void attach(Observer observer) {
weixinUserlist.add(observer);
}
@Override
public void detach(Observer observer) {
weixinUserlist.remove(observer);
}
@Override
public void notify(String message) {
for(Observer observer : weixinUserlist) { observer.update(message); }}}Copy the codeClient program
public class Client {
public static void main(String[] args) {
SubscriptionSubject mSubscriptionSubject=new SubscriptionSubject();
// Create a wechat user
WeixinUser user1=new WeixinUser("Sun Wukong");
WeixinUser user2=new WeixinUser("Pig Wuneng");
WeixinUser user3=new WeixinUser("Sha Wu Jing");
// Subscribe to the public account
mSubscriptionSubject.attach(user1);
mSubscriptionSubject.attach(user2);
mSubscriptionSubject.attach(user3);
// Public account updates send messages to subscribed wechat users
mSubscriptionSubject.notify("The dark Horse column has been updated."); }}Copy the codeThe advantages and disadvantages
1. Advantages:
- The coupling relationship between the target and the observer is abstract.
- The observed sends a notification, all registered observers will receive the message [can implement broadcast mechanism]
2. Disadvantages:
- If there are too many observers, it will take time for all observers to receive the notification sent by the observer
- If the observed has a loop dependency, then the observed sends a notification which causes the observer to loop, causing the system to crash
Usage scenarios
- Objects have a one-to-many relationship. Changes in the state of one object affect other objects.
- When an abstract model has two aspects, one of which depends on the other.
Implementation provided in the JDK
In Java, the Observer pattern is defined through the java.util.Observable class and the java.util.Observer interface, and instances of the Observer pattern can be written by implementing their subclasses.
Class 1, observables
An Observable is an abstract object class. It has a Vector member variable that holds all Observable objects to be notified. Here are three of its most important methods.
-
Void addObserver(Observer O) method: Used to add a new Observer object to the collection.
-
Void notifyObservers(Object ARg) method: Call the update method for all observer objects in the collection, notifying them of data changes. Observers who join the collection later are usually notified first.
-
The void setChange() method: Sets an internal Boolean flag indicating that the target object has changed. When it is true, notifyObservers() notifyObservers.
2, Observer interface
The Observer interface is an abstract Observer that monitors changes in the target object, notifies the Observer when the target object changes, and calls the Update method to do the work accordingly.
The police caught the thief
Police catching thieves can also be implemented using the observer model, where the police are the observers and the thief is the observed. The code is as follows:
The thief is an Observable, so it needs to inherit the Observable class
public class Thief extends Observable {
private String name;
public Thief(String name) {
this.name = name;
}
public void setName(String name) {
this.name = name;
}
public String getName(a) {
return name;
}
public void steal(a) {
System.out.println("Thief: I stole something, have someone to catch me!!");
super.setChanged(); //changed = true
super.notifyObservers(); }}Copy the codeThe police is an Observer, so it needs to implement the Observer interface
public class Policemen implements Observer {
private String name;
public Policemen(String name) {
this.name = name;
}
public void setName(String name) {
this.name = name;
}
public String getName(a) {
return name;
}
@Override
public void update(Observable o, Object arg) {
System.out.println("Policeman:" + ((Thief) o).getName() + ", I have been watching you for a long time, you can keep silent, but anything you say can and will be used against you in a court of law!!"); }}Copy the codeClient code
public class Client {
public static void main(String[] args) {
// Create thief object
Thief t = new Thief("Next door Lao Wang");
// Create a police object
Policemen p = new Policemen("Xiao li");
// Keep the police on the thief
t.addObserver(p);
// Thieves steal thingst.steal(); }}Copy the code