Esper学习之十四：Pattern（一）

1. Pattern Atoms and Pattern operators
Pattern是通过原子事件和操作符组合在一起构成模板。原子事件有3类，操作符有4类，具体如下：

原子事件：
1). 普通事件：包括POJO，Map，Array，XML
2). 时间事件：包括间隔n个时间单位、crontab
3). 自定义插件：用于观察特定事件的发生

操作符：
1). 重复操作符：every, every-distinct, [num] and until
2). 逻辑操作符：and, or, not
3). 顺序操作符：->（Followed by）
4). 事件生命周期操作符：timer:within, timer:withinmax, while-expression, 自定义插件

关于操作符，自然会有优先级，具体如下：

Precedence Operator Description Example
1

guard postfix

 where timer:within and while (expression) (incl. withinmax and plug-in pattern guard)

MyEvent where timer:within(1 sec)
2

unary

 every, not every, distinct

every MyEvent
timer:interval(5 min) and not MyEvent
3 repeat [num], until

[5] MyEvent

[1..3] MyEvent until MyOtherEvent
4 and and every (MyEvent and MyOtherEvent)
5 or or every (MyEvent or MyOtherEvent)
6 followed by -> every (MyEvent -> MyOtherEvent)

上面的内容各位可以先有个印象，方便理解之后的详解。

2. Pattern Filter Expression
Pattern的Filter表达式和普通的表达式没有区别，我就不展开讲解了，各位看看下面几个例子就好，除了Filter之外的东西暂时不用关心是什么意思。

1). every e1=RfidEvent -> e2=RfidEvent(assetId=e1.assetId)
2). every e1=RfidEvent -> e2=RfidEvent(MyLib.isInRadius(e1.x, e1.y, x, y) and zone in (1, e1.zone))
3). every (RfidEvent(zone > 1) and RfidEvent(zone < 10))

3. Controlling Event Consumption
       上面说到了Filter，因为Pattern可以由多个原子事件组成，那么Filter自然也会有多个，正常情况下，所有的Filter都会对进入引擎的事件进行判定，但是我们也有只需要判定一次的时候，只要满足了某个Filter，那么其他的Filter就不用管这个事件了。Esper考虑到了这个需求，我们只需要在Filter表达式后面加个@consume注解即可，此注解可以跟随数字，表示过滤的优先级。默认优先级为1，数值越大优先级越高。

为了结合上面几节的知识，我给了个完整的实例：

[java] view plaincopy

  1. package example;
  2. import com.espertech.esper.client.EPAdministrator;
  3. import com.espertech.esper.client.EPRuntime;
  4. import com.espertech.esper.client.EPServiceProvider;
  5. import com.espertech.esper.client.EPServiceProviderManager;
  6. import com.espertech.esper.client.EPStatement;
  7. import com.espertech.esper.client.EventBean;
  8. import com.espertech.esper.client.UpdateListener;
  9. /**
  10. * Created by Luonanqin on 8/11/14.
  11. */
  12. class ConsumeEvent {
  13. private int id;
  14. private String name;
  15. private int age;
  16. public int getId() {
  17. return id;
  18. }
  19. public void setId(int id) {
  20. this.id = id;
  21. }
  22. public String getName() {
  23. return name;
  24. }
  25. public void setName(String name) {
  26. this.name = name;
  27. }
  28. public int getAge() {
  29. return age;
  30. }
  31. public void setAge(int age) {
  32. this.age = age;
  33. }
  34. public String toString() {
  35. return "ConsumeEvent{" + "id=" + id + ", name=‘" + name + ‘\‘‘ + ", age=" + age + ‘}‘;
  36. }
  37. }
  38. class PatternConsumeListener1 implements UpdateListener {
  39. public void update(EventBean[] newEvents, EventBean[] oldEvents) {
  40. if (newEvents != null) {
  41. for (int i = 0; i < newEvents.length; i++) {
  42. System.out.println("a: " + newEvents[i].get("a"));
  43. System.out.println("b: " + newEvents[i].get("b"));
  44. }
  45. }
  46. }
  47. }
  48. class PatternConsumeListener2 implements UpdateListener {
  49. public void update(EventBean[] newEvents, EventBean[] oldEvents) {
  50. if (newEvents != null) {
  51. for (int i = 0; i < newEvents.length; i++) {
  52. System.out.println("a: " + newEvents[i].get("a"));
  53. System.out.println("b: " + newEvents[i].get("b"));
  54. System.out.println("c: " + newEvents[i].get("c"));
  55. }
  56. }
  57. }
  58. }
  59. public class PatternConsumeTest {
  60. public static void main(String[] args) {
  61. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
  62. EPAdministrator admin = epService.getEPAdministrator();
  63. EPRuntime runtime = epService.getEPRuntime();
  64. String consume = ConsumeEvent.class.getName();
  65. String epl1 = "every (a=" + consume + "(id = 1)@consume and b=" + consume + "(name = ‘luonq‘))";
  66. System.out.println("EPL1: " + epl1 + "\n");
  67. EPStatement stat1 = admin.createPattern(epl1);
  68. stat1.addListener(new PatternConsumeListener1());
  69. ConsumeEvent ce1 = new ConsumeEvent();
  70. ce1.setId(1);
  71. ce1.setName("luonq");
  72. System.out.println("Send Event: " + ce1);
  73. runtime.sendEvent(ce1);
  74. System.out.println();
  75. ConsumeEvent ce2 = new ConsumeEvent();
  76. ce2.setId(2);
  77. ce2.setName("luonq");
  78. System.out.println("Send Event: " + ce2);
  79. runtime.sendEvent(ce2);
  80. stat1.destroy();
  81. System.out.println();
  82. String epl2 = "every (a=" + consume + "(id = 1)@consume(2) or b=" + consume + "(name = ‘luonq‘)@consume(3) or c=" + consume + "(age > 2))";
  83. System.out.println("EPL2: " + epl2 + "\n");
  84. EPStatement stat2 = admin.createPattern(epl2);
  85. stat2.addListener(new PatternConsumeListener2());
  86. ConsumeEvent ce3 = new ConsumeEvent();
  87. ce3.setId(1);
  88. ce3.setName("luonq");
  89. ce3.setAge(3);
  90. System.out.println("Send Event: " + ce3);
  91. runtime.sendEvent(ce3);
  92. ConsumeEvent ce4 = new ConsumeEvent();
  93. ce4.setId(1);
  94. ce4.setName("luonqin");
  95. ce4.setAge(1);
  96. System.out.println("Send Event: " + ce4);
  97. runtime.sendEvent(ce4);
  98. ConsumeEvent ce5 = new ConsumeEvent();
  99. ce5.setId(3);
  100. ce5.setName("luonqin");
  101. ce5.setAge(5);
  102. System.out.println("Send Event: " + ce5);
  103. runtime.sendEvent(ce5);
  104. }
  105. }

执行结果：

[plain] view plaincopy

  1. EPL1: every (a=example.ConsumeEvent(id = 1)@consume and b=example.ConsumeEvent(name = ‘luonq‘))
  2. Send Event: ConsumeEvent{id=1, name=‘luonq‘, age=0}
  3. Send Event: ConsumeEvent{id=2, name=‘luonq‘, age=0}
  4. a: ConsumeEvent{id=1, name=‘luonq‘, age=0}
  5. b: ConsumeEvent{id=2, name=‘luonq‘, age=0}
  6. EPL2: every (a=example.ConsumeEvent(id = 1)@consume(2) or b=example.ConsumeEvent(name = ‘luonq‘)@consume(3) or c=example.ConsumeEvent(age > 2))
  7. Send Event: ConsumeEvent{id=1, name=‘luonq‘, age=3}
  8. a: null
  9. b: ConsumeEvent{id=1, name=‘luonq‘, age=3}
  10. c: null
  11. Send Event: ConsumeEvent{id=1, name=‘luonqin‘, age=1}
  12. a: ConsumeEvent{id=1, name=‘luonqin‘, age=1}
  13. b: null
  14. c: null
  15. Send Event: ConsumeEvent{id=3, name=‘luonqin‘, age=5}
  16. a: null
  17. b: null
  18. c: ConsumeEvent{id=3, name=‘luonqin‘, age=5}

这里先简单说明下，every关键字表示引擎把每个事件都进行Pattern的匹配，而不管上一个匹配是否完成。or和and就是或和且的意思，表示满足某个以及满足所有。

去掉consume的执行结果：

[plain] view plaincopy

  1. EPL1: every (a=example.ConsumeEvent(id = 1) and b=example.ConsumeEvent(name = ‘luonq‘))
  2. Send Event: ConsumeEvent{id=1, name=‘luonq‘, age=0}
  3. a: ConsumeEvent{id=1, name=‘luonq‘, age=0}
  4. b: ConsumeEvent{id=1, name=‘luonq‘, age=0}
  5. Send Event: ConsumeEvent{id=2, name=‘luonq‘, age=0}
  6. EPL2: every (a=example.ConsumeEvent(id = 1) or b=example.ConsumeEvent(name = ‘luonq‘) or c=example.ConsumeEvent(age > 2))
  7. Send Event: ConsumeEvent{id=1, name=‘luonq‘, age=3}
  8. a: ConsumeEvent{id=1, name=‘luonq‘, age=3}
  9. b: null
  10. c: null
  11. Send Event: ConsumeEvent{id=1, name=‘luonqin‘, age=1}
  12. a: ConsumeEvent{id=1, name=‘luonqin‘, age=1}
  13. b: null
  14. c: null
  15. Send Event: ConsumeEvent{id=3, name=‘luonqin‘, age=5}
  16. a: null
  17. b: null
  18. c: ConsumeEvent{id=3, name=‘luonqin‘, age=5}

上面的例子可能看得不是很懂，不过没关系，等到后面讲操作符进行详解后再来回顾就很简单了。

时间： 2024-08-28 04:36:58

Esper学习之十四：Pattern（一）的相关文章

JavaScript学习总结(十四)——JavaScript编写类的扩展方法

在?J?a?v?a?S?c?r?i?p?t?中?可以使?用?类的p?r?o?t?o?t?y?p?e属性来?扩?展?类的属?性?和?方?法,在实际开发当中,当JavaScript内置的那些类所提供的动态方法和动态属性不满足我们实际开发时,我们就可以通过"prototype"属性给自定义类添加方法和属性或者扩展原有的类中的方法和属性. 一.扩展JavaScript内置类,添加动态方法 语法格式: 类名.prototype.方法名 = function([param1],[param2],.

Swift学习笔记十四：构造（Initialization）

类和结构体在实例创建时,必须为所有存储型属性设置合适的初始值.存储型属性的值不能处于一个未知的状态. 你可以在构造器中为存储型属性赋初值,也可以在定义属性时为其设置默认值.以下章节将详细介绍这两种方法. 注意: 当你为存储型属性设置默认值或者在构造器中为其赋值时,它们的值是被直接设置的,不会触发任何属性观测器(property observers). 一.基本语法 class Human{ var name :String init(){ name = "human" } init(n

laravel3学习笔记(十四)

原作者博客:ieqi.net ==================================================================================================== 运行时配置 在 Laravel3 中很多地方我们都可以看到“约定大于配置”的影子,我本人也很喜欢这种工程哲学尤其是在框架领域,当然这并不能代替所有的配置.我们知道 Laravel3 中,主要配置都写在 application/config 文件夹下,在应用逻辑中,往往

C++语言学习（十四）——C++类成员函数调用分析

C++语言学习(十四)--C++类成员函数调用分析 一.C++成员函数 1.C++成员函数的编译 C++中的函数在编译时会根据命名空间.类.参数签名等信息进行重新命名,形成新的函数名.函数重命名的过程通过一个特殊的Name Mangling(名字编码)算法来实现.Name Mangling算法是一种可逆的算法,既可以通过现有函数名计算出新函数名,也可以通过新函数名逆向推导出原有函数名.Name Mangling算法可以确保新函数名的唯一性,只要命名空间.所属的类.参数签名等有一个不同,那么产生的

Esper学习之十二：EPL语法（八）

今天的内容十分重要,在Esper的应用中是十分常用的功能之一.它是一种事件集合,我们可以对这个集合进行增删查改,所以在复杂的业务场景中我们肯定不会缺少它.它就是Named Window. 由于本篇篇幅较长,希望各位童鞋慢慢阅读,并仔细研究文档中或者我给出的例子. 1.Create Named Window 本篇的开头有说过named window是一种事件集合,它可以存储一种类型或多种类型的事件.如果我们不移除named window中的事件,那么事件应该存在生命周期,否则事件过多会有内存溢出的

学习五十四

十四周四次课(5月14日)16.1 Tomcat介绍16.2 安装jdk16.3 安装Tomcat 扩展java容器比较 http://my.oschina.net/diedai/blog/271367 http://www.360doc.com/content/11/0618/21/16915_127901371.shtmlj2ee.j2se.ejb.javabean.serverlet.jsp之间关系 http://bbs.csdn.net/topics/50015576tomcat ser

Esper学习之十五：Pattern（二）

转载请注明出处:http://blog.csdn.net/luonanqin 上一篇开始了新一轮语法--Pattern的讲解,一开始为大家普及了几个基础知识,其中有说到操作符.当时只是把它们都列举出来了,所以今天这篇就是专门详解这些操作符的,但是由于篇幅限制,本篇先会讲几个,剩余的后面几篇会逐个讲解. 1. Followed-by 如果各位有看过官方文档,应该会发现Followed-by的讲解是在比较靠后的位置,而放在第一的是Every关键字.我把它提前主要是因为其他的关键字结合Followed

Esper学习之十：EPL语法（六）

在esper的文档中,epl访问数据库的配置放在了比较靠后的位置,不过为了方便各位学习,这里会先说明和数据库交互的相关配置,然后再说epl怎么访问数据库. 配置文件在官方esper包的etc文件夹下,大家可以参考着学习. 1.连接数据库 a.JNDI获取连接 配置如下: [html] view plaincopy <database-reference name="mydb1"> <datasource-connection context-lookup-name=&

我的python学习--第十四天（二）

一.ansible api 在了解python的ansible api之前,先简单了解一下ansible. ansible是新出现的自动化运维工具,基于Python开发,集合了众多运维工具(puppet.cfengine.chef.func.fabric)的优点,实现了批量系统配置.批量程序部署.批量运行命令等功能. ansible是基于模块工作的,本身没有批量部署的能力.真正具有批量部署的是ansible所运行的模块,ansible只是提供一种框架.主要包括: 连接插件connection p