AIOps 平台的误解，挑战及建议（中），AIOps常见的误解
842
2023-01-25
包含事件通知链是什么模式的词条
本站部分文章、图片属于网络上可搜索到的公开信息，均用于学习和交流用途，不能代表睿象云的观点、立场或意见。我们接受网民的监督，如发现任何违法内容或侵犯了您的权益，请第一时间联系小编邮箱jiasou666@gmail.com 处理。
本篇文章给大家谈谈事件通知链是什么模式，以及对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
今天给各位分享事件通知链是什么模式的知识，其中也会对进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！
我们知道，面向对象编程有两个核心元素：对象、对象间通信协作。从面向对象的角度看，任何系统和功能，都是由一个个对象，相互分工合作实现的。推而广之，很多系统也都是这样组织和运行的。
本章的设计模式，列举了通用场景下常用功能机制的经典实现方法，讲解了经典实现中是如何高效组织对象、控制对象协作交互的，具有很好的参考价值。
示例：https://www.runoob.com/design-pattern/chain-of-responsibility-pattern.html
责任链模式，就是把程序处理对象前后排列起来，形成一条处理线。处理线上需要被处理的信息，在处理线上向下传递，任何一个节点都可以随时中断传递。
GUI系统中的事件传递机制（在Javascript中叫做事件冒泡），是责任链模式最典型的应用之一。
当某一事件发生时，最顶层GUI对象会首先收到事件，但是它先不处理，而是依次交给命中的子GUI对象处理。当子GUI对象返回为False时，表示事件未被接收，此时父GUI对象才真正对发生的事件进行业务处理。
可以看出，事件传递机制，是一种增强版的责任链模式，它的节点处理权，经历了向下和向上的双向传递过程。
总结：当项目中一个数据对象，需要被多个处理对象进行处理时，可以将处理对象链接起来，然后把数据对象传递给头节点，随着处理的进行，数据对象的处理权会在处理链中流动，从而完成整个处理过程。
责任链模式结构适用于需求固定的场景，用于实现简单高效的处理机制。假如需求不断变化，而且功能很复杂，那么用责任链模式很可能就无法胜任了，需要采用新的高复杂度的设计。例如，如果想要数据对象在所有处理对象中根据状态来实现跳转，可以选择使用状态机等其他方案来实现。
示例：https://www.runoob.com/design-pattern/command-pattern.html
想要实现撤销、重做、事务等功能，可以使用此设计模式。通常在编辑器、数据库中有此类功能需求。
命令也就是请求，或者叫调用。命令模式要求将请求参数和请求相关的方法封装在一起。
请求对象中封装了实现“撤销”、“重做”、“事务”功能所需要的所有信息，实现了关联信息的高内聚，所以可以实现我们想要的功能。
例如，可以在请求对象中保存修改之前的值、修改之后的值。利用修改之前的值，可以实现“撤销”功能；利用修改之后的值，可以实现“重做”功能。如果将所有请求对象都记录下来，并按照先后顺序排列起来，形成“撤销重做”堆栈，这样就可以实现连续的“撤销”、“重做”。“事务”则是“撤销”与“重做”的结合体，正常执行流程等同于“重做”，发生错误需要回滚，等同于“撤销”。
如果不采用这种方式，会导致实现这些功能的信息，分散在源码中多个地方，或者已经丢失，没有保存，就无法实现“撤销”、“重做”、“事务”功能。
同时，实现请求参数高内聚，也可以很方便地将它们保存到磁盘上，保存到文件的过程叫做“序列化”，从文件中读取的过程叫“反序列化”。这里的序列指的就是二进制流。
Qt中与命令模式相关的部分是：Undo Framework，里面有示例项目，不熟悉的同学可以抽点时间看一看。
示例：https://www.runoob.com/design-pattern/interpreter-pattern.html
顾名思义，解释器模式是用来实现解释器的。 解释器是这样一个程序：解释器以符合语法的文本为输入，解释输入内容，完成一定的计算功能。文本可以在程序运行时动态加载，动态解释、动态执行。
实现简单的解释器：命令行程序，如ping命令、cd命令等； 实现复杂的解释器：脚本语言解释器，如python，lua，javascript；计算器。
我们知道，在GUI图形用户界面被发明之前，人类和程序之间的交互是通过敲命令行实现的，缺点是使用难度较大，门槛较高。 在GUI发明以后，交互更加友好，电脑更加易于使用了，所以也更加普及了。
但是GUI交互的缺点在于，不够灵活，对参数的控制粒度不够细致。例如，现在大多数开发者都使用集成开发环境来开发软件，一般情况下都使用默认参数，比较方便。但是如果你想要更改某些编译选项，可能还是需要直接修改底层的编译命令。命令相对于GUI元素更加灵活，过于灵活的地方用GUI比较难于实现，例如组合、递归、跳转等等。在这些场景下，使用解释器是非常合适的。但是通常情况下，这个模式并不常用。
示例：https://www.runoob.com/design-pattern/iterator-pattern.html
在需要多次遍历同一个数据集合的时候，为了少些一些for，或者想要把遍历过程封装起来，降低耦合，就可以使用迭代器模式。这个模式非常常用。
迭代器就是一个专门用来遍历数组的类。它只需要实现两个接口：hasNext()、next()。 hasNext()接口用于控制循环何时停止；next()接口用于取出当前位置的数据元素，并将遍历指针指向下一个元素。 当然，构造迭代器对象的时候，需要将数据集合传递给迭代器，让迭代器知道要遍历哪些数据。
原本需要用for循环来遍历的代码，现在通过封装，提取出了“遍历”这一功能所需要的必要信息，定义了两个接口，把不必要暴露的信息封装在了迭代器中，妥妥的实现了解耦。
示例：https://www.runoob.com/design-pattern/mediator-pattern.html
中介者模式是指，在原本直接通信的对象之间，添加一个通信中间层，使对象间通信变为间接通信，降低对象间的耦合。
此模式和代理模式基本思想上是一致的。二者的区别是：代理模式是通过加一个中间层，来实现两个原本很难交互的功能主体，实现顺畅交互；中介者模式是为了降低对象间通信时的耦合而提出的，为的是提高代码的可维护性。
比较大的项目中会用到，一般存在于某些框架中。因为大的项目中对象繁多，通信也比较复杂，适合使用中介者模式。
在大的项目中，一般会有一个全局的通信管理器，任何对象都可以使用通信管理器提供的接口，将自己注册为某一个具有唯一ID消息的发送者和接收者。这样发送者只需要发送消息，不需要管谁来接收，不需要拥有发送者的实例指针，发出消息后，已注册的接收者都会收到消息。接收者不需要管信号是谁发的，即不需要拥有发送者的实例指针。
所以，中介者模式也可以叫“通信中介模式”。
示例：https://www.runoob.com/design-pattern/memento-pattern.html
这个模式和状态存档功能是绑定在一起的。为了在程序中实现状态存档功能，可以使用备忘录模式。
原例子中有三个类，个人觉得没有必要，这里我们简化成两个类，即备忘录模式中有两个类：状态对象类和状态对象管理类。 状态对象类是状态字段是集合，并提供了存取接口；状态对象管理类负责组织和保存状态对象。当然实际实现中可以根据需求增加类，配合使用，完成状态保存恢复。
当一个对象会影响到其他多个对象时，即当对象间存在一对多关系时，使用观察者模式。 一般应用于单向通知的场景，如GUI中鼠标事件、按键事件、窗口事件通知。使用Qt中的信号槽机制可以实现此模式。
“一”是指发生变化的那个对象，“多”是指需要获取此变化通知的对象组。其中，变化消息是单向地由“一”到“多”传递的。如果不是单向的或者对象间不是一对多的关系，更加复杂，就需要重新思考其他对象间通信模型。
如果不使用此模式，可能会导致观察者不能动态增加或删除；可能会造成发送者的业务代码和接收者的响应代码混在一起，耦合严重。
使用此模式，需要为观察者设计一个基类，并设计一个接收通知的接口，所有观察者需要实现通知接口；所有观察者指针可以保存在队列中，实现动态增删。
状态模式用于实现状态机。 如果一个程序功能中存在某些状态，在一定情况下，这些状态可以互相转换，并且在转换前后需要作出对应的操作，这种情况下使用状态机来实现就非常合适。
如果不使用状态机（状态模式），一般的实现方法是使用一连串的if-else，或者使用长长的switch-case来实现。这样做的缺点，一方面状态判断不够高效，另一方面是业务代码集中在一块，不好维护。
使用状态机，每个状态都是一个类，相关的业务代码分布到各自的状态类中，能够实现不同的状态及与状态相关的业务代码解耦。同时某个状态和下一个状态是关联好的，在状态切换时，效率更高，不需要执行长长的判断。
Qt中已实现状态机框架，The State Machine Framework，在此框架下，我们可以更加专注于业务实现，而不是状态机本身的技术细节。
示例：https://www.runoob.com/design-pattern/null-object-pattern.html
使用基类保存子类对象通常有两种做法：
第一种方法用指针是基本方法，但是指针用起来要非常小心，要考虑内存释放的问题。此时空对象就可以用空指针表示。 第二种方法用基类对象保存子类对象，这种方法使用起来相对省心，不用与指针打交道，使用者不用直接管理内存。例如Qt中的Qt XML C++ Classes类的设计就是采用这种方式设计的。这种情况下，因为不使用指针，就需要使用空对象来代替空指针。
可以仿造Qt XML中的类进行设计。一般需要提供isNull()接口，对象类型转换接口等。
策略模式和桥接模式类似，用于实现功能切换与组合。二者区别在于，策略模式专注于一个功能的不同实现方式；桥接模式专注于多个功能之间的组合。
将功能抽象成单独的类，功能切换只需要切换不同的功能子类即可，同一个功能需要实现同一个功能接口。
示例：https://www.runoob.com/design-pattern/template-pattern.html
模板模式应该是我们最熟悉的。 这里的模板就是接口类，接口类定义了使用者和功能提供者之间交互的函数列表。子类负责功能的具体实现。
示例：https://www.runoob.com/design-pattern/visitor-pattern.html
访问者模式用于将数据结构与数据操作相分离。
访问者模式和迭代器模式类似。迭代器模式一般用来遍历数组，所以没有把for封装起来。而访问者模式可以遍历一切类型的数据结构，具体的遍历过程被封装在接收者内部。同时，对每一个遍历得到的数组元素的操作，被封装在访问者内部。每一种对元素不同的操作，都需要新建一个访问者类。
接收者需要实现accept()接口，访问者需要实现visit()接口。
每种设计模式都有使用场景，都有优点和缺点。随着需求的改变，任何一种设计模式可能都将不再适用。
背景
关于设计模式，之前笔者写过工厂模式，最近在使用gava ListenableFuture时发现事件监听模型特别有意思，于是就把事件监听、观察者之间比较了一番，发现这是一个非常重要的设计模式，在很多框架里扮演关键的作用。
回调函数
为什么首先会讲回调函数呢？因为这个是理解监听器、观察者模式的关键。
什么是回调函数
所谓的回调，用于回调的函数。 回调函数只是一个功能片段，由用户按照回调函数调用约定来实现的一个函数。 有这么一句通俗的定义事件通知链是什么模式：就是程序员A写了一段程序（程序a），其中预留有回调函数接口，并封装好了该程序。程序员B要让a调用自己的程序b中的一个方法，于是，事件通知链是什么模式他通过a中的接口回调自己b中的方法。
举个例子：
这里有两个实体：回调抽象接口、回调者（即程序a）
回调接口（ICallBack ）
public interface ICallBack {
public void callBack();
}
回调者（用于调用回调函数的类）
public class Caller {
}
回调测试：
public static void main(String[] args) {
Caller call = new Caller();
call.call(new ICallBack(){
控制台输出：
start...
终于回调成功了事件通知链是什么模式！
end...
还有一种写法
或实现这个ICallBack接口类
class CallBackC implements ICallBack{
@Override
public void callBack() {
System.out.println("终于回调成功了！");
}
}
有没有发现这个模型和执行一个线程，Thread很像。 没错，Thread就是回调者，Runnable就是一个回调接口。
new Thread(new Runnable(){
@Override
public void run() {
System.out.println("回调一个新线程！");
}}).start();
Callable也是一个回调接口，原来一直在用。 接下来我们开始讲事件监听器
事件监听模式
什么是事件监听器
监听器将监听自己感兴趣的事件一旦该事件被触发或改变，立即得到通知，做出响应。例如：android程序中的Button事件。
java的事件监听机制可概括为3点：
java的事件监听机制涉及到 事件源，事件监听器，事件对象 三个组件,监听器一般是接口，用来约定调用方式
当事件源对象上发生操作时，它将会调用事件监听器的一个方法，并在调用该方法时传递事件对象过去
事件监听器实现类,通常是由开发人员编写，开发人员通过事件对象拿到事件源，从而对事件源上的操作进行处理
举个例子
这里我为了方便，直接使用jdk，EventListener 监听器，感兴趣的可以去研究下源码，非常简单。
监听器接口
public interface EventListener extends java.util.EventListener {
//事件处理
public void handleEvent(EventObject event);
}
事件对象
public class EventObject extends java.util.EventObject{
private static final long serialVersionUID = 1L;
public EventObject(Object source){
super(source);
}
public void doEvent(){
System.out.println("通知一个事件源 source :"+ this.getSource());
}
}
事件源
事件源是事件对象的入口，包含监听器的注册、撤销、通知
public class EventSource {
//监听器列表，监听器的注册则加入此列表
private Vector<EventListener ListenerList = new Vector<EventListener();
//注册监听器
public void addListener(EventListener eventListener){
ListenerList.add(eventListener);
}
//撤销注册
public void removeListener(EventListener eventListener){
ListenerList.remove(eventListener);
}
//接受外部事件
public void notifyListenerEvents(EventObject event){
for(EventListener eventListener:ListenerList){
eventListener.handleEvent(event);
}
}
}
测试执行
public static void main(String[] args) {
EventSource eventSource = new EventSource();
}
控制台显示：
通知一个事件源 source :openWindows
通知一个事件源 source :openWindows
doOpen something...
到这里事件通知链是什么模式你应该非常清楚的了解，什么是事件监听器模式了吧。 那么哪里是回调接口，哪里是回调者，对！EventListener是一个回调接口类，handleEvent是一个回调函数接口，通过回调模型，EventSource 事件源便可回调具体监听器动作。
有了了解后，这里还可以做一些变动。 对特定的事件提供特定的关注方法和事件触发
public class EventSource {
...
public void onCloseWindows(EventListener eventListener){
System.out.println("关注关闭窗口事件");
ListenerList.add(eventListener);
}
}
public static void main(String[] args) {
EventSource windows = new EventSource();
/**
* 另一种实现方式
*/
//关注关闭事件，实现回调接口
windows.onCloseWindows(new EventListener(){
}
这种就类似于，我们的窗口程序，Button监听器了。我们还可以为单击、双击事件定制监听器。
观察者模式
什么是观察者模式
观察者模式其实原理和监听器是一样的，使用的关键在搞清楚什么是观察者、什么是被观察者。
观察者(Observer)相当于事件监器。有个微博模型比较好理解，A用户关注B用户，则A是B的观察者，B是一个被观察者，一旦B发表任何言论，A便可以获得。
被观察者(Observable)相当于事件源和事件，执行事件源通知逻辑时，将会回调observer的回调方法update。
举个例子
为了方便，同样我直接使用jdk自带的Observer。
一个观察者
public class WatcherDemo implements Observer {
@Override
public void update(Observable o, Object arg) {
if(arg.toString().equals("openWindows")){
System.out.println("已经打开窗口");
}
}
}
被观察者
Observable 是jdk自带的被观察者，具体可以自行看源码和之前的监听器事件源类似。
主要方法有
addObserver() 添加观察者，与监听器模式类似
notifyObservers() 通知所有观察者
类Watched.java的实现描述：被观察者，相当于事件监听的事件源和事件对象。又理解为订阅的对象 主要职责：注册/撤销观察者（监听器），接收主题对象（事件对象）传递给观察者（监听器），具体由感兴趣的观察者（监听器）执行
/**
}
测试执行
public static void main(String[] args) {
Watched watched = new Watched();
WatcherDemo watcherDemo = new WatcherDemo();
watched.addObserver(watcherDemo);
watched.addObserver(new Observer(){
@Override
public void update(Observable o, Object arg) {
if(arg.toString().equals("closeWindows")){
System.out.println("已经关闭窗口");
}
}
});
//触发打开窗口事件，通知观察者
watched.notifyObservers("openWindows");
//触发关闭窗口事件，通知观察者
watched.notifyObservers("closeWindows");
控制台输出：
已经打开窗口
已经关闭窗口
总结
从整个实现和调用过程来看，观察者和监听器模式基本一样。
有兴趣的你可以基于这个模型，实现一个简单微博加关注和取消的功能。 说到底，就是事件驱动模型，将调用者和被调用者通过一个链表、回调函数来解耦掉，相互独立。
“你别来找我，有了我会找你”。
整个设计模式的初衷也就是要做到低耦合，低依赖。
再延伸下，消息中间件是什么一个模型？ 将生产者+服务中心（事件源）和消费者（监听器）通过消息队列解耦掉. 消息这相当于具体的事件对象，只是存储在一个队列里（有消峰填谷的作用），服务中心回调消费者接口通过拉或取的模型响应。 想必基于这个模型，实现一个简单的消息中间件也是可以的。
还比如gava ListenableFuture，采用监听器模式就解决了future.get()一直阻塞等待返回结果的问题。
有兴趣的同学，可以再思考下观察者和责任链之间的关系， 我是这样看的。
同样会存在一个链表，被观察者会通知所有观察者，观察者自行处理，观察者之间互不影响。 而责任链，讲究的是击鼓传花，也就是每一个节点只需记录继任节点，由当前节点决定是否往下传。 常用于工作流，过滤器web filter。
事件驱动是JavaScript响应用户操作的一种处理方式，而事件处理是JavaScript响应用户操作所调用的程序代码。
12.2.1 事件驱动
在多年以前，计算机程序通常是以批处理的模式运行。所谓批处理，就是开发者事先写好一些代码，再将这些代码一次运行。这种处理方式有点类似于通过HTML代码直接编写的网页。浏览器只是将HTML代码逐行解析，并显示在浏览器窗口。
后来，在批处理模式中，开发者可以加入一些特定的代码，在程序批处理期间，可以停下来等待用户输入一些信息，并根据用户输入的信息来判断和执行某个程序分支，这就使程序有了初步的交互性。
随着鼠标、触摸屏等设备的出现，批处理时代就逐渐远去，取而代之的是事件驱动的时代。当然，批处理也还能使用，只是使用的范围和频率比事件驱动要少得多。以鼠标为例，在事件驱动中，用户可以使用鼠标单击等方式进行操作，程序则根据鼠标指针的位置以及单击的方式进行响应。JavaScript使用的就是这种事件驱动的程序设计方式。
在JavaScript中，事件（Even）包括以下两个方面：
● 用户在浏览器中产生的操作是事件，如单击鼠标、按下键盘上的键等。
● 文档本身产生的事件，如文档加载完毕、卸载文档等，都是事件。
12.2.2 事件处理
在JavaScript中，浏览器会使用事件来通知JavaScript程序响应用户的操作。事件的类型有很多种，如鼠标事件、键盘事件、加载与卸载事件、得到焦点与失去焦点事件等。在事件产生的时候，浏览器会调用一个JavaScript程序来响应这个事件，这就是JavaScript的事件处理方式。要想让浏览器可以调用合适的JavaScript程序，就必须要做到以下 3点：
（1）设置HTML文档中响应事件的元素。在一个HTML文档中，并非所有元素都会去响应事件。就鼠标单击事件而言，一般在HTML文档的正文不会响应该事件，但在按钮中一般都会响应该事件。
（2）设置元素响应事件的类型。在确定了哪些元素响应事件之后，要设置该元素响应事件的类型。例如，一个按钮通常会响应鼠标单击事件（click事件），而一个下拉列表框通常会响应选项变化事件（change事件）。在同一个元素中，也可以响应多个事件。例如，一个超链接，在鼠标移动到该超链接上时，可以响应鼠标移动到对象上事件（mouseover事件），当鼠标从超链接上移开时，又可以响应鼠标移开事件（mouseout事件）。
（3）设置响应事件的程序。为了让浏览器可以响应事件，必须要设置响应事件的程序。例如一个按钮被单击时，浏览器会响应这个click事件，此时浏览器就会在JavaScript中寻找一个合适的程序，并运行该程序。这个程序可以是用户自定义的函数，也可以是一段JavaScript代码，还可以是JavaScript内置对象的方法等。
看看这个 http://ajava.org/readbook/js/jsdaq/4709.html更详细 关于事件通知链是什么模式和的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。 事件通知链是什么模式的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于、事件通知链是什么模式的信息别忘了在本站进行查找喔。
本文目录一览：
- 1、设计模式（五）行为型模式
- 2、软件设计模式主要有哪几种
- 3、java设计模式-回调、事件监听器、观察者模式
- 4、js 怎么理解js事件观察者模式
- 5、深入理解LINUX网络技术内幕的图书目录
- 6、JavaScript中，1）何为事件驱动模式（文字陈述和代码） 2）JS中事件类型分类（用代码举例说明）
设计模式（五）行为型模式
在上一篇结构型模式中，我们以功能为基本单位，研究了一些设计模式，用于实现功能转换、功能组合、功能封装等目的。我们知道，面向对象编程有两个核心元素：对象、对象间通信协作。从面向对象的角度看，任何系统和功能，都是由一个个对象，相互分工合作实现的。推而广之，很多系统也都是这样组织和运行的。
本章的设计模式，列举了通用场景下常用功能机制的经典实现方法，讲解了经典实现中是如何高效组织对象、控制对象协作交互的，具有很好的参考价值。
示例：https://www.runoob.com/design-pattern/chain-of-responsibility-pattern.html
责任链模式，就是把程序处理对象前后排列起来，形成一条处理线。处理线上需要被处理的信息，在处理线上向下传递，任何一个节点都可以随时中断传递。
GUI系统中的事件传递机制（在Javascript中叫做事件冒泡），是责任链模式最典型的应用之一。
当某一事件发生时，最顶层GUI对象会首先收到事件，但是它先不处理，而是依次交给命中的子GUI对象处理。当子GUI对象返回为False时，表示事件未被接收，此时父GUI对象才真正对发生的事件进行业务处理。
可以看出，事件传递机制，是一种增强版的责任链模式，它的节点处理权，经历了向下和向上的双向传递过程。
总结：当项目中一个数据对象，需要被多个处理对象进行处理时，可以将处理对象链接起来，然后把数据对象传递给头节点，随着处理的进行，数据对象的处理权会在处理链中流动，从而完成整个处理过程。
责任链模式结构适用于需求固定的场景，用于实现简单高效的处理机制。假如需求不断变化，而且功能很复杂，那么用责任链模式很可能就无法胜任了，需要采用新的高复杂度的设计。例如，如果想要数据对象在所有处理对象中根据状态来实现跳转，可以选择使用状态机等其他方案来实现。
示例：https://www.runoob.com/design-pattern/command-pattern.html
想要实现撤销、重做、事务等功能，可以使用此设计模式。通常在编辑器、数据库中有此类功能需求。
命令也就是请求，或者叫调用。命令模式要求将请求参数和请求相关的方法封装在一起。
请求对象中封装了实现“撤销”、“重做”、“事务”功能所需要的所有信息，实现了关联信息的高内聚，所以可以实现我们想要的功能。
例如，可以在请求对象中保存修改之前的值、修改之后的值。利用修改之前的值，可以实现“撤销”功能；利用修改之后的值，可以实现“重做”功能。如果将所有请求对象都记录下来，并按照先后顺序排列起来，形成“撤销重做”堆栈，这样就可以实现连续的“撤销”、“重做”。“事务”则是“撤销”与“重做”的结合体，正常执行流程等同于“重做”，发生错误需要回滚，等同于“撤销”。
如果不采用这种方式，会导致实现这些功能的信息，分散在源码中多个地方，或者已经丢失，没有保存，就无法实现“撤销”、“重做”、“事务”功能。
同时，实现请求参数高内聚，也可以很方便地将它们保存到磁盘上，保存到文件的过程叫做“序列化”，从文件中读取的过程叫“反序列化”。这里的序列指的就是二进制流。
Qt中与命令模式相关的部分是：Undo Framework，里面有示例项目，不熟悉的同学可以抽点时间看一看。
示例：https://www.runoob.com/design-pattern/interpreter-pattern.html
顾名思义，解释器模式是用来实现解释器的。 解释器是这样一个程序：解释器以符合语法的文本为输入，解释输入内容，完成一定的计算功能。文本可以在程序运行时动态加载，动态解释、动态执行。
实现简单的解释器：命令行程序，如ping命令、cd命令等； 实现复杂的解释器：脚本语言解释器，如python，lua，javascript；计算器。
我们知道，在GUI图形用户界面被发明之前，人类和程序之间的交互是通过敲命令行实现的，缺点是使用难度较大，门槛较高。 在GUI发明以后，交互更加友好，电脑更加易于使用了，所以也更加普及了。
但是GUI交互的缺点在于，不够灵活，对参数的控制粒度不够细致。例如，现在大多数开发者都使用集成开发环境来开发软件，一般情况下都使用默认参数，比较方便。但是如果你想要更改某些编译选项，可能还是需要直接修改底层的编译命令。命令相对于GUI元素更加灵活，过于灵活的地方用GUI比较难于实现，例如组合、递归、跳转等等。在这些场景下，使用解释器是非常合适的。但是通常情况下，这个模式并不常用。
示例：https://www.runoob.com/design-pattern/iterator-pattern.html
在需要多次遍历同一个数据集合的时候，为了少些一些for，或者想要把遍历过程封装起来，降低耦合，就可以使用迭代器模式。这个模式非常常用。
迭代器就是一个专门用来遍历数组的类。它只需要实现两个接口：hasNext()、next()。 hasNext()接口用于控制循环何时停止；next()接口用于取出当前位置的数据元素，并将遍历指针指向下一个元素。 当然，构造迭代器对象的时候，需要将数据集合传递给迭代器，让迭代器知道要遍历哪些数据。
原本需要用for循环来遍历的代码，现在通过封装，提取出了“遍历”这一功能所需要的必要信息，定义了两个接口，把不必要暴露的信息封装在了迭代器中，妥妥的实现了解耦。
示例：https://www.runoob.com/design-pattern/mediator-pattern.html
中介者模式是指，在原本直接通信的对象之间，添加一个通信中间层，使对象间通信变为间接通信，降低对象间的耦合。
此模式和代理模式基本思想上是一致的。二者的区别是：代理模式是通过加一个中间层，来实现两个原本很难交互的功能主体，实现顺畅交互；中介者模式是为了降低对象间通信时的耦合而提出的，为的是提高代码的可维护性。
比较大的项目中会用到，一般存在于某些框架中。因为大的项目中对象繁多，通信也比较复杂，适合使用中介者模式。
在大的项目中，一般会有一个全局的通信管理器，任何对象都可以使用通信管理器提供的接口，将自己注册为某一个具有唯一ID消息的发送者和接收者。这样发送者只需要发送消息，不需要管谁来接收，不需要拥有发送者的实例指针，发出消息后，已注册的接收者都会收到消息。接收者不需要管信号是谁发的，即不需要拥有发送者的实例指针。
所以，中介者模式也可以叫“通信中介模式”。
示例：https://www.runoob.com/design-pattern/memento-pattern.html
这个模式和状态存档功能是绑定在一起的。为了在程序中实现状态存档功能，可以使用备忘录模式。
原例子中有三个类，个人觉得没有必要，这里我们简化成两个类，即备忘录模式中有两个类：状态对象类和状态对象管理类。 状态对象类是状态字段是集合，并提供了存取接口；状态对象管理类负责组织和保存状态对象。当然实际实现中可以根据需求增加类，配合使用，完成状态保存恢复。
当一个对象会影响到其他多个对象时，即当对象间存在一对多关系时，使用观察者模式。 一般应用于单向通知的场景，如GUI中鼠标事件、按键事件、窗口事件通知。使用Qt中的信号槽机制可以实现此模式。
“一”是指发生变化的那个对象，“多”是指需要获取此变化通知的对象组。其中，变化消息是单向地由“一”到“多”传递的。如果不是单向的或者对象间不是一对多的关系，更加复杂，就需要重新思考其他对象间通信模型。
如果不使用此模式，可能会导致观察者不能动态增加或删除；可能会造成发送者的业务代码和接收者的响应代码混在一起，耦合严重。
使用此模式，需要为观察者设计一个基类，并设计一个接收通知的接口，所有观察者需要实现通知接口；所有观察者指针可以保存在队列中，实现动态增删。
状态模式用于实现状态机。 如果一个程序功能中存在某些状态，在一定情况下，这些状态可以互相转换，并且在转换前后需要作出对应的操作，这种情况下使用状态机来实现就非常合适。
如果不使用状态机（状态模式），一般的实现方法是使用一连串的if-else，或者使用长长的switch-case来实现。这样做的缺点，一方面状态判断不够高效，另一方面是业务代码集中在一块，不好维护。
使用状态机，每个状态都是一个类，相关的业务代码分布到各自的状态类中，能够实现不同的状态及与状态相关的业务代码解耦。同时某个状态和下一个状态是关联好的，在状态切换时，效率更高，不需要执行长长的判断。
Qt中已实现状态机框架，The State Machine Framework，在此框架下，我们可以更加专注于业务实现，而不是状态机本身的技术细节。
示例：https://www.runoob.com/design-pattern/null-object-pattern.html
使用基类保存子类对象通常有两种做法：
第一种方法用指针是基本方法，但是指针用起来要非常小心，要考虑内存释放的问题。此时空对象就可以用空指针表示。 第二种方法用基类对象保存子类对象，这种方法使用起来相对省心，不用与指针打交道，使用者不用直接管理内存。例如Qt中的Qt XML C++ Classes类的设计就是采用这种方式设计的。这种情况下，因为不使用指针，就需要使用空对象来代替空指针。
可以仿造Qt XML中的类进行设计。一般需要提供isNull()接口，对象类型转换接口等。
策略模式和桥接模式类似，用于实现功能切换与组合。二者区别在于，策略模式专注于一个功能的不同实现方式；桥接模式专注于多个功能之间的组合。
将功能抽象成单独的类，功能切换只需要切换不同的功能子类即可，同一个功能需要实现同一个功能接口。
示例：https://www.runoob.com/design-pattern/template-pattern.html
模板模式应该是我们最熟悉的。 这里的模板就是接口类，接口类定义了使用者和功能提供者之间交互的函数列表。子类负责功能的具体实现。
示例：https://www.runoob.com/design-pattern/visitor-pattern.html
访问者模式用于将数据结构与数据操作相分离。
访问者模式和迭代器模式类似。迭代器模式一般用来遍历数组，所以没有把for封装起来。而访问者模式可以遍历一切类型的数据结构，具体的遍历过程被封装在接收者内部。同时，对每一个遍历得到的数组元素的操作，被封装在访问者内部。每一种对元素不同的操作，都需要新建一个访问者类。
接收者需要实现accept()接口，访问者需要实现visit()接口。
每种设计模式都有使用场景，都有优点和缺点。随着需求的改变，任何一种设计模式可能都将不再适用。
软件设计模式主要有哪几种
软件设计模式主要有以下三大类共23种事件通知链是什么模式：
一、创建型模式事件通知链是什么模式：
1、工厂方法模式工厂方法模式的创建是因为简单工厂模式有一个问题，在简单工厂模式中类的创建依赖工厂类，如果想要拓展程序，必须对工厂类进行修改，这违背事件通知链是什么模式了开闭原则，所以就出现了工厂方法模式，只需要创建一个工厂接口和多个工厂实现类。
2、抽象工厂模式抽象工厂模式是提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。区别于工厂方法模式的地方，工厂方法模式是创建一个工厂，可以实现多种对象；而抽象工厂模式是提供一个抽象工厂接口，里面定义多种工厂，每个工厂可以生产多种对象。
3、单例模式单例模式能保证一个类仅有一个实例，并提供一个访问它的全局访问点，同时在类内部创造单一对象，通过设置权限，使类外部无法再创造对象。单例对象能保证在一个JVM中，该对象只有一个实例存在。
4、建造者模式建造者模式是将一个复杂的构建与其表示相分离，使得同样的构建过程可以创建不同的表示。在程序当中就是将一些不会变的基本组件，通过builder来进行组合，构建复杂对象，实现分离。
5、原型模式：原型模式是用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。其实就是将对象复制了一份并返还给调用者，对象需继承Cloneable并重写clone方法。原型模式的思想就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象。
二、结构型模式：
1、适配器模式适配器模式是使得原本由于接口不兼容而不能一起工作的那些类可以一起工作，衔接两个不兼容、独立的接口的功能，使得它们能够一起工作，适配器起到中介的作用。
2、装饰模式：装饰器模式是动态地给一个对象添加一些额外的职责，给一个对象增加一些新的功能，要求装饰对象和被装饰对象实现同一个接口，装饰对象持有被装饰对象的实例。除了动态的增加，也可以动态的撤销，要做到动态的形式，不可以用继承实现，因为继承是静态的。
3、代理模式代理模式是为其他对象提供一种代理以控制对这个对象的访问，也就是创建类的代理类，间接访问被代理类的过程中，对其功能加以控制。
4、外观模式外观模式是为子系统中的一组接口提供一个一致的界面，外观模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。
5、桥接模式桥接模式是将抽象部分与实现部分分离，使它们都可以独立的变化。桥接模式就是把事物和其具体实现分开，使他们可以各自独立的变化（突然联想到了mvc模式）。
6、组合模式：组合模式是将对象组合成树形结构以表示"部分-整体"的层次结构，组合模式使得用户对单个对象和组合对象的使用具有一致性。
7、享元模式：享元模式是运用共享技术有效地支持大量细粒度的对象。享元模式的主要目的是实现对象的共享，即共享池，当系统中对象多的时候可以减少内存的开销，重用现有的同类对象，若未找到匹配的对象，则创建新对象，这样可以减少对象的创建，降低系统内存，提高效率。
三、行为型模式：
1、策略模式：
策略模式是定义一系列的算法,把它们一个个封装起来, 并且使它们可相互替换，且算法的变化不会影响到使用算法的客户。
2、模版方法模式：
模板方法模式是定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。该模式就是在一个抽象类中，有一个主方法，再定义1...n个方法，可以是抽象的，也可以是实际的方法，定义一个类，继承该抽象类，重写抽象方法，通过调用抽象类，实现对子类的调用。
模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤，将一些固定步骤、固定逻辑的方法封装成模板方法。调用模板方法即可完成那些特定的步骤。
3、观察者模式：
观察者模式是定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
也就是当被观察者状态变化时，通知所有观察者，这种依赖方式具有双向性，在QQ邮箱中的邮件订阅和RSS订阅，当用户浏览一些博客时，经常会看到RSS图标，简单来说就是当订阅了该文章，如果后续有更新，会及时通知用户。这种现象即是典型的观察者模式。
4、迭代器模式：
迭代器模式是提供一种方法顺序访问一个聚合对象中各个元素, 而又无须暴露该对象的内部表示。
在Java当中，将聚合类中遍历各个元素的行为分离出来，封装成迭代器，让迭代器来处理遍历的任务；使简化聚合类，同时又不暴露聚合类的内部，在事件通知链是什么模式我们经常使用的JDK中各个类也都是这些基本的东西。
5、责任链模式：
责任链模式是避免请求发送者与接收者耦合在一起，让多个对象都有可能接收请求，将这些对象连接成一条链，并且沿着这条链传递请求，直到有对象处理它为止。有多个对象，每个对象持有对下一个对象的引用，这样就会形成一条链，请求在这条链上传递，直到某一对象决定处理该请求。
6、命令模式：
命令模式是将一个请求封装成一个对象，从而使发出者可以用不同的请求对客户进行参数化。模式当中存在调用者、接收者、命令三个对象，实现请求和执行分开；调用者选择命令发布，命令指定接收者。
7、备忘录模式：
备忘录模式是在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。创建一个备忘录类，用来存储原始类的信息；同时创建备忘录仓库类，用来存储备忘录类，主要目的是保存一个对象的某个状态，以便在适当的时候恢复对象，也就是做个备份。
8、状态模式：
状态模式是允许对象在内部状态发生改变时改变它的行为。对象具有多种状态，且每种状态具有特定的行为。
9、访问者模式：
访问者模式主要是将数据结构与数据操作分离。在被访问的类里面加一个对外提供接待访问者的接口，访问者封装了对被访问者结构的一些杂乱操作，解耦结构与算法，同时具有优秀的扩展性。通俗来讲就是一种分离对象数据结构与行为的方法。
10、中介者模式：
中介者模式是用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。
11、解释器模式：
解释器模式是给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子，基本也就用在这个范围内，适用面较窄，例如：正则表达式的解释等。
软件设计的概念以及意义：
软件设计模式是对软件设计经验的总结，是对软件设计中反复出现的设计问题的成功解决方案的描述。为了记录这些成功的设计经验并方便以后使用，软件设计模式通常包含 4 个基本要素：模式名称、问题、解决方案以及效果。
模式名称实际上就是一个帮助记忆的名称，是用于软件设计的技术术语，有助于设计者之间的交流。
问题描述了设计者所面临的设计场景，用于告诉设计者在什么情况下使用该模式。
解决方案描述了设计的细节，通常会给出方案的原理图示（例如 UML 的类图，序列图等，也可能是一些示意图）及相关文字说明，如果可能，还会给出一些代码实例，以便对解决方案的深入理解。
效果描述了设计方案的优势和劣势，这些效果通常面向软件的质量属性，例如，可扩展性、可复用性等。
软件设计模式的重要意义在于设计复用。设计模式可以使设计者更加方便地借鉴或直接使用已经过证实的成功设计方案，而不必花费时间进行重复设计。一些设计模式甚至提供了显示的类图设计及代码实例，为设计的文档化及软件的开发提供了直接的支持。
java设计模式-回调、事件监听器、观察者模式
转自( https://my.oschina.net/u/923324/blog/792857 )背景
关于设计模式，之前笔者写过工厂模式，最近在使用gava ListenableFuture时发现事件监听模型特别有意思，于是就把事件监听、观察者之间比较了一番，发现这是一个非常重要的设计模式，在很多框架里扮演关键的作用。
回调函数
为什么首先会讲回调函数呢？因为这个是理解监听器、观察者模式的关键。
什么是回调函数
所谓的回调，用于回调的函数。 回调函数只是一个功能片段，由用户按照回调函数调用约定来实现的一个函数。 有这么一句通俗的定义事件通知链是什么模式：就是程序员A写了一段程序（程序a），其中预留有回调函数接口，并封装好了该程序。程序员B要让a调用自己的程序b中的一个方法，于是，事件通知链是什么模式他通过a中的接口回调自己b中的方法。
举个例子：
这里有两个实体：回调抽象接口、回调者（即程序a）
回调接口（ICallBack ）
public interface ICallBack {
public void callBack();
}
回调者（用于调用回调函数的类）
public class Caller {
}
回调测试：
public static void main(String[] args) {
Caller call = new Caller();
call.call(new ICallBack(){
控制台输出：
start...
终于回调成功了事件通知链是什么模式！
end...
还有一种写法
或实现这个ICallBack接口类
class CallBackC implements ICallBack{
@Override
public void callBack() {
System.out.println("终于回调成功了！");
}
}
有没有发现这个模型和执行一个线程，Thread很像。 没错，Thread就是回调者，Runnable就是一个回调接口。
new Thread(new Runnable(){
@Override
public void run() {
System.out.println("回调一个新线程！");
}}).start();
Callable也是一个回调接口，原来一直在用。 接下来我们开始讲事件监听器
事件监听模式
什么是事件监听器
监听器将监听自己感兴趣的事件一旦该事件被触发或改变，立即得到通知，做出响应。例如：android程序中的Button事件。
java的事件监听机制可概括为3点：
java的事件监听机制涉及到 事件源，事件监听器，事件对象 三个组件,监听器一般是接口，用来约定调用方式
当事件源对象上发生操作时，它将会调用事件监听器的一个方法，并在调用该方法时传递事件对象过去
事件监听器实现类,通常是由开发人员编写，开发人员通过事件对象拿到事件源，从而对事件源上的操作进行处理
举个例子
这里我为了方便，直接使用jdk，EventListener 监听器，感兴趣的可以去研究下源码，非常简单。
监听器接口
public interface EventListener extends java.util.EventListener {
//事件处理
public void handleEvent(EventObject event);
}
事件对象
public class EventObject extends java.util.EventObject{
private static final long serialVersionUID = 1L;
public EventObject(Object source){
super(source);
}
public void doEvent(){
System.out.println("通知一个事件源 source :"+ this.getSource());
}
}
事件源
事件源是事件对象的入口，包含监听器的注册、撤销、通知
public class EventSource {
//监听器列表，监听器的注册则加入此列表
private Vector<EventListener ListenerList = new Vector<EventListener();
//注册监听器
public void addListener(EventListener eventListener){
ListenerList.add(eventListener);
}
//撤销注册
public void removeListener(EventListener eventListener){
ListenerList.remove(eventListener);
}
//接受外部事件
public void notifyListenerEvents(EventObject event){
for(EventListener eventListener:ListenerList){
eventListener.handleEvent(event);
}
}
}
测试执行
public static void main(String[] args) {
EventSource eventSource = new EventSource();
}
控制台显示：
通知一个事件源 source :openWindows
通知一个事件源 source :openWindows
doOpen something...
到这里事件通知链是什么模式你应该非常清楚的了解，什么是事件监听器模式了吧。 那么哪里是回调接口，哪里是回调者，对！EventListener是一个回调接口类，handleEvent是一个回调函数接口，通过回调模型，EventSource 事件源便可回调具体监听器动作。
有了了解后，这里还可以做一些变动。 对特定的事件提供特定的关注方法和事件触发
public class EventSource {
...
public void onCloseWindows(EventListener eventListener){
System.out.println("关注关闭窗口事件");
ListenerList.add(eventListener);
}
}
public static void main(String[] args) {
EventSource windows = new EventSource();
/**
* 另一种实现方式
*/
//关注关闭事件，实现回调接口
windows.onCloseWindows(new EventListener(){
}
这种就类似于，我们的窗口程序，Button监听器了。我们还可以为单击、双击事件定制监听器。
观察者模式
什么是观察者模式
观察者模式其实原理和监听器是一样的，使用的关键在搞清楚什么是观察者、什么是被观察者。
观察者(Observer)相当于事件监器。有个微博模型比较好理解，A用户关注B用户，则A是B的观察者，B是一个被观察者，一旦B发表任何言论，A便可以获得。
被观察者(Observable)相当于事件源和事件，执行事件源通知逻辑时，将会回调observer的回调方法update。
举个例子
为了方便，同样我直接使用jdk自带的Observer。
一个观察者
public class WatcherDemo implements Observer {
@Override
public void update(Observable o, Object arg) {
if(arg.toString().equals("openWindows")){
System.out.println("已经打开窗口");
}
}
}
被观察者
Observable 是jdk自带的被观察者，具体可以自行看源码和之前的监听器事件源类似。
主要方法有
addObserver() 添加观察者，与监听器模式类似
notifyObservers() 通知所有观察者
类Watched.java的实现描述：被观察者，相当于事件监听的事件源和事件对象。又理解为订阅的对象 主要职责：注册/撤销观察者（监听器），接收主题对象（事件对象）传递给观察者（监听器），具体由感兴趣的观察者（监听器）执行
/**
}
测试执行
public static void main(String[] args) {
Watched watched = new Watched();
WatcherDemo watcherDemo = new WatcherDemo();
watched.addObserver(watcherDemo);
watched.addObserver(new Observer(){
@Override
public void update(Observable o, Object arg) {
if(arg.toString().equals("closeWindows")){
System.out.println("已经关闭窗口");
}
}
});
//触发打开窗口事件，通知观察者
watched.notifyObservers("openWindows");
//触发关闭窗口事件，通知观察者
watched.notifyObservers("closeWindows");
控制台输出：
已经打开窗口
已经关闭窗口
总结
从整个实现和调用过程来看，观察者和监听器模式基本一样。
有兴趣的你可以基于这个模型，实现一个简单微博加关注和取消的功能。 说到底，就是事件驱动模型，将调用者和被调用者通过一个链表、回调函数来解耦掉，相互独立。
“你别来找我，有了我会找你”。
整个设计模式的初衷也就是要做到低耦合，低依赖。
再延伸下，消息中间件是什么一个模型？ 将生产者+服务中心（事件源）和消费者（监听器）通过消息队列解耦掉. 消息这相当于具体的事件对象，只是存储在一个队列里（有消峰填谷的作用），服务中心回调消费者接口通过拉或取的模型响应。 想必基于这个模型，实现一个简单的消息中间件也是可以的。
还比如gava ListenableFuture，采用监听器模式就解决了future.get()一直阻塞等待返回结果的问题。
有兴趣的同学，可以再思考下观察者和责任链之间的关系， 我是这样看的。
同样会存在一个链表，被观察者会通知所有观察者，观察者自行处理，观察者之间互不影响。 而责任链，讲究的是击鼓传花，也就是每一个节点只需记录继任节点，由当前节点决定是否往下传。 常用于工作流，过滤器web filter。
js 怎么理解js事件观察者模式
观察者模式主要应用于对象之间一对多的依赖关系，当一个对象发生改变时，多个对该对象有依赖的其他对象也会跟着做出相应改变，这就非常适合用观察者模式来实现。使用观察者模式可以根据需要增加或删除对象，解决一对多对象间的耦合关系，使程序更易于扩展和维护。
基础知识:
观察者模式定义了对象间的一种一对多依赖关系，每当一个对象发生改变时，其相关依赖对象皆得到通知并被进行相应的改变。观察者模式又叫做发布-订阅模式。生活中有很多类似的关系，比如微信公众号订阅，多个读者订阅一个微信公众号，一旦公众号有更新，多个读者都会收到更新，而这种情况在应用程序中也非常常见，js绑定各种事件本质上就是观察者模式的实现。
观察者模式是一个非常有用的设计模式，它主要有两个角色组成：
（1）目标对象：作为一对多关系中的一，可以用来管理观察者的增加和删除。
（2）观察者对象：观察目标对象，一旦目标发生改变则做出相应的反应。
更多详解查看:网页链接,希望可以帮到你
深入理解LINUX网络技术内幕的图书目录
前言
第一部分 基础背景
第一章 简介
基本术语
常见编码模式
用户空间工具
浏览源代码
当功能以补丁形式提供时
第二章 关键数据结构
套接字缓冲区：sk—buff结构
net—device结构
本章涉及的文件
第三章 用户空间与内核的接
概论
procfs与sysctl
ioctl
Netlink
配置改变串行化
第二部分 系统初始化
第四章 通知链
使用通知链的原因
概论
定义链
链注册
链上的通知事件
网络子系统的通知链
通过/proc文件系统的调整
本章涉及的函数和变量
本章涉及的文件和目录
第五章 网络设备初始化
系统初始化概论
设备注册和初始化
NIC初始化的基本目标
设备与内核之间的交互
初始化选项
模块选项
设备处理层初始化：net—dev—init
用户空间辅助程序
虚拟设备
通过/proc文件系统调整
本章涉及的函数和变量
本章涉及的文件和目录
第六章 PCI层和网络接口卡
本章涉及的数据结构
PCI NIC设备驱动程序的注册
电源管理和网络唤醒
PCI NIC驱动程序注册范例
大蓝图
通过/proc文件系统调整
本章涉及的函数和变量
本章涉及的文件和目录
第七章 组件初始化的内核基础架构
引导期间的内核选项
模块初始化代码
优化宏卷标
引导期间初始化函数
内存最优化
同第六章后三条
第八章 设备注册和初始化
设备注册之时
设备除名之时
分配net—device结构
NIC注册和除名的架构
设备初始化
net—device结构的组织
设备状态
设备的注册和除名
设备注册
设备除名
开启和关闭网络设备
更新设备队列规则状态
从用户空间配置设备相关信息
虚拟设备
上锁
同第六章后三条
第三部分 传输和接收
第九章 中断和网络驱动程序
决策和流量方向
接收到帧时通知驱动程序
.....................
JavaScript中，1）何为事件驱动模式（文字陈述和代码） 2）JS中事件类型分类（用代码举例说明）
12.2 事件驱动与事件处理事件驱动是JavaScript响应用户操作的一种处理方式，而事件处理是JavaScript响应用户操作所调用的程序代码。
12.2.1 事件驱动
在多年以前，计算机程序通常是以批处理的模式运行。所谓批处理，就是开发者事先写好一些代码，再将这些代码一次运行。这种处理方式有点类似于通过HTML代码直接编写的网页。浏览器只是将HTML代码逐行解析，并显示在浏览器窗口。
后来，在批处理模式中，开发者可以加入一些特定的代码，在程序批处理期间，可以停下来等待用户输入一些信息，并根据用户输入的信息来判断和执行某个程序分支，这就使程序有了初步的交互性。
随着鼠标、触摸屏等设备的出现，批处理时代就逐渐远去，取而代之的是事件驱动的时代。当然，批处理也还能使用，只是使用的范围和频率比事件驱动要少得多。以鼠标为例，在事件驱动中，用户可以使用鼠标单击等方式进行操作，程序则根据鼠标指针的位置以及单击的方式进行响应。JavaScript使用的就是这种事件驱动的程序设计方式。
在JavaScript中，事件（Even）包括以下两个方面：
● 用户在浏览器中产生的操作是事件，如单击鼠标、按下键盘上的键等。
● 文档本身产生的事件，如文档加载完毕、卸载文档等，都是事件。
12.2.2 事件处理
在JavaScript中，浏览器会使用事件来通知JavaScript程序响应用户的操作。事件的类型有很多种，如鼠标事件、键盘事件、加载与卸载事件、得到焦点与失去焦点事件等。在事件产生的时候，浏览器会调用一个JavaScript程序来响应这个事件，这就是JavaScript的事件处理方式。要想让浏览器可以调用合适的JavaScript程序，就必须要做到以下 3点：
（1）设置HTML文档中响应事件的元素。在一个HTML文档中，并非所有元素都会去响应事件。就鼠标单击事件而言，一般在HTML文档的正文不会响应该事件，但在按钮中一般都会响应该事件。
（2）设置元素响应事件的类型。在确定了哪些元素响应事件之后，要设置该元素响应事件的类型。例如，一个按钮通常会响应鼠标单击事件（click事件），而一个下拉列表框通常会响应选项变化事件（change事件）。在同一个元素中，也可以响应多个事件。例如，一个超链接，在鼠标移动到该超链接上时，可以响应鼠标移动到对象上事件（mouseover事件），当鼠标从超链接上移开时，又可以响应鼠标移开事件（mouseout事件）。
（3）设置响应事件的程序。为了让浏览器可以响应事件，必须要设置响应事件的程序。例如一个按钮被单击时，浏览器会响应这个click事件，此时浏览器就会在JavaScript中寻找一个合适的程序，并运行该程序。这个程序可以是用户自定义的函数，也可以是一段JavaScript代码，还可以是JavaScript内置对象的方法等。
看看这个 http://ajava.org/readbook/js/jsdaq/4709.html更详细 关于事件通知链是什么模式和的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。 事件通知链是什么模式的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于、事件通知链是什么模式的信息别忘了在本站进行查找喔。
相关文章
发表评论
暂时没有评论，来抢沙发吧~