In diesem Artikel wird hauptsächlich das Beispiel der Verwendung des Observer Pattern in JavaDesign Pattern zur Entwicklung eines öffentlichen WeChat-Kontos vorgestellt. Auf das WeChat SDK und andere Teile von Java wird hier nicht näher eingegangen . Konzentrieren Sie sich während des Entwicklungsprozesses nur auf die wesentlichen Teile und die Verkörperung der Vorteile des Beobachtermodus.
Erinnern Sie sich noch daran, wie die Gangster in den Polizeifilmen zusammengearbeitet haben? ? Wenn eine Bande einen Diebstahl begeht, stehen immer ein oder zwei Personen an der Tür Wache. Bei Anzeichen von Unruhen werden die Komplizen sofort benachrichtigt, damit sie sich in Notsituationen zurückziehen können. Vielleicht kennt die Person, die betrügt, nicht unbedingt jeden Komplizen im Inneren; und vielleicht gibt es neue Leute, die den Betrüger nicht kennen. Aber es spielt keine Rolle, dass es keinen Einfluss auf die Kommunikation zwischen ihnen hat, da sie sich bereits auf den Geheimcode geeinigt haben.
Haha, die oben erwähnte Beziehung zwischen dem Beobachter und dem Dieb ist ein lebendiges Beispiel für das Beobachtermuster in der Realität.
Das Observer-Muster wird auch als Publish/Subscribe-Muster bezeichnet. GOF definiert das Beobachtermuster wie folgt: Definieren Sie eine Eins-zu-Viele-Abhängigkeitsbeziehung zwischen Objekten . Wenn sich der Status eines Objekts ändert, werden alle davon abhängigen Objekte benachrichtigt und aktualisiert automatisch.
Hier werde ich zunächst über ein wichtiges Prinzip des objektorientierten Designs sprechen – das Single-Responsibility-Prinzip. Jedes Objekt des Systems sollte sich daher auf eine diskrete Abstraktion innerhalb der Problemdomäne konzentrieren. Im Idealfall macht ein Objekt also nur eine Sache. Dies bringt viele Vorteile in der Entwicklung: Es sorgt für Wiederverwendbarkeit und Wartbarkeit und ist zudem eine gute Grundlage für den Wiederaufbau.
Fast alle Designmuster basieren also auf diesem grundlegenden Designprinzip. Ich denke, der Ursprung des Beobachtermusters sollte in der Verarbeitung von GUI- und Geschäftsdaten liegen, da sich die meisten Beispiele, die das Beobachtermuster jetzt erklären, auf dieses Thema beziehen. Die Anwendung des Beobachtermusters ist jedoch keineswegs auf diesen Aspekt beschränkt.
Nun, das Verständnis von Definitionen erfordert immer Beispiele zur Analyse. Die heutigen WeChat-Dienstkonten sind sehr beliebt. Lassen Sie uns den Beobachtermodus allen vorstellen, die WeChat-Dienstkonten als Hintergrund verwenden.
Sehen Sie sich ein Bild an:
Jeder Benutzer hat die 3 Zeilen im Bild oben, die weggelassen wurden, um das Bild klarer zu machen.
Wie im Bild oben gezeigt, ist das Dienstkonto unser Subjekt und der Benutzer der Beobachter. Lassen Sie uns nun die Funktionen klären:
1. Das Dienstkonto ist das Thema und das Unternehmen sendet Nachrichten
2. Beobachter müssen nur das Thema abonnieren, und neue Nachrichten werden gesendet
3. Wann Sie möchten dies nicht. Wenn Sie Themennachrichten erhalten, melden Sie sich ab
4. Solange das Dienstkonto noch vorhanden ist, wird es immer Leute geben, die sich anmelden
Okay, jetzt werfen wir einen Blick auf das Klassendiagramm des Beobachters Muster:
Der nächste Schritt ist die Codezeit. Wir simulieren ein WeChat 3D-Lotteriedienstkonto und einige Abonnenten.
Beginnen Sie zunächst mit dem Schreiben unseres Themas Schnittstelle und der Beobachterschnittstelle:
package com.zhy.pattern.observer;
/**
* 主题接口，所有的主题必须实现此接口
*
* @author zhy
*
*/
public interface Subject
{
/**
* 注册一个观察着
*
* @param observer
*/
public void registerObserver(Observer observer);
/**
* 移除一个观察者
*
* @param observer
*/
public void removeObserver(Observer observer);
/**
* 通知所有的观察着
*/
public void notifyObservers();
}
package com.zhy.pattern.observer;
/**
* @author zhy 所有的观察者需要实现此接口
*/
public interface Observer
{
public void update(String msg);
}Dann die Implementierungsklasse des 3D-Dienstkontos:
package com.zhy.pattern.observer;
import java.util.ArrayList;
import java.util.List;
public class ObjectFor3D implements Subject
{
private List<observer> observers = new ArrayList<observer>();
/**
* 3D彩票的号码
*/
private String msg;
@Override
public void registerObserver(Observer observer)
{
observers.add(observer);
}
@Override
public void removeObserver(Observer observer)
{
int index = observers.indexOf(observer);
if (index >= 0)
{
observers.remove(index);
}
}
@Override
public void notifyObservers()
{
for (Observer observer : observers)
{
observer.update(msg);
}
}
/**
* 主题更新消息
*
* @param msg
*/
public void setMsg(String msg)
{
this.msg = msg;
notifyObservers();
}
}</observer></observer>Simulation Zwei Benutzer:
package com.zhy.pattern.observer;
public class Observer1 implements Observer
{
private Subject subject;
public Observer1(Subject subject)
{
this.subject = subject;
subject.registerObserver(this);
}
@Override
public void update(String msg)
{
System.out.println("observer1 得到 3D 号码 -->" + msg + ", 我要记下来。");
}
}package com.zhy.pattern.observer;
public class Observer2 implements Observer
{
private Subject subject ;
public Observer2(Subject subject)
{
this.subject = subject ;
subject.registerObserver(this);
}
@Override
public void update(String msg)
{
System.out.println("observer2 得到 3D 号码 -->" + msg + "我要告诉舍友们。");
}
} Es ist ersichtlich, dass das Dienstkonto alle Benutzer verwaltet, die Nachrichten von ihm abonnieren. Wenn das Dienstkonto neue Nachrichten hat, werden alle Benutzer benachrichtigt. Die gesamte Architektur ist lose gekoppelt. Wenn ein neuer Benutzer hinzugefügt wird, muss der Code des Themas nicht geändert werden Daten haben nichts mit dem Thema zu tun;
Schauen Sie sich zum Schluss den Testcode an:
package com.zhy.pattern.observer.test;
import com.zhy.pattern.observer.ObjectFor3D;
import com.zhy.pattern.observer.Observer;
import com.zhy.pattern.observer.Observer1;
import com.zhy.pattern.observer.Observer2;
import com.zhy.pattern.observer.Subject;
public class Test
{
public static void main(String[] args)
{
//模拟一个3D的服务号
ObjectFor3D subjectFor3d = new ObjectFor3D();
//客户1
Observer observer1 = new Observer1(subjectFor3d);
Observer observer2 = new Observer2(subjectFor3d);
subjectFor3d.setMsg("20140420的3D号码是：127" );
subjectFor3d.setMsg("20140421的3D号码是：333" );
}
}Ausgabeergebnis:
observer1 得到 3D 号码 -->20140420的3D号码是：127, 我要记下来。 observer2 得到 3D 号码 -->20140420的3D号码是：127我要告诉舍友们。 observer1 得到 3D 号码 -->20140421的3D号码是：333, 我要记下来。 observer2 得到 3D 号码 -->20140421的3D号码是：333我要告诉舍友们。
Es gibt viele Orte in JDK oder Andorid die den Beobachtermodus implementieren, wie zum Beispiel rief einen Rückruf an.
恭喜你学会了观察者模式，上面的观察者模式使我们从无到有的写出，当然了java中已经帮我们实现了观察者模式，借助于java.util.Observable和java.util.Observer。
下面我们使用Java内置的类实现观察者模式：
首先是一个3D彩票服务号主题：
package com.zhy.pattern.observer.java;
import java.util.Observable;
public class SubjectFor3d extends Observable
{
private String msg ;
public String getMsg()
{
return msg;
}
/**
* 主题更新消息
*
* @param msg
*/
public void setMsg(String msg)
{
this.msg = msg ;
setChanged();
notifyObservers();
}
}下面是一个双色球的服务号主题：
package com.zhy.pattern.observer.java;
import java.util.Observable;
public class SubjectForSSQ extends Observable
{
private String msg ;
public String getMsg()
{
return msg;
}
/**
* 主题更新消息
*
* @param msg
*/
public void setMsg(String msg)
{
this.msg = msg ;
setChanged();
notifyObservers();
}
}最后是我们的使用者：
package com.zhy.pattern.observer.java;
import java.util.Observable;
import java.util.Observer;
public class Observer1 implements Observer
{
public void registerSubject(Observable observable)
{
observable.addObserver(this);
}
@Override
public void update(Observable o, Object arg)
{
if (o instanceof SubjectFor3d)
{
SubjectFor3d subjectFor3d = (SubjectFor3d) o;
System.out.println("subjectFor3d's msg -- >" + subjectFor3d.getMsg());
}
if (o instanceof SubjectForSSQ)
{
SubjectForSSQ subjectForSSQ = (SubjectForSSQ) o;
System.out.println("subjectForSSQ's msg -- >" + subjectForSSQ.getMsg());
}
}
}看一个测试代码：
package com.zhy.pattern.observer.java;
public class Test
{
public static void main(String[] args)
{
SubjectFor3d subjectFor3d = new SubjectFor3d() ;
SubjectForSSQ subjectForSSQ = new SubjectForSSQ() ;
Observer1 observer1 = new Observer1();
observer1.registerSubject(subjectFor3d);
observer1.registerSubject(subjectForSSQ);
subjectFor3d.setMsg("hello 3d'nums : 110 ");
subjectForSSQ.setMsg("ssq'nums : 12,13,31,5,4,3 15");
}
}测试结果：
subjectFor3d's msg -- >hello 3d'nums : 110 subjectForSSQ's msg -- >ssq'nums : 12,13,31,5,4,3 15
可以看出，使用Java内置的类实现观察者模式，代码非常简洁，对了addObserver,removeObserver,notifyObservers都已经为我们实现了，所有可以看出Observable（主题）是一个类，而不是一个接口，基本上书上都对于Java的如此设计抱有反面的态度，觉得Java内置的观察者模式，违法了面向接口编程这个原则，但是如果转念想一想，的确你拿一个主题在这写观察者模式（我们自己的实现），接口的思想很好，但是如果现在继续添加很多个主题，每个主题的ddObserver,removeObserver,notifyObservers代码基本都是相同的吧，接口是无法实现代码复用的，而且也没有办法使用组合的模式实现这三个方法的复用，所以我觉得这里把这三个方法在类中实现是合理的。
Das obige ist der detaillierte Inhalt vonBeispielcode für die Entwicklung öffentlicher WeChat-Konten mithilfe des Beobachtermusters in Java-Entwurfsmustern. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
