标签：解耦 move pack 就是 接收 复杂 监听 总结 就会
观察者模式（有时又被称为模型（Model）-视图（View）模式、源-收听者(Listener)模式或从属者模式）是软件设计模式的一种。在此种模式中，一个目标物件管理所有相依于它的观察者物件，并且在它本身的状态改变时主动发出通知。这通常透过呼叫各观察者所提供的方法来实现。此种模式通常被用来实现事件处理系统。
观察者模式（Observer）完美的将观察者和被观察的对象分离开，以明星和粉丝举例子，明星就是被观察着，粉丝就是观察者。下面是一个demo
package Observer; public interface Observer { void update(Observable o); }
package Observer; import java.util.ArrayList; import java.util.List; public class Observable { private List<Observer> list = new ArrayList<>(); public void addObserver(Observer o) { list.add(o); } private String status; public List<Observer> getList() { return list; } public String getStatus() { return status; } public void movelUp (String status) { System.out.println(status); this.status = status; list.stream().forEach(o -> o.update(this)); } }
package Observer; public class Client { public static void main(String[] args) { Observable ob = new Observable(); ob.addObserver(new ObserverImpl("小花")); ob.addObserver(new ObserverImpl("小名")); ob.movelUp("天下无贼"); } }
以上便是标准的观察者模式，在被观察着中维护了一个观察者的列表，需要由被观察者去完成注册观察者的功能，不符合单一职责原则。所以我们需要添加一个manager类，来方便用户自己去订阅某个明星。改造代码如下：
package Observer2; import java.util.ArrayList; import java.util.List; public class Star { private String name; private String lastMovel; // 标识被观察者是否变化 private boolean changed = false; private List<Observer> list = new ArrayList<>(); public void addObserver(Observer o) { list.add(o); } public List<Observer> getList() { return list; } public void notifyObserver() { if (!changed) { return; } setChanged(false); list.stream().forEach(o -> o.update(this, null)); } public boolean isChanged() { return changed; } public void setChanged(boolean changed) { this.changed = changed; } public void setList(List<Observer> list) { this.list = list; } public Star(String name) { super(); this.name = name; Manager.getInstance().addStar(this); } public void movelUp(String movel) { System.out.println(name + "发布了" + movel); this.lastMovel = movel; setChanged(true); notifyObserver(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getLastMovel() { return lastMovel; } public void setLastMovel(String lastMovel) { this.lastMovel = lastMovel; } }
package Observer2; public interface Observer { void update(Star o,Object args); }
package Observer2; public class Fans implements Observer { private String name; public Fans(String name) { super(); this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } public void subscribe(String starName) { Manager.getInstance().getStar(starName).addObserver(this); } @Override public void update(Star star,Object args) { System.out.println(name + "得到了" + star.getName() +"发布" + star.getLastMovel() + "的消息"); } }
package Observer2; import java.util.HashMap; import java.util.Map; public class Manager { private Map<String, Star> observableMap = new HashMap<>(); private Manager() { } public void addStar(Star star) { observableMap.put(star.getName(), star); } public Star getStar(String name) { return observableMap.get(name); } public static Manager getInstance() { return SingleManager.manager; } private static class SingleManager{ private static Manager manager = new Manager(); } }
package Observer2; public class Client { public static void main(String[] args) { Fans fans1 = new Fans("小明"); Fans fans2 = new Fans("小话"); Fans fans3 = new Fans("小张"); Fans fans4 = new Fans("小里"); Star star1 = new Star("丽影"); Star star2 = new Star("幂幂"); fans1.subscribe("丽影"); fans3.subscribe("幂幂"); fans4.subscribe("幂幂"); star1.movelUp("乘风破浪"); star2.movelUp("孤岛惊魂"); System.out.println("----------------------------"); fans2.subscribe("丽影"); star1.movelUp("女儿国"); } }
发布/订阅模式(Pub/Sub)是一种消息模式,它有 两个参与者 : 发布者和订阅者 。发布者向 某个信道发布一条消息，订阅者绑定这个信道，当有消息发布至信道时就会 接收到一个通知。最重要的一点是， 发布者和订阅者是完全解耦的，彼此并不知晓对方的存在。从定义上可以看出，发布订阅模式里双方是完全解耦的，而在观察者模式里，目标对象管理这观察者，双方是耦合的，这是最主要的区别，而在发布订阅模式中多了一个中间层信道。我们常用的activeMQ、rabbitMQ、kafka等中间件就是为发布订阅模式服务的。
还有一种和观察者模式很像的就是事件驱动模型，相信各位都知道tomcat，在使用的过程中，或许经常会有人用到listener，即监听器这个概念。那么其实这个就是一个事件驱动模型的应用。比如我们的spring，我们在应用启动的时候要初始化我们的IOC容器，那么我们的做法就是加入一个listener，这样伴随着tomcat服务器的启动，spring的IOC容器就会跟着启动。那么这个listener其实就是事件驱动模型中的监听器，它用来监听它所感兴趣的事，比如我们springIOC容器启动的监听器，就是实现的ServletContextListener这个接口，说明它对servletContext感兴趣，会监听servletContext的启动和销毁。事件驱动模型与观察者模式勉强的对应关系可以看成是，被观察者相当于事件源，观察者相当于监听器，事件源会产生事件，监听器监听事件。所以这其中就搀和到四个类，事件源，事件，监听器以及具体的监听器。下面我们就将上面的例子改造为事件驱动模型。
package Observer3; import java.util.EventObject; public class MovelEvent extends EventObject { private static final long serialVersionUID = -1231609728871248531L; public MovelEvent(Star star) { super(star); } public Star getStar() { return (Star) super.getSource(); } }
package Observer3; import java.util.ArrayList; import java.util.List; public class Star { // 标识被观察者是否变化 private boolean changed = false; private List<MovelListener> list = new ArrayList<>(); public void addMovelListener(MovelListener o) { list.add(o); } public List<MovelListener> getList() { return list; } public void setList(List<MovelListener> list) { this.list = list; } public void notifyObserver() { if (!changed) { return; } setChanged(false); MovelEvent movelEvent = new MovelEvent(this); list.stream().forEach(o -> o.update(movelEvent)); } public boolean isChanged() { return changed; } public void setChanged(boolean changed) { this.changed = changed; } public Star(String name) { super(); this.name = name; Manager.getInstance().addStar(this); } private String name; private String lastMovel; public void movelUp(String movel) { System.out.println(name + "发布了" + movel); this.lastMovel = movel; setChanged(true); notifyObserver(); } public String getName() { return name; } public void setName(String name) { this.name = name; } public String getLastMovel() { return lastMovel; } public void setLastMovel(String lastMovel) { this.lastMovel = lastMovel; } }
package Observer3; import java.util.EventListener; public interface MovelListener extends EventListener { void update (MovelEvent movelEvent); }
package Observer3; public class Fans implements MovelListener { private String name; public Fans(String name) { super(); this.name = name; } public String getName() { return name; } public void setName(String name) { this.name = name; } public void subscribe(String starName) { Manager.getInstance().getStar(starName).addMovelListener(this); } @Override public void update(MovelEvent movelEvent) { Star star = movelEvent.getStar(); System.out.println(name + "得到了" + star.getName() +"发布" + star.getLastMovel() + "的消息"); } }
我们彻底将刚才的观察者模式改成了事件驱动，现在我们使用事件驱动的类再运行一下客户端，其中客户端代码和WriterManager类的代码是完全不需要改动的，直接运行客户端即可。我们会发现得到的结果与观察者模式一模一样。
那么观察者模式和事件驱动的不同之处在哪里呢？首先从实现方式上就能看出，事件驱动可以解决观察者模式的问题，但反过来则不一定，另外二者所表达的业务场景也不一样，比如上述例子，使用观察者模式更贴近业务场景的描述，而使用事件驱动，从业务上讲，则有点勉强。再者从功能上讲，观察者模式中观察者的响应理论上讲针对特定的被观察者是唯一的（当然如果在update方法中ifelse则也能实现对多个被观察着）；事件驱动则更灵活，可以定义自己感兴趣的事情，比如我们可以监听movel，也可以在接口里加一个singListener的接口，然后我们的fans同时实现这个接口，那么star在发布singEvent的时候，只要实现了singListener的类的实例就可以收到消息，当然程序的复杂性就增加了。
最后总结一下，观察者模式和发布订阅模型的区别就在于消息是否发送给中间件，观察者和被观察着是否完全解耦；而观察者模式和事件驱动的区别则在于事件驱动则更加灵活，但同时增加了程序的复杂性。
标签：解耦 move pack 就是 接收 复杂 监听 总结 就会
原文地址：https://www.cnblogs.com/hhhshct/p/10297872.html
