java 观察者模式_java设计模式之观察者模式-CSDN博客

观察者模式

观察者模式（又被称为发布-订阅（Publish/Subscribe）模式，属于行为型模式的一种，它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，会通知所有的观察者对象，使他们能够自动更新自己。

观察者模式四大角色

Subject：抽象主题（抽象被观察者），抽象主题角色把所有观察者对象保存在一个集合里，每个主题都可以有任意数量的观察者，抽象主题提供新增、删除、通知观察者的方法。

ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。

Observer：抽象观察者，是观察者者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。

ConcrereObserver：具体观察者，实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新

使用场景

商品变更的时候，需要更新商品缓存、发布商品详情页、更新搜索索引，传统做法，在商品update方法处，分别调用更新商品缓存接口、发布商品接口、更新搜索索引接口。代码耦合度很高，如果增加一个新的逻辑，需要修改update方法，如果商品修改不需要更新缓存了，同样需要修改update方法。通过引入观察者模式，通过消息中间件的方式可以进行解耦，当商品发生修改的时候，发送一个消息，商品缓存应用可以订阅此消息，进行缓存的更新。商品发布系统，订阅此消息，重新发布商品。搜索应用，订阅此消息，增量更新索引。

如果商品更改有其他的业务逻辑，可以通过消息订阅和消费，增加相应的逻辑。如果要去掉某个逻辑，只要取消消息订阅，不再消费此消息即可。观察者模式通过发布和订阅的方式，实现业务的解耦。

代码实现

public interface Subject {
 //添加观察者
 void addObserver(Observer obj);
 //移除观察者
 void deleteObserver(Observer obj);
 //当主题方法改变时,这个方法被调用,通知所有的观察者
 void notifyObserver();
}

public class StudentObserver implements Observer{
 //保存一个Subject的引用,以后如果可以想取消订阅,有了这个引用会比较方便
 private Subject subject;
 //学生的姓名,用来标识不同的学生对象
 private String name;
 //构造器用来注册观察者
 public StudentObserver(String name,TeacherSubject teacherSubject) {
 this.name=name;
 this.subject = teacherSubject;
 //每新建一个学生对象,默认添加到观察者的行列
 teacherSubject.addObserver(this);
 }
 public void update(String info) {
 System.out.println(name+"得到作业:"+info);
 }
}

public interface Subject {
 //添加观察者
 void addObserver(Observer obj);
 //移除观察者
 void removeObserver(Observer obj);
 //当主题方法改变时,这个方法被调用,通知所有的观察者
 void notifyObserver();
}

public class StudentObserver implements Observer{
 //保存一个Subject的引用,以后如果可以想取消订阅,有了这个引用会比较方便
 private Subject subject;
 //学生的姓名,用来标识不同的学生对象
 private String name;
 //构造器用来注册观察者
 public StudentObserver(String name,TeacherSubject teacherSubject) {
 this.name=name;
 this.subject = teacherSubject;
 //每新建一个学生对象,默认添加到观察者的行列
 teacherSubject.addObserver(this);
 }
 public void update(String info) {
 System.out.println(name+"得到作业:"+info);
 }
}

public class TestObserver {
 public static void main(String[] args) {
 TeacherSubject teacher = new TeacherSubject();
 StudentObserver zhangSan = new StudentObserver("张三", teacher);
 StudentObserver LiSi = new StudentObserver("李四", teacher);
 StudentObserver WangWu = new StudentObserver("王五", teacher);
 teacher.setHomework("第二页第六题");
 System.out.println("----------------");
 teacher.setHomework("第三页第七题");
 System.out.println("----------------");
 teacher.setHomework("第五页第八题");
 }
}

运行结果：

代码不是特别的严谨，没有考虑多线程问题，不是线程安全的，用于生产环境，需要做同步或者增加锁控制。java中jdk提供了相关的工具类，java.uitl包下的Observer和Observable，这个是同步的，支持多线程。java自带jdk实现方法如下：

public class Message {
 private String title;
 private String content;
 public String getTitle() {
 return title;
 }
 public void setTitle(String title) {
 this.title = title;
 }
 public String getContent() {
 return content;
 }
 public void setContent(String content) {
 this.content = content;
 }
 public Message(String title, String content) {
 this.title = title;
 this.content = content;
 }
 @Override
 public String toString() {
 return "Message{" +
 "title='" + title + ''' +
 ", content='" + content + ''' +
 '}';
 }
}

//订阅者
public class MessageObserver implements Observer {
 private String title;
 public String getTitle() {
 return title;
 }
 public void setTitle(String title) {
 this.title = title;
 }
 public MessageObserver(String title) {
 this.title = title;
 }
 public void update(Observable o, Object arg) {
 System.out.println("observer :" + title + ",receive a message" + arg.toString());
 }
}

//发布者
public class MessagePublishObservable extends Observable {
 private Message message;
 public MessagePublishObservable(Message message) {
 this.message = message;
 }
 public void pushMessage(){
 setChanged();
 notifyObservers(message);
 }
 public Message getMessage() {
 return message;
 }
 public void setMessage(Message message) {
 this.message = message;
 }
 @Override
 public synchronized void addObserver(Observer o) {
 super.addObserver(o);
 }
 @Override
 public synchronized void deleteObserver(Observer o) {
 super.deleteObserver(o);
 }
 @Override
 public void notifyObservers() {
 super.notifyObservers();
 }
 @Override
 public void notifyObservers(Object arg) {
 super.notifyObservers(arg);
 }
 @Override
 protected synchronized void setChanged() {
 super.setChanged();
 }
}

public class Test {
 public static void main(String[] args) {
 MessageObserver messageObserverTopicA = new MessageObserver("A");
 MessageObserver messageObserverTopicB = new MessageObserver("B");
 MessageObserver messageObserverTopicC = new MessageObserver("C");
 MessagePublishObservable messagePublishObservable = new MessagePublishObservable(new Message("关注","欢迎关注享知行"));
 //a关注了享知行
 messagePublishObservable.addObserver(messageObserverTopicA);
 //b关注了享知行
 messagePublishObservable.addObserver(messageObserverTopicB);
 //c关注了享知行
 messagePublishObservable.addObserver(messageObserverTopicC);
 messagePublishObservable.pushMessage();
 messagePublishObservable.setMessage(new Message("文章更新","公众号享知行更新啦"));
 messagePublishObservable.pushMessage();
 }
}

运行结果：