java观察者模式详解,java 观察者模式

　　00-1010代码后台介绍观察者模式实现观察者(学生)通知者(教师)主要方法观察者通知者事件事件处理委托介绍总结

　　00-1010一个班有两种学生，A班：他们不学习，不玩耍，但他们玩不同的东西，有的玩游戏，有的看电视。

　　B班：站岗的学生观察老师的动作。如果老师进了班，他们会马上通知大家。

　　于是就有了一个要求，站岗的学生要通知所有在玩的学生：老师来了，不同的学生有不同的反应。他们中的一些人立即关掉电视，而另一些人则停止玩游戏。

目录

　　00-1010观察者模式:定义了一对多的依赖关系，允许多个observer对象同时监控某个topic对象。当这个主题对象的状态发生变化时，它会通知所有观察者，以便他们可以自动更新自己。

　　主要解决：是一个对象的状态发生变化时通知其他对象的问题，需要考虑易用性和低耦合性，保证高度协作。

　　当何时使用：中的一个对象(目标对象)的状态改变时，所有依赖对象(观察者对象)将被通知和广播。

　　如何解决：可以通过使用面向对象技术来削弱这种依赖性。

　　在关键代码：的抽象类中有一个数组列表来存储观察者。

代码背景

　　00-1010/* * *抽象观察者* * @作者提示(张友博)* @ version 1 . 0 . 0 * @ since 2022/5/10-15336032 */公共接口观察者{公共抽象void更新状态()；}/* * *具体观察者* * @作者提示(张友博)* @ version 1 . 0 . 0 * @ since 2022/5/10-15336039 */公共类具体观察者实现观察者{//观察者私有字符串名称的名称；//观察器的状态私有字符串observerState//清除特定的通知者私有ConcreteSubject subject//get set方法省略了公共的具体observer(字符串名，具体subject subject){ this . name=name；this.subject=subject} @ Override public void updateState(){ observer state=subject . get subject state()；System.out.println(name 正在玩游戏)；string str=string . format( observer %s:新状态为% s ，name，observer state)；system . out . println(str)；}}/* * *具体观察者* * @作者提示(张友博)* @ version 1 . 0 . 0 * @ since 2022/5/10-15336039 */公共类具体观察者2实现观察者{//观察者私有字符串名称的名称；//观察器的状态私有字符串observerState//清除特定的通知者私有ConcreteSubject subject//get set方法省略公共具体observer 2(字符串名，具体subject subject){ this . name=name；this.subject=subject} @ Override public void updateState(){ observer state=subject . get subject state()；System.out.println(名为看电视)；string str=string . format( observer %s:新状态为% s ，name，observer state)；

　　 System.out.println(str); }}

通知者（老师）

/** * 抽象的通知者 * * @author Promsing(张有博) * @version 1.0.0 * @since 2022/5/10 - 15:30 */public abstract class Subject { //管理观察者的集合 private List<Observer> observers=new ArrayList<>(); //增加观察者 public void add(Observer observer){ observers.add(observer); } //减少观察者 public void detach(Observer observer){ observers.remove(observer); } /** * 通知所有的观察者 */ public void notifyMsg(){ for (Observer observer : observers) { observer.updateState(); } }}/** * 具体的通知者 * * @author Promsing(张有博) * @version 1.0.0 * @since 2022/5/10 - 15:38 */public class ConcreteSubject extends Subject { //通知者的状态 private String subjectState; //get set方法 public String getSubjectState() { return subjectState; } public void setSubjectState(String subjectState) { this.subjectState = subjectState; }}

Main方法

/** * 控制台Main方法 * * @author Promsing(张有博) * @version 1.0.0 * @since 2022/5/10 - 15:48 */public class MainTest { public static void main(String[] args) { //创建一个主题/通知者 ConcreteSubject subject=new ConcreteSubject(); //new出观察者（学生） ConcreteObserver studentZhang = new ConcreteObserver("小张", subject); ConcreteObserver studentLiu = new ConcreteObserver("小刘", subject); ConcreteObserver studentWang = new ConcreteObserver("小王", subject); //将观察者添加到通知队列里 subject.add(studentZhang); subject.add(studentLiu); subject.add(studentWang); //通知者（老师）状态修改，通知每个学生 subject.setSubjectState("老师回来了，我要好好学习"); subject.notifyMsg(); System.out.println("-----------"); }}

委托 介绍

委托可以看做是函数的抽象，是函数的类。委托的实例将代表一个具体的函数一个委托可以搭载多个方法，所有的方法被依次唤起。可以使委托对象所搭载的方法并不需要属于同一类。委托事件模型可以由三个组件定义：事件、事件源和事件侦听器。

　　委托的实现简单来讲就是用反射来实现的。

　　实现

观察者

/** * 监听器/观察者 玩游戏 * 事件监听器 * @author Promsing(张有博) * @version 1.0.0 * @since 2022/5/8 - 11:17 */public class PlayingGameListener { public PlayingGameListener(){ System.out.println("我正在玩游戏 开始时间"+new Date()); } public void stopPlayingGame(Date date){ System.out.println("老师来了，快回到座位上，结束时间"+date); }}/** * 监听器/观察者 看电视 * 事件监听器 * @author Promsing(张有博) * @version 1.0.0 * @since 2022/5/8 - 11:17 */public class WatchingTVListener { public WatchingTVListener(){ System.out.println("我正在看电视 "+new Date()); } public void stopWatchingTV(Date date){ System.out.println("老师来了，快关闭电视 。 结束时间"+date); }}

通知者

/** * 通知者的抽象类 * 事件源 * @author Promsing(张有博) * @version 1.0.0 * @since 2022/5/8 - 11:15 */public abstract class Notifier { //每个通知者都有一个需要通知的队列（通知：对象、方法、参数） private EventHandler eventHandler=new EventHandler(); public EventHandler getEventHandler() { return eventHandler; } public void setEventHandler(EventHandler eventHandler) { this.eventHandler = eventHandler; } //增加需要帮忙放哨的学生 public abstract void addListener(Object object,String methodName,Object...args); //告诉所有要帮忙放哨的学生：老师来了 public abstract void notifyX();}/** * 通知者的子类，放哨人 * 事件源 * @author Promsing(张有博) * @version 1.0.0 * @since 2022/5/8 - 11:15 */public class GoodNotifier extends Notifier { @Override public void addListener(Object object, String methodName, Object...args) { System.out.println("有新的同学委托尽职尽责的放哨人!"); this.getEventHandler().addEvent(object, methodName, args); } @Override public void notifyX() { System.out.println("尽职尽责的放哨人告诉所有需要帮忙的同学：老师来了"); try{ //优化：异步通知 this.getEventHandler().notifyX(); }catch(Exception e){ e.printStackTrace(); } }}

事件

/** * 抽象出的事件类，也可以称为方法类 * 事件 * @author Promsing(张有博) * @version 1.0.0 * @since 2022/5/8 - 11:03 */public class Event { //要执行方法的对象 private Object object; //要执行的方法名称 private String methodName; //要执行方法的参数 private Object[] params; //要执行方法的参数类型 private Class[] paramTypes; //若干setter getter public Object getObject() { return object; } public String getMethodName() { return methodName; } public void setMethodName(String methodName) { this.methodName = methodName; } public Object[] getParams() { return params; } public void setParams(Object[] params) { this.params = params; } public Class[] getParamTypes() { return paramTypes; } public void setParamTypes(Class[] paramTypes) { this.paramTypes = paramTypes; } public Event(){ } public Event(Object object,String methodName,Object...args){ this.object=object; this.methodName=methodName; this.params=args; contractParamTypes(this.params); } //根据参数数组生成参数类型数组 private void contractParamTypes(Object[] params){ this.paramTypes=new Class[params.length]; for(int i=0;i<params.length;i++){ this.paramTypes[i]=params[i].getClass(); } } //执行该 对象的该方法 public void invoke() throws Exception{ //通过class,method,paramTypes 确定执行哪个类的哪个方法 Method method=object.getClass().getMethod(this.getMethodName(), this.getParamTypes()); if(null==method){ return; } //方法执行 method.invoke(this.getObject(), this.getParams()); }}

事件处理

/** * 管理哪些事件需要执行 * 管理事件 * * @author Promsing(张有博) * @version 1.0.0 * @since 2022/5/8 - 11:03 */public class EventHandler { //是用一个List private List<Event> objects; //添加某个对象要执行的事件，及需要的参数 public void addEvent(Object object,String methodName,Object...args){ objects.add(new Event(object,methodName,args)); } public EventHandler(){ objects=new ArrayList<Event>(); } //通知所有的对象执行指定的事件 public void notifyX() throws Exception{ for(Event e : objects){ e.invoke(); } }}

Main方法

/** * 启动类 * * @author Promsing(张有博) * @version 1.0.0 * @since 2022/5/8 - 11:19 */public class EventMain { public static void main(String[] args) { //创建一个尽职尽责的放哨者 Notifier goodNotifier = new GoodNotifier(); //创建一个玩游戏的同学，开始玩游戏 PlayingGameListener playingGameListener = new PlayingGameListener(); //创建一个看电视的同学，开始看电视 WatchingTVListener watchingTVListener = new WatchingTVListener(); //玩游戏的同学告诉放哨的同学，老师来了告诉一下 goodNotifier.addListener(playingGameListener, "stopPlayingGame", new Date()); //看电视的同学告诉放哨的同学，老师来了告诉一下 goodNotifier.addListener(watchingTVListener, "stopWatchingTV", new Date()); try { //一点时间后 Thread.sleep(1000); } catch (Exception e) { e.printStackTrace(); } //老师出现，放哨的人通知所有要帮忙的同学:老师来了 goodNotifier.notifyX(); }}

总结

1.先有观察者模式后有委托事件技术2.观察者模式只能通知继承 Observer类 的子类，也可以将Observer改成接口

for (Observer observer : observers) { observer.updateState();}

3.委托可以通知任何类的任何方法。反射、everone

 Method method=object.getClass().getMethod(this.getMethodName(), this.getParamTypes());if(null==method){ return;} method.invoke(this.getObject(), this.getParams());

4.委托与观察者比多了一个事件执行者，解除观察者与通知者的耦合，可以做到通知任何对象的任何方法。让A类学生和B类学生完全解耦，即A类完全不知道B类的学生，却可以通知B类的学生

　　6.建立一套触发机制，可以使用异步通知

　　7.观察者/委托挺像MQ里边的订阅发布。生产者、队列、消费者。

　　到此这篇关于Java中观察者模式与委托的对比的文章就介绍到这了,更多相关Java观察者模式委托内容请搜索盛行IT以前的文章或继续浏览下面的相关文章希望大家以后多多支持盛行IT！

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。