事件驱动模型。。。。有时间弄

public class A{
private Vector aListeners = new Vector();
private int value;
public int getValue(){
return value;
}
public void setValue(int newValue){
if(value!=newValue){
value = newValue;
AEvent evt= new AEvent(this,value);
//如果值改变的话,就触发事件
fireAEvent(evt);
}
}
public synchronized void addAListener(AListener a){
aListeners.addElement(a);
}
public synchronized void removeAListener(Alistener a){
aListeners.removeElement(a);
}
public void fireAEvent(AEvent evt){
Vector currentListeners = null;
synchronized(this){
currentListeners = (Vector)aListeners.clone();
}
for(int i =0;i<currentListeners.size();i++){
AListener listener = (AListener)currentListeners.elementAt(i);
listener.performed(evt);
}
}
}
//定义接口,当事件触发时调用
public interface AListener extends java.util.EventListener{
public abstract void performed(AEvent e);
}
//定义事件
public class AEvent extends EventObject{
private int value;
public AEvent(Object source){
this(source,null);
}
public AEvent(Object source,int newValue){
super(source);
value = newValue;
}
}
class B{
public B(){
A a = new A();
a.addAListener(new AListener(){
public performed(AEvent e){
//要处理的
}
});
}
}

事件驱动架构Event Driven Architecture (EDA) 是一种低耦合可分布式的架构，它通常处理异步信息流。

通常可以把事件看作是业务领域中发生的一个变化。因此，在代码中我们需要定义事件，并且实例化该事件。在.net中，事件可以看作行为的结果。必然有事件发生者和接收者，触发事件的对象为发生者，响应事件的对象则为事件接收者。委托（delegate）则串联起发生者和接收者。C#中委托的概念不在此累述。下面代码是声明委托，初始化委托和调用委托的示例。

声明一个委托

  1. public delegate int TestDelegate(object obj1, object obj2) ;

实例化一个委托

  1. TestDelegate TD = new TestDelegate(TestDelegateMethod) ;

调用一个委托

  1. TestDelegateMethod(" This is a Test.");

注意，其实在C#中，更多的时候是使用event修饰的delegate。使用event修饰后的委托是一个特殊的委托，它的特殊性体现在对象的封装性上。比如上面的代码可以写成

event TestDelegate TD = TestDelegateMethod;关于event和delegate的更多细节可以参考博文

http://www.tracefact.net/CSharp-Programming/Delegates-and-Events-in-CSharp.aspx

http://blog.monstuff.com/archives/000040.html

假设有如下一个应该场景，一个血压监测仪器，在病人每一次心跳的时候，监测血压，一旦发现病人血压小于80，则开始报警。

那么此处，动作的发出者就是病人，一旦发出心跳这个动作后，（通知）血压检测仪立即检测血压，如果小于80，则发出警报。

有一个BloodPressureMonitor类和Paient类。BloodPressureMonitor类只用一个方法，监测血压。病人类中主要有一个委托和一个HeartBeat()方法。其中每次调用HeartBeat()方法，都会调用委托方法。（此处，委托的意义类似于函数式编程的概念，将函数作为一个变量值，该变量赋予了哪个函数就调用哪个函数）。

因此，在main方法中，主要就是对dosth委托的赋值，也就是对病人每次心跳的时候，要调用一下血压检测仪的CheckPresssure方法。

代码如下：

  1. public delegate void DoAction(int s);
  2. class BloodPressureMonitor
  3. {
  4. public void CheckPresssure(int p)
  5. {
  6. if (p < 80)
  7. {
  8. Console.WriteLine(String.Format("Alert!Bloodpressure is less than {0}", p));
  9. }
  10. else
  11. {
  12. Console.WriteLine(String.Format("Bloodpressure is {0}", p));
  13. }
  14. }
  15. }
  16. class Patient {
  17. public event DoAction dosth;
  18. public String Name { get; set; }
  19. public int BloodPressure { get; set; }
  20. public void HeartBeat()
  21. {
  22. if (dosth != null)
  23. dosth(BloodPressure);
  24. }
  25. }
  26. class Program
  27. {
  28. static void Main(string[] args)
  29. {
  30. Patient  p = new Patient();
  31. p.Name = "Tom";
  32. p.BloodPressure = 100;
  33. BloodPressureMonitor monitor = new BloodPressureMonitor();
  34. p.dosth += monitor.CheckPresssure;
  35. for (int i = 0; i < 10; i++)
  36. {
  37. p.BloodPressure -= 5;
  38. p.HeartBeat();
  39. }
  40. }
  41. }

运行结果如下：

也许很多人会觉得，那何必这么麻烦，直接在 HeartBeat方法中调用BloodPressureMonitor的CheckPresssure方法不就行了嘛，何必用委托呢？例如直接写成

  1. public void HeartBeat()
  2. {
  3. new BloodPressureMonitor(). CheckPresssure( BloodPressure );
  4. }

这样的写法不也是可以实现的吗？

是的，但是这种写法不灵活，首先，使用委托的话，可以利用委托的一些特点，比如调用委托的BeginInvoke方法可以异步在线程池线程上执行。

其次，如果此时再要加一个电话呼叫功能，一旦血压小于60，电话机自动呼叫医生，那么在现有的基础上，改起来十分容易。只需要加个电话类，然后在委托上再挂一个方法就行了。

代码如下:

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. namespace EDA
  6. {
  7. public delegate void DoAction(int s);//定义一个委托
  8. class BloodPressureMonitor
  9. {
  10. public void CheckPresssure(int p)
  11. {
  12. if (p < 80)
  13. {
  14. Console.WriteLine(String.Format("Alert!Bloodpressure is less than {0}", p));
  15. }
  16. else
  17. {
  18. Console.WriteLine(String.Format("Bloodpressure is {0}", p));
  19. }
  20. }
  21. }
  22. class Telephone
  23. {
  24. public void NeedCallDoctor(int p)
  25. {
  26. if (p < 60)
  27. {
  28. Console.WriteLine(String.Format("Call doctor!", p));
  29. }
  30. }
  31. }
  32. class Patient
  33. {
  34. public event DoAction dosth;
  35. public String Name { get; set; }
  36. public int BloodPressure { get; set; }
  37. public void HeartBeat()//心跳时，调用dosth委托
  38. {
  39. if (dosth != null)
  40. dosth(BloodPressure);
  41. }
  42. }
  43. class Program
  44. {
  45. static void Main(string[] args)
  46. {
  47. Patient p = new Patient();
  48. p.Name = "Tom";
  49. p.BloodPressure = 100;
  50. BloodPressureMonitor monitor = new BloodPressureMonitor();
  51. p.dosth += monitor.CheckPresssure;//具体设定dosth是哪些方法。用+=可以挂载多个方法
  52. Telephone Phone = new Telephone();
  53. p.dosth += Phone.NeedCallDoctor;
  54. for (int i = 0; i < 10; i++)
  55. {
  56. p.BloodPressure -= 5;
  57. p.HeartBeat();
  58. }
  59. }
  60. }
  61. }

本文出自 “一只博客” 博客，请务必保留此出处http://cnn237111.blog.51cto.com/2359144/1176649

仿net事件委托的java事件模型实现

学习过Java Swing的读者一定对于Swing中相对较为复杂的事件驱动模型比较困惑，虽然事件驱动模型在Java Swing中被完完全全的体现出来了，

但是对于一个软件初学者而言这样的近乎“裸体”的事件驱动模型确实是很难理解的。
Microsoft公司.Net框架与Java Swing的GUI编程相比要简单很多，同样是事件驱动模型.Net框架就进行了大量的封装处理，.Net把这种封装称之

为委托器(Delegate)其代码如下：


 1 //当btnSubmit按钮被点击以后要求交给btnSubmit_Click方法处理
 2 // EventHandler在中间启到委托器的作用，
 3 //它负责将事件分发到指定的方法中进行处理
 4 this.btnSubmit.Click += new EventHandler(this.btnSubmit_Click);
 5 //事件处理方法
 6 // object sender:事件源，这里指btnSubmit对象
 7 // EventArgs e:事件处理参数，它保存了需要提供给程序员的必要信息
 8     private void btnSubmit_Click(object sender, EventArgs e)
 9     {
10         //打印This is a button语句
11         System.Diagnostics.Debug.WriteLine("This is button");
12    }
13

作为对比，我们来看看Java Swing的事件处理和委托就要复杂很多：代码如下


 1 //为btnSubmit增加侦听器SelectHandler，当btnSubmit被点击以后
 2 //有侦听器的actionPerformed负责处理该点击事件的业务
 3 //由于事件源btnSubmit和侦听器类SelectHandler处于两个不同的类中
 4 //为了让SelectHandler类取得页面的信息，我们需要将窗体对象(this)
 5 //传入到侦听器中
 6 btnSubmit.addActionListener(new SelectHandler(this));
 7 //侦听器SelectHandler，它必须实现动作事件ActionListener接口
 8 //以达到事件分发的作用
 9 class SelectHandler implements ActionListener {
10     private CommonDialogDemo form = null;
11     //将窗体对象CommonDialogDemo通过构造函数传入SelectHandler类中
12     public SelectHandler(CommonDialogDemo form) {
13         this.form = form;
14     }
15     //事件处理方法，当btnSubmit被点击，自动执行以下打印代码
16     publicvoid actionPerformed(ActionEvent e) {
17         System.out.println("This is button");
18     }
19 }
20

根据以上代码，我们可以清晰的看到Java Swing要比.Net的麻烦的多，而且更不能让人忍受的就是，一个页面如果有多个按钮的话，我们必须针

对每个按钮编写多个事件侦听类，而且这些类一般都会被设为内部类。学过软件建模的读者可能知道，内部在软件建模在软件工程中是不推荐使

用的，所以这样的代码编写明显会增加设计冗余度和复杂度，因此我们可以考虑自己编写一个类似于.Net中EventHandler一样的事件委托类来处

理事件分发。
       由于我们无权修改Java的编译器，所以我在这里将会借助于反射技术，利用一个事件委托类处理所有的点击事件，代码如下：


 1 package cn.softworks.teachersearchsystem.support;
 2 
 3 import java.awt.event.ActionEvent;
 4 import java.awt.event.ActionListener;
 5 import java.lang.reflect.Method;
 6 
 7 /**
 8 *该类是用来处理所有的Swing按钮点击事件，并根据将处理权<br>
 9 *转交给使用者来处理
10 *
11 *@authorChen.yu
12 *
13 */
14 publicclass EventHandlerimplements ActionListener {
15     
16     //组件所在的窗体对象
17     private Object form = null;
18     
19     //受到委托的方法名
20     private String methodName = null;
21     
22     /**
23      *构造函数
24      *
25      *@paramform           组件所在的窗体对象
26      *@parammethodName     受到委托的方法名
27      */
28     public EventHandler(Object form,String methodName) {
29         this.form = form;
30         this.methodName = methodName;
31     }
32     
33     /**
34      *事件处理委托方法
35      */
36     publicvoid actionPerformed(ActionEvent e) {
37         
38         //得到窗体对象的类型
39         Class formType = this.form.getClass();
40         
41         try {
42             //得到指定委托方法的类型 
43             Method method = 
44                 formType.getMethod(this.methodName, new Class[] {e.getClass()});
45             //调用指定的方法
46             method.invoke(this.form, new Object[] {e});
47             
48         }catch(Exception ex) {
49             
50             return;
51         }       
52     
53     }
54 
55 }
56 
57

现在我们来编写一个测试程序，代码如下：


1 btnSearch.addActionListener(
2 new EventHandler(this,"btnSearch_Click"));
3 
4 public void btnSearch_Click(ActionEvent e) {
5     System.out.println("This is btnSearch");
6 }
7

从以上代码中我们可以清晰的看到，事件处理和事件委托处于同一窗体中了，.Net方便的Delegate处理被我们用反射实现了。

事件驱动模型。。。。有时间弄

时间： 2024-10-15 08:26:32

事件驱动模型。。。。有时间弄的相关文章

事件驱动模型Libev（二）

Libev设计思路 理清了Libev的代码结构和主要的数据结构,就可以跟着示例中接口进入到Libev中,跟着代码了解其设计的思路.这里我们管struct ev_loop称作为事件循环驱动器而将各种watcher称为事件监控器. 1.分析例子中的IO事件 这里在前面的例子中我们先把定时器和信号事件的使用注释掉,只看IO事件监控器,从而了解Libev最基本的逻辑.可以结合Gdb设断点一步一步的跟看看代码的逻辑是怎样的. 我们从main开始一步步走.首先执行 struct ev_loop *main_

由Node.js事件驱动模型引发的思考

引言 近段时间听说了Node.js,很多文章表述这个事件驱动模型多么多么优秀,应用在服务器开发中有很大的优势,本身对此十分感性去,决定深入了解一下,由此也引发了一些对程序设计的思考,记录下来. 什么是Node.js Node.js在官网上是这样定义的:"一个搭建在Chrome JavaScript运行时上的平台,用于构建高速.可伸缩的网络程序.Node.js采用的事件驱动.非阻塞I/O模型使它既轻量又高效,是构建运行在分布式设备上的数据密集型实时程序的完美选择." Node.js的事件

使用事件驱动模型实现高效稳定的网络服务器程序

使用事件驱动模型实现高效稳定的网络服务器程序 几种网络服务器模型的介绍与比较 围绕如何构建一个高效稳定的网络服务器程序,本文从一个最简单的服务器模型开始,依次介绍了使用多线程的服务器模型.使用非阻塞接口的服务器模型.利用select()接口实现的基于事件驱动的服务器模型,和使用libev事件驱动库的服务器模型.通过比较各个模型,得出事件驱动模型更适合构建高效稳定的网络服务器程序的结论. 前言 事件驱动为广大的程序员所熟悉,其最为人津津乐道的是在图形化界面编程中的应用:事实上,在网络编程中事件驱动

YARN中MRAppMaster的事件驱动模型与状态机处理消息过程的分析

在MRv1中,对象之间的作用关系是基于函数调用实现的,当一个对象向另外一个对象传递消息时,会直接采用函数调用的方式,并且这个过程是串行的.比如,当TaskTracker需要执行一个Task的时候,将首先下载Task依赖的文件(JAR包,二进制文件等,字典文件等),然后执行Task.在整个过程中,下载依赖文件是阻塞式的,也就是说,前一个任务未完成文件下载之前,后一个新任务将一直处于等待状态,只有在下载完成之后,才会启动一个独立进程运行该任务.基于函数调用式的编程模型是低效的,它隐含着整个过程是串行

（六）观察者模式详解（包含观察者模式JDK的漏洞以及事件驱动模型）决了当时的问题，那时LZ接触JAVA刚几个月，比葫芦画瓢的用了观察者模式。

本章我们讨论一个除前面的单例以及代理模式之外,一个WEB项目中有可能用到的设计模式,即观察者模式. 说起观察者模式,LZ还是非常激动的,当初这算是第一个让LZ感受到设计模式强大的家伙.当初LZ要做一个小型WEB项目,要上传给服务器文件,一个需求就是要显示上传进度,LZ就是用这个模式解决了当时的问题,那时LZ接触JAVA刚几个月,比葫芦画瓢的用了观察者模式. 现在谈及观察者模式,能用到的地方就相对较多了,通常意义上如果一个对象状态的改变需要通知很多对这个对象关注的一系列对象,就可以使用观察者模式.

Python并发编程-事件驱动模型

 一.事件驱动模型介绍                                                                                                        1.传统的编程模式  例如:线性模式大致流程 开始--->代码块A--->代码块B--->代码块C--->代码块D--->......--->结束 每一个代码块里是完成各种各样事情的代码,但编程者知道代码块A,B,C,D...的执行顺序,唯一能

11.python并发入门（part13 了解事件驱动模型））

一.事件驱动模型的引入. 在引入事件驱动模型之前,首先来回顾一下传统的流水线式编程. 开始--->代码块A--->代码块B--->代码块C--->代码块D--->......--->结束 每一个代码块里是完成各种各样事情的代码,但编程者知道代码块A,B,C,D...的执行顺序,唯一能够改变这个流程的是数据.输入不同的数据,根据条件语句判断,流程或许就改为A--->C--->E...--->结束.每一次程序运行顺序或许都不同,但它的控制流程是由输入数据和

Spring基于事件驱动模型的订阅发布模式代码实例详解

代码下载地址:http://www.zuidaima.com/share/1791499571923968.htm 原文:Spring基于事件驱动模型的订阅发布模式代码实例详解 事件驱动模型简介 事件驱动模型也就是我们常说的观察者,或者发布-订阅模型:理解它的几个关键点: 首先是一种对象间的一对多的关系:最简单的如交通信号灯,信号灯是目标(一方),行人注视着信号灯(多方): 当目标发送改变(发布),观察者(订阅者)就可以接收到改变: 观察者如何处理(如行人如何走,是快走/慢走/不走,目标不会管的

Guava ---- EventBus事件驱动模型

在软件开发过程中, 难免有信息的共享或者对象间的协作. 怎样让对象间信息共享高效, 而且耦合性低. 这是一个难题. 而耦合性高将带来编码改动牵一发而动全身的连锁效应. Spring的风靡正是由于攻克了高耦合问题. 本篇介绍的EventBus中也用到了Spring中的依赖注入. 来进行对象和对象间的解耦(如@Subscribe). Guava解决高耦合採用的是事件驱动模型的思路. 对象能够订阅(subscribe)特定的事件或者公布(publish)特定的事件去被消费. 从以下的代码能够看出, E