设计模式—观察者模式（用微信公众号来分析）
转载请注明出处 https://blog.csdn.net/qq_39071530/article/details/84196142
github地址 https://github.com/esmusssein777/designpatterns
设计模式目录 https://blog.csdn.net/qq_39071530/article/details/84849070
先来看一个定义
出版者+订阅者=观察者模式
我们可以了解为定义了对象为一对多的依赖，就和微信公众号一样，我们可以比较好的理解了。
首先我们可以关注和取消关注公众号。
关注了之后我们会发现公众号更新时所有关注了的用户都会同时接收到更新。
如果某个用户取消关注后发现会不在接收到公众号最新的消息。
这张图是headfirst设计模式里面观察者模式的类图。
我们可以这样
我们有某一个公众号下面有三个用户，当公众号发布消息时，三个用户都可以接收到消息，并且可以随意的关注和取消关注。
在我们看下面的图之前，我们可以先自己想一想类图关系是怎样的。
我们也可以自己画一画。
三个用户都应该有一个subject的指针来指向WxPublic对象，但是怕太乱。
我们先来看测试的代码。
package org.ligz.DesignPatterns.Observer.wxpublic;
public class Test {
public static void main(String[] args) {
WxPublic wxPublic = new WxPublic();
System.out.println("三个用户关注公众号");
Observer observer1= new Observer1(wxPublic);
Observer observer2= new Observer2(wxPublic);
Observer observer3= new Observer3(wxPublic);
System.out.println("微信公众号更新文章一");
wxPublic.UpdateContent("文章一");
System.out.println("用户一取消关注");
wxPublic.unsubscribeObserver(observer1);
System.out.println("微信公众号更新文章二");
wxPublic.UpdateContent("文章二");
}
}
得出来的结果是
三个用户关注公众号
微信公众号更新文章一
用户一接收到文章一
用户二接收到文章一
用户三接收到文章一
用户一取消关注
微信公众号更新文章二
用户二接收到文章二
用户三接收到文章二
我们来看代码吧
package org.ligz.DesignPatterns.Observer.wxpublic;
/**
* 观察者模式
* 主题接口
* @author ligz
*/
public interface Subject {
public void subscribeObserver(Observer o);
public void unsubscribeObserver(Observer o);
public void notifyObserver();
}package org.ligz.DesignPatterns.Observer.wxpublic;
import java.util.ArrayList;
import java.util.List;
/**
* 观察者模式
* 微信公众号
* @author ligz
*/
public class WxPublic implements Subject{
private List list;
private String content;
public WxPublic() {
list = new ArrayList();
}
public void subscribeObserver(Observer o) {
list.add(o);
}
public void unsubscribeObserver(Observer o) {
int index = list.indexOf(o);
if(index >= 0) {
list.remove(index);
}
}
public void notifyObserver() {
for(Observer o : list) {
o.update(content);
}
}
public void UpdateContent(String content) {
this.content = content;
notifyObserver();
}
}
package org.ligz.DesignPatterns.Observer.wxpublic;
/**
* 观察者模式
* 所有的用户都需要实现这个接口，公众号在需要通知用户时，才有了 一个共同的接口
* @author ligz
*/
public interface Observer {
public void update(String content);
}
package org.ligz.DesignPatterns.Observer.wxpublic;
/**
* 观察者模式
* 为用户建立一个共同的接口，实现展示的功能
* @author ligz
*/
public interface DisPlayContent {
public void display();
}
package org.ligz.DesignPatterns.Observer.wxpublic;
/**
* 观察者模式
* 用户一
* @author ligz
*/
public class Observer1 implements Observer, DisPlayContent{
private String content;
public Subject wxPublic;
public Observer1 (Subject wxPublic) {
this.wxPublic = wxPublic;
wxPublic.subscribeObserver(this);
}
public void update(String content) {
this.content =content;
display();
}
public void display() {
System.out.println("用户一接收到" + content);
}
}
package org.ligz.DesignPatterns.Observer.wxpublic;
/**
* 观察者模式
* 用户二
* @author ligz
*/
public class Observer2 implements Observer, DisPlayContent{
private String content;
public Subject wxPublic;
public Observer2 (Subject wxPublic) {
this.wxPublic = wxPublic;
wxPublic.subscribeObserver(this);
}
public void update(String content) {
this.content =content;
display();
}
public void display() {
System.out.println("用户二接收到" + content);
}
}
package org.ligz.DesignPatterns.Observer.wxpublic;
/**
* 观察者模式
* 用户三
* @author ligz
*/
public class Observer3 implements Observer, DisPlayContent{
private String content;
public Subject wxPublic;
public Observer3 (Subject wxPublic) {
this.wxPublic = wxPublic;
wxPublic.subscribeObserver(this);
}
public void update(String content) {
this.content =content;
display();
}
public void display() {
System.out.println("用户三接收到" + content);
}
}
我们会发现我们可以随时的将新的用户添加进来，或者用户取消关注。我们不再为需要通知哪一些人而烦恼。这就是松耦合的设计。公众号只需关心发布内容，而用户的内容更新已经和他分离开来
当然，在Java里面Java.util.observer和Java.util.observable支持了对观察者编写。
我们在上面可以不使用Subject和Observer类。
用WxPublic 继承Java.util.observable，用Observe1来继承Java.util.observe来减少代码的使用。
但是原理和上面是一样的，这里就不多加描述。
有兴趣的或者需要可以自己去查询资料。
我们可以在观察者模式中发现新的设计模式原则，那就是
为交互对象之间的松耦合设计而努力。
观察者模式的代表就是我们熟悉的MVC模式，这个我们后面讲。