行为型模式[观察者模式]
观察者模式就是定义对象之间的一对多依赖,这样一来,当一个对象状态发生改变时,它的所有依赖者都会收到通知并自动更新。 这样的好处就是两个或多个对象之间松耦合,它们依然可以交互,但不太清楚彼此的细节。观察者模式提供了一种对象的设计,让主题和观察者之间松耦合。松耦合的设计可以让我们建立有弹性的OO系统,能够应对变化,是因为对象之间的互相依赖降到了最低。
应用场景:
1、当一个抽象模型包含两个方面内容,其中一个方面依赖于另一个方面。
2、其他一个或多个对象的变化依赖于另外一个对象的变化。
3、实现类似广播机制的功能,无需知道具体收听者,只需分发广播,系统中感兴趣的对象会自动连接接收该广播。
4、多层级嵌套使用,形成一种链式触发机制,使用事件具备跨域(跨越两种观察者类型)通知。
观察者模式通用的UML类图
抽象主题(IMianHero):指被观察的对象。该角色是一个抽象类或者接口定义了增加,删除,通知观察者对象的方法。
具体主题(MianHero):具体背观察者,当其内状态变化时,会通知已注册的观察者。
抽象观察者(IHero):定义了响应接收通知。
具体观察者(Hero):在得到状态更新时,会自动作出回应。
观察者应用场景代码
// 抽象被观察者
public interface IMianHero {
void addHero(IHero IHero);
void notify(String context);
}
// 实现被观察者
public class MianHero implements IMianHero {
private final List<IHero> IHeroes = new ArrayList<>();
private String name;
private String context;
public MianHero(String name) {
this.name = name;
}
@Override
public void addHero(IHero IHero) {
IHeroes.add(IHero);
}
@Override
public void notify(String context) {
if (CollectionUtils.isEmpty(IHeroes)) {
return;
}
System.out.println(this.name+"发送了一条:"+context);
this.context = context;
for (IHero IHero : IHeroes) {
IHero.receive(this);
}
}
@Override
public String toString() {
return this.name+"英雄发送了"+this.context+"消息给你们";
}
}
// 抽象观察者接口
public interface IHero {
void receive(IMianHero context);
}
// 具体观察者
public class Hero implements IHero {
private String name;
public Hero(String name) {
this.name = name;
}
@Override
public void receive(IMianHero mianHero) {
System.out.println(this.name+" 英雄收到来之"+mianHero);
System.out.println("收到收到ovov\n");
}
}
public class Test {
public static void main(String[] args) {
IMianHero iMianHero = new MianHero("大桥");
iMianHero.addHero(new Hero("小乔"));
iMianHero.addHero(new Hero("马超"));
iMianHero.addHero(new Hero("典韦"));
iMianHero.addHero(new Hero("张良"));
iMianHero.notify("辅助不见了,快跑。");
}
}
JDK原生的观察者模式
// 消息体
public class Context {
private String context;
public Context(String context) {
this.context = context;
}
public String getContext() {
return this.context;
}
}
// 观察者对象
public class Hero implements Observer {
private String name;
public Hero(String name) {
this.name = name;
}
@Override
public void update(Observable o, Object arg) {// o = 被观察者对象,arg 传入的参数
MianHero mianHero = (MianHero) o;
Context context = (Context) arg;
System.out.println(name+"收到来之 " +mianHero.getName()+" 发送的消息:"+context.getContext());
System.out.println("收到收到ovov\n");
}
}
// 被观察者对象
public class MianHero extends Observable {
private String name;
public MianHero(String name) {
this.name = name;
}
public String getName() {
return this.name;
}
void notify(String context){
Context c = new Context(context);
setChanged();
notifyObservers(c);
}
}
public class Test {
public static void main(String[] args) {
MianHero mianHero = new MianHero("小乔");
mianHero.addObserver(new Hero("张三"));
mianHero.addObserver(new Hero("赵云"));
mianHero.addObserver(new Hero("大桥"));
mianHero.addObserver(new Hero("花木兰"));
mianHero.notify("中路不见了,中路不见了");
}
}
google的观察者模式配置
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>18.0</version>
</dependency>
// 观察者对象
public class LvBu {
private String name = "吕布";
private String context;
public LvBu(String context) {
this.context = context;
}
@Override
public String toString() {
return this.name+"收到发送的:"+ context +"消息";
}
}
public class WangZhaoJun {
private String name = "王昭君";
private String context;
public WangZhaoJun(String context) {
this.context = context;
}
@Override
public String toString() {
return this.name+"收到发送的:"+ context +"消息";
}
}
public class ZhaoYun {
private String name = "赵云";
private String context;
public ZhaoYun(String context) {
this.context = context;
}
@Override
public String toString() {
return this.name+"收到发送的:"+ context +"消息";
}
}
// 事件触发场景 采用责任链触发形式
public class Event {
@Subscribe
public void observer(LvBu lvBu) {
System.out.println("参数名称:lvBu");
System.out.println(lvBu);
}
@Subscribe
public void observer(WangZhaoJun wangZhaoJun) {
System.out.println("参数名称:wangZhaoJun");
System.out.println(wangZhaoJun);
}
@Subscribe
public void observer(ZhaoYun zhaoYun) {
System.out.println("参数名称:zhaoYun");
System.out.println(zhaoYun);
}
@Subscribe
public void observer(Object o) {
System.out.println("参数名称:Object");
System.out.println(o);
}
}
public class Test {
public static void main(String[] args) {
EventBus eventBus = new EventBus();
eventBus.register(new Event());
eventBus.post(new LvBu("快跑快跑"));
eventBus.post(new WangZhaoJun("快跑快跑"));
eventBus.post(new ZhaoYun("快跑快跑"));
}
}
观察者的优缺点
优点:
1、观察者和被观察者是松耦合(抽象耦合)分开的,符合依赖倒置原则。
2、分离了表示层(观察者)和数据逻辑层(被观察者),并且建立了一套触发机制,使得数据的变化可以响应到多个表示层上。
3、实现了一对多的通讯机制,支持事件注册机制,支持兴趣分发机制,当被观察者触发事件时,只有感兴趣的观察者可以接收到通知。
缺点:
1、如果观察者数量过多,则事件通知会耗时较长。
2、事件通知呈线性关系,如果其中一个观察者处理事件卡壳,会影响后续的观察者接收该事件。
3、如果观察者和被观察者之间存在循环依赖,则可能造成两者之间的循环调用,导致系统死循环崩溃状态。