Esper学习之四：Context

 Context是Esper里一个很有意思的概念，要是理解为上下文，我觉得有点不妥。以我的理解，Context就像一个框，把不同的事件按照框的规则框起来，并且有可能有多个框，而框与框之间不会互相影响。不知道各位在看完这篇文章后是否认同我的观点，我愿洗耳恭听。

 

1.Context基本语法

语法结构如下

 

[plain] view plaincopy
 
  1. create context context_name partition [by] event_property [and event_property [and ...]] from stream_def   
  2. [, event_property [...] from stream_def] [, ...]  

 

说明：
context_name为context的名字，并且唯一。如果重复，会说明已存在。

event_property为事件的属性名，多个属性名之间用and连接，也可以用逗号连接。

stream_def为事件流的定义，简单的定义可以是一个事件的名称，比如之前定义了一个Map结构的事件为User，那么这里就可以写User。复杂的流定义后面会说到

举个例子：

 

[plain] view plaincopy
 
  1. create context NewUser partition by id and name from User  
  2. // id和name是User的属性  


如果context包含多个流，例子如下：

 

 

[plain] view plaincopy
 
  1. create context Person partition by sid from Student, tid from Teacher  
  2. // sid是Student的属性，tid是Teacher的属性  


多个流一定要注意，每个流的中用于context的属性的数量要一样，数据类型也要一致。比如下面这几个就是错误的：

 

 

[plain] view plaincopy
 
  1. create context Person partition by sid from Student, tname from Teacher  
  2. // 错误：sid是int，tname是String，数据类型不一致  
  3.   
  4. create context Person partition by sid from Student, tid,tname from Teacher  
  5. // 错误：Student有一个属性，Teacher有两个属性，属性数量不一致  
  6.   
  7. create context Person partition by sid,sname from Student, tname,tid from Teacher  
  8. // 错误：sid对应tname，sname对应tid，并且sname和tname是String，sid和tid是int，属性数量一样，但是对应的数据类型不一致  

 

实际上可以对进入context的事件增加过滤条件，不符合条件的就被过滤掉，就像下面这样：

 

[plain] view plaincopy
 
  1. create context Person partition by sid from Student(age > 20)  
  2. // age大于20的Student事件才能建立或者进入context  

 

       看了这么多，可能大家只是知道context的一些基本定义方法，但是不知道什么意思。其实很简单，partition by后面的属性，就是作为context的一个约束，比如说id，如果id相等的则进入同一个context里，如果id不同，那就新建一个context。好比根据id分组，id相同的会被分到一个组里，不同的会新建一个组并等待相同的进入。

       如果parition by后面跟着同一个流的两个属性，那么必须两个属性值一样才能进入context。比如说A事件id=1,name=a，那么会以1和a两个值建立context，有点像数据库里的联合主键。然后B事件id=1,name=b，则又会新建一个context。接着C事件id=1,name=a，那么会进入A事件建立的context。

       如果partition by后面跟着两个流的一个属性，那么两个属性值一样才能进入context。比如说Student事件sid=1，那么会新建一个context，然后来了个Teacher事件tid=1，则会进入sid=1的那个context。多个流也一样，不用关心是什么事件，只用关心事件的属性值一样即可进入同一个context。

要是说了这么多还是不懂，可以看看下面要讲的context自带属性也许就能明白一些了。

 

2. Built-In Context Properties

Context本身自带一些属性，最关键的是可以查看所创建的context的标识，并帮助我们理解context的语法。

如上所示，name表示context的名称，这个是不会变的。id是每个context的唯一标识，从0开始。key1和keyN表示context定义时所选择的属性的值，1和N表示属性的位置。例如：

 

[plain] view plaincopy
 
  1. EPL: create context Person partition by sid, sname from Student  
  2. // key1为sid，key2为sname  

 

 

为了说明对这几个属性的应用，我举了一个比较完整的例子。

 

[java] view plaincopy
 
  1. import com.espertech.esper.client.EPAdministrator;  
  2. import com.espertech.esper.client.EPRuntime;  
  3. import com.espertech.esper.client.EPServiceProvider;  
  4. import com.espertech.esper.client.EPServiceProviderManager;  
  5. import com.espertech.esper.client.EPStatement;  
  6. import com.espertech.esper.client.EventBean;  
  7. import com.espertech.esper.client.UpdateListener;  
  8.   
  9. class ESB  
  10. {  
  11.   
  12.     private int id;  
  13.     private int price;  
  14.   
  15.     public int getId()  
  16.     {  
  17.         return id;  
  18.     }  
  19.   
  20.     public void setId(int id)  
  21.     {  
  22.         this.id = id;  
  23.     }  
  24.   
  25.     public int getPrice()  
  26.     {  
  27.         return price;  
  28.     }  
  29.   
  30.     public void setPrice(int price)  
  31.     {  
  32.         this.price = price;  
  33.     }  
  34.   
  35. }  
  36.   
  37. class ContextPropertiesListener2 implements UpdateListener  
  38. {  
  39.   
  40.     public void update(EventBean[] newEvents, EventBean[] oldEvents)  
  41.     {  
  42.         if (newEvents != null)  
  43.         {  
  44.             EventBean event = newEvents[0];  
  45.             System.out.println("context.name " + event.get("name") + ", context.id " + event.get("id") + ", context.key1 " + event.get("key1")  
  46.                     + ", context.key2 " + event.get("key2"));  
  47.         }  
  48.     }  
  49. }  
  50.   
  51. public class ContextPropertiesTest2  
  52. {  
  53.     public static void main(String[] args)  
  54.     {  
  55.         EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();  
  56.         EPAdministrator admin = epService.getEPAdministrator();  
  57.         EPRuntime runtime = epService.getEPRuntime();  
  58.   
  59.         String esb = ESB.class.getName();  
  60.         // 创建context  
  61.         String epl1 = "create context esbtest partition by id,price from " + esb;  
  62.         // context.id针对不同的esb的id,price建立一个context，如果事件的id和price相同，则context.id也相同，即表明事件进入了同一个context  
  63.         String epl2 = "context esbtest select context.id,context.name,context.key1,context.key2 from " + esb;  
  64.   
  65.         admin.createEPL(epl1);  
  66.         EPStatement state = admin.createEPL(epl2);  
  67.         state.addListener(new ContextPropertiesListener2());  
  68.   
  69.         ESB e1 = new ESB();  
  70.         e1.setId(1);  
  71.         e1.setPrice(20);  
  72.         System.out.println("sendEvent: id=1, price=20");  
  73.         runtime.sendEvent(e1);  
  74.   
  75.   
  76.         ESB e2 = new ESB();  
  77.         e2.setId(2);  
  78.         e2.setPrice(30);  
  79.         System.out.println("sendEvent: id=2, price=30");  
  80.         runtime.sendEvent(e2);  
  81.   
  82.         ESB e3 = new ESB();  
  83.         e3.setId(1);  
  84.         e3.setPrice(20);  
  85.         System.out.println("sendEvent: id=1, price=20");  
  86.         runtime.sendEvent(e3);  
  87.   
  88.         ESB e4 = new ESB();  
  89.         e4.setId(4);  
  90.         e4.setPrice(20);  
  91.         System.out.println("sendEvent: id=4, price=20");  
  92.         runtime.sendEvent(e4);  
  93.     }  
  94. }  

执行结果：

 

 

[plain] view plaincopy
 
  1. sendEvent: id=1, price=20  
  2. context.name esbtest, context.id 0, context.key1 1, context.key2 20  
  3. sendEvent: id=2, price=30  
  4. context.name esbtest, context.id 1, context.key1 2, context.key2 30  
  5. sendEvent: id=1, price=20  
  6. context.name esbtest, context.id 0, context.key1 1, context.key2 20  
  7. sendEvent: id=4, price=20  
  8. context.name esbtest, context.id 2, context.key1 4, context.key2 20  


      这个例子说得比较明白，针对不同的id和price，都会新建一个context，并context.id会从0开始增加作为其标识。如果id和price一样，事件就会进入之前已经存在的context，所以e3这个事件就会和e1一样存在于context.id=0的context里面。

 

      对于epl2这个句子，意思是在esbtest这个context限制下进行事件的计算，不过这个句子很简单，可以说没有什么计算，事件进入后就显示出来了。实际上写成什么样都可以，但是必须以context xxx开头（xxx表示context定义时的名字），比如说：

 

[plain] view plaincopy
 
  1. // context定义  
  2. create context esbtest2 partition by id from ESB  
  3.   
  4. // 每当5个id相同的ESB事件进入时，统计price的总和  
  5. context esbtest select sum(price) from ESB.win:length_batch(5)  
  6.   
  7. // 根据不同的id，统计3秒内进入的事件的平均price，且price必须大于10  
  8. context esbtest select avg(price) from ESB(price>10).win:time(3 sec)  

 

       也许你会发现为什么我写的句子都会带有".win:length"或者".win:time"，那是因为我要计算的都是一堆事件，所以必须用一定条件才能把事件聚集起来。当然并不是一个事件没法计算，只不过更多情况下计算都是以多个事件为基础的。关于这一点，学习到后面就会有更多的接触。

 

 

3. Hash Context

       前面介绍的Context语法是以事件属性来定义的，Esper提供了以Hash值为标准定义Context，通俗一点说就是提供事件属性参与hash值的计算，计算的值再对某个值（这是什么）是同余的则进入到同一个context中。详细语法如下：

 

[plain] view plaincopy
 
  1. create context context_name coalesce [by]  
  2. hash_func_name(hash_func_param) from stream_def  
  3. [, hash_func_name(hash_func_param) from stream_def ]  
  4. [, ...]  
  5. granularity granularity_value  
  6. [preallocate]   

 

a). hash_func_name为hash函数的名称，Esper提供了CRC32或者使用Java的hashcode函数来计算hash值，分别为consistent_hash_crc32和hash_code。你也可以自己定义hash函数，不过这需要配置。

b). hash_func_param为参与计算的属性列表，比如之前的sid或者tname什么的。

c). stream_def就是事件类型，可以一个可以多个。不同于前面的Context语法要求，Hash Context不管有多个少属性作为基础来计算hash值，hash值都只有一个，并且为int型。所以就不用关心这些属性的个数以及数据类型了。

d). granularity是必选参数，表示为最多能创建多少个context

e). granularity_value就是那个用于取余的“某个值”，因为Esper为了防止内存溢出，就想出了取余这种办法来限制context创建的数量。也就是说context.id=hash_func_name(hash_func_param)  % granularity_value。

f). preallocate是一个可选参数，如果使用它，那么Esper会预分配空间来创建granularity_value数量的context。比如说granularity_value为1024，那么Esper会预创建1024个context。内存不大的话不建议使用这个参数。

Hash Context同样可以过滤事件，举个完整的例子：

 

[plain] view plaincopy
 
  1. // 以java的hashcode方法计算sid的值(sid必须大于5)，以CRC32算法计算tid的值，然后对10取余后的值来建立context  
  2. create context HashPerson coalesce by hash_code(sid) from Student(sid>5), consistent_hash_crc32(tid) from Teacher granularity 10  

 

 

Hash Context也有Built-In Context Properties，只不过只有context.id和context.name了。用法和前面说的一样，这里就不列举了。

小贴士：

1.如果用于hash计算的属性比较多，那么就不建议使用CRC32算法了，因为他会把这些属性值先序列化字节数组以后才能计算hash值。hashcode方法相对它能快很多。

2.如果使用preallocate参数，建议granularity_value不要超过1000

3.如果granularity_value超过65536，引擎查找context会比较费劲，进而影响计算速度

 

4. Category Context

Category Context相对之前的两类context要简单许多，也更容易理解。语法说明如下：

 

[plain] view plaincopy
 
  1. create context context_name  
  2. group [by] group_expression as category_label  
  3. [, group [by] group_expression as category_label]  
  4. [, ...]  
  5. from stream_def  


       我相信基本上不用我说，大家都能理解。group_expression表示分组策略的表达式，category_label为策略定义一个名字，一个context可以有多个策略同时存在，但是特殊的是之能有一个stream_def。例如：

 

 

[plain] view plaincopy
 
  1. create context CategoryByTemp  
  2. group temp < 5 as cold, group temp between 5 and 85 as normal, group temp > 85 as large  
  3. from Temperature  

 

Category Context也有它自带的属性。

label指明进入的事件所处的group是什么。完整例子如下：

 

[java] view plaincopy
 
  1. import com.espertech.esper.client.EPAdministrator;  
  2. import com.espertech.esper.client.EPRuntime;  
  3. import com.espertech.esper.client.EPServiceProvider;  
  4. import com.espertech.esper.client.EPServiceProviderManager;  
  5. import com.espertech.esper.client.EPStatement;  
  6. import com.espertech.esper.client.EventBean;  
  7. import com.espertech.esper.client.UpdateListener;  
  8.   
  9. class ESB3  
  10. {  
  11.     private int id;  
  12.     private int price;  
  13.   
  14.     public int getId()  
  15.     {  
  16.         return id;  
  17.     }  
  18.   
  19.     public void setId(int id)  
  20.     {  
  21.         this.id = id;  
  22.     }  
  23.   
  24.     public int getPrice()  
  25.     {  
  26.         return price;  
  27.     }  
  28.   
  29.     public void setPrice(int price)  
  30.     {  
  31.         this.price = price;  
  32.     }  
  33. }  
  34.   
  35. class ContextPropertiesListener4 implements UpdateListener  
  36. {  
  37.     public void update(EventBean[] newEvents, EventBean[] oldEvents)  
  38.     {  
  39.         if (newEvents != null)  
  40.         {  
  41.             EventBean event = newEvents[0];  
  42.             System.out.println("context.name " + event.get("name") + ", context.id " + event.get("id") + ", context.label " + event.get("label"));  
  43.         }  
  44.     }  
  45. }  
  46.   
  47. public class ContextPropertiesTest4  
  48. {  
  49.     public static void main(String[] args)  
  50.     {  
  51.         EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();  
  52.         EPAdministrator admin = epService.getEPAdministrator();  
  53.         EPRuntime runtime = epService.getEPRuntime();  
  54.   
  55.         String esb = ESB3.class.getName();  
  56.         String epl1 = "create context esbtest group by id<0 as low, group by id>0 and id<10 as middle,group by id>10 as high from " + esb;  
  57.         String epl2 = "context esbtest select context.id,context.name,context.label, price from " + esb;  
  58.   
  59.         admin.createEPL(epl1);  
  60.         EPStatement state = admin.createEPL(epl2);  
  61.         state.addListener(new ContextPropertiesListener4());  
  62.   
  63.         ESB3 e1 = new ESB3();  
  64.         e1.setId(1);  
  65.         e1.setPrice(20);  
  66.         System.out.println("sendEvent: id=1, price=20");  
  67.         runtime.sendEvent(e1);  
  68.   
  69.   
  70.         ESB3 e2 = new ESB3();  
  71.         e2.setId(0);  
  72.         e2.setPrice(30);  
  73.         System.out.println("sendEvent: id=0, price=30");  
  74.         runtime.sendEvent(e2);  
  75.   
  76.         ESB3 e3 = new ESB3();  
  77.         e3.setId(11);  
  78.         e3.setPrice(20);  
  79.         System.out.println("sendEvent: id=11, price=20");  
  80.         runtime.sendEvent(e3);  
  81.   
  82.         ESB3 e4 = new ESB3();  
  83.         e4.setId(-1);  
  84.         e4.setPrice(40);  
  85.         System.out.println("sendEvent: id=-1, price=40");  
  86.         runtime.sendEvent(e4);  
  87.     }  
  88. }  

输出结果为：

 

 

[plain] view plaincopy
 
  1. sendEvent: id=1, price=20  
  2. context.name esbtest, context.id 1, context.label middle  
  3. sendEvent: id=0, price=30  
  4. sendEvent: id=11, price=20  
  5. context.name esbtest, context.id 2, context.label high  
  6. sendEvent: id=-1, price=40  
  7. context.name esbtest, context.id 0, context.label low  


可以发现，id=0的事件，并没有触发监听器，那是因为context里的三个category没有包含id=0的情况，所以这个事件就被排除掉了。

 

 

5. Non-Overlapping Context

这类Context有个特点，是由开始和结束两个条件构成context。语法如下：

[plain] view plaincopy
 
  1. create context context_name start start_condition end end_condition  


       这个context有两个条件做限制，形成一个约束范围。当开始条件和结束条件都没被触发时，引擎会观察事件的进入是否会触发开始条件。如果开始条件被触发了，那么就新建一个context，并且观察结束条件是否被触发。如果结束条件被触发，那么context结束，引擎继续观察开始条件何时被触发。所以说这类Context的另一个特点是，要么context存在并且只有一个，要么条件都没被触发，也就一个context都没有了。

 

start_condition和end_condition可以是时间，或者是事件类型。比如说：

 

[plain] view plaincopy
 
  1. create context NineToFive start (0, 9, *, *, *) end (0, 17, *, *, *)  
  2. //  9点到17点此context才可用（以引擎的时间为准）。如果事件进入的事件不在此范围内，则不受该context影响  

 

我列了一个完整的例子，以某类事件开始，以某类事件结束

 

[java] view plaincopy
 
  1. import com.espertech.esper.client.EPAdministrator;  
  2. import com.espertech.esper.client.EPRuntime;  
  3. import com.espertech.esper.client.EPServiceProvider;  
  4. import com.espertech.esper.client.EPServiceProviderManager;  
  5. import com.espertech.esper.client.EPStatement;  
  6. import com.espertech.esper.client.EventBean;  
  7. import com.espertech.esper.client.UpdateListener;  
  8.   
  9. class StartEvent  
  10. {  
  11. }  
  12.   
  13. class EndEvent  
  14. {  
  15. }  
  16.   
  17. class OtherEvent  
  18. {  
  19.     private int id;  
  20.   
  21.     public int getId()  
  22.     {  
  23.         return id;  
  24.     }  
  25.   
  26.     public void setId(int id)  
  27.     {  
  28.         this.id = id;  
  29.     }  
  30. }  
  31.   
  32. class NoOverLappingContextTest3 implements UpdateListener  
  33. {  
  34.   
  35.     public void update(EventBean[] newEvents, EventBean[] oldEvents)  
  36.     {  
  37.         if (newEvents != null)  
  38.         {  
  39.             EventBean event = newEvents[0];  
  40.             System.out.println("Class:" + event.getUnderlying().getClass().getName() + ", id:" + event.get("id"));  
  41.         }  
  42.     }  
  43. }  
  44.   
  45. public class NoOverLappingContextTest  
  46. {  
  47.     public static void main(String[] args)  
  48.     {  
  49.         EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();  
  50.         EPAdministrator admin = epService.getEPAdministrator();  
  51.         EPRuntime runtime = epService.getEPRuntime();  
  52.   
  53.         String start = StartEvent.class.getName();  
  54.         String end = EndEvent.class.getName();  
  55.         String other = OtherEvent.class.getName();  
  56.         // 以StartEvent事件作为开始条件，EndEvent事件作为结束条件  
  57.         String epl1 = "create context NoOverLapping start " + start + " end " + end;  
  58.         String epl2 = "context NoOverLapping select * from " + other;  
  59.   
  60.         admin.createEPL(epl1);  
  61.         EPStatement state = admin.createEPL(epl2);  
  62.         state.addListener(new NoOverLappingContextTest3());  
  63.   
  64.         StartEvent s = new StartEvent();  
  65.         System.out.println("sendEvent: StartEvent");  
  66.         runtime.sendEvent(s);  
  67.   
  68.         OtherEvent o = new OtherEvent();  
  69.         o.setId(2);  
  70.         System.out.println("sendEvent: OtherEvent");  
  71.         runtime.sendEvent(o);  
  72.   
  73.         EndEvent e = new EndEvent();  
  74.         System.out.println("sendEvent: EndEvent");  
  75.         runtime.sendEvent(e);  
  76.   
  77.         OtherEvent o2 = new OtherEvent();  
  78.         o2.setId(4);  
  79.         System.out.println("sendEvent: OtherEvent");  
  80.         runtime.sendEvent(o2);  
  81.     }  
  82. }  


执行结果：

 

 

[plain] view plaincopy
 
  1. sendEvent: StartEvent  
  2. sendEvent: OtherEvent  
  3. Class:blog.OtherEvent, id:2  
  4. sendEvent: EndEvent  
  5. sendEvent: OtherEvent  


由此可以看出，在NoOverLapping这个Context下监控OtherEvent，必须是在StartEvent被触发才能监控到，所以在EndEvent发送后，再发送一个OtherEvent是不会触发Listener的。

 

 

6. OverLapping

OverLapping和NoOverLapping一样都有两个条件限制，但是区别在于OverLapping的初始条件可以被触发多次，并且只要被触发就会新建一个context，但是当终结条件被触发时，之前建立的所有context都会被销毁。他的语法也很简单：

 

[plain] view plaincopy
 
  1. create context context_name initiated [by] initiating_condition terminated [by] terminating_condition  


initiating_condition和terminating_condition可以为事件类型，事件或者别的条件表达式。下面给出了一个完整的例子。

 

 

[java] view plaincopy
 
  1. import com.espertech.esper.client.EPAdministrator;  
  2. import com.espertech.esper.client.EPRuntime;  
  3. import com.espertech.esper.client.EPServiceProvider;  
  4. import com.espertech.esper.client.EPServiceProviderManager;  
  5. import com.espertech.esper.client.EPStatement;  
  6. import com.espertech.esper.client.EventBean;  
  7. import com.espertech.esper.client.UpdateListener;  
  8.   
  9. class InitialEvent{}  
  10.   
  11. class TerminateEvent{}  
  12.   
  13. class SomeEvent  
  14. {  
  15.     private int id;  
  16.   
  17.     public int getId()  
  18.     {  
  19.         return id;  
  20.     }  
  21.   
  22.     public void setId(int id)  
  23.     {  
  24.         this.id = id;  
  25.     }  
  26. }  
  27.   
  28. class OverLappingContextListener implements UpdateListener  
  29. {  
  30.   
  31.     public void update(EventBean[] newEvents, EventBean[] oldEvents)  
  32.     {  
  33.         if (newEvents != null)  
  34.         {  
  35.             EventBean event = newEvents[0];  
  36.             System.out.println("context.id:" + event.get("id") + ", id:" + event.get("id"));  
  37.         }  
  38.     }  
  39. }  
  40.   
  41. class OverLappingContextListener2 implements UpdateListener  
  42. {  
  43.   
  44.     public void update(EventBean[] newEvents, EventBean[] oldEvents)  
  45.     {  
  46.         if (newEvents != null)  
  47.         {  
  48.             EventBean event = newEvents[0];  
  49.             System.out.println("Class:" + event.getUnderlying().getClass().getName() + ", id:" + event.get("id"));  
  50.         }  
  51.     }  
  52. }  
  53.   
  54. public class OverLappingContextTest  
  55. {  
  56.     public static void main(String[] args)  
  57.     {  
  58.         EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();  
  59.         EPAdministrator admin = epService.getEPAdministrator();  
  60.         EPRuntime runtime = epService.getEPRuntime();  
  61.   
  62.         String initial = InitialEvent.class.getName();  
  63.         String terminate = TerminateEvent.class.getName();  
  64.         String some = SomeEvent.class.getName();  
  65.         // 以InitialEvent事件作为初始事件，TerminateEvent事件作为终结事件  
  66.         String epl1 = "create context OverLapping initiated " + initial + " terminated " + terminate;  
  67.         String epl2 = "context OverLapping select context.id from " + initial;  
  68.         String epl3 = "context OverLapping select * from " + some;  
  69.   
  70.         admin.createEPL(epl1);  
  71.         EPStatement state = admin.createEPL(epl2);  
  72.         state.addListener(new OverLappingContextListener());  
  73.         EPStatement state1 = admin.createEPL(epl3);  
  74.         state1.addListener(new OverLappingContextListener2());  
  75.   
  76.         InitialEvent i = new InitialEvent();  
  77.         System.out.println("sendEvent: InitialEvent");  
  78.         runtime.sendEvent(i);  
  79.   
  80.         SomeEvent s = new SomeEvent();  
  81.         s.setId(2);  
  82.         System.out.println("sendEvent: SomeEvent");  
  83.         runtime.sendEvent(s);  
  84.   
  85.         InitialEvent i2 = new InitialEvent();  
  86.         System.out.println("sendEvent: InitialEvent");  
  87.         runtime.sendEvent(i2);  
  88.   
  89.         TerminateEvent t = new TerminateEvent();  
  90.         System.out.println("sendEvent: TerminateEvent");  
  91.         runtime.sendEvent(t);  
  92.   
  93.         SomeEvent s2 = new SomeEvent();  
  94.         s2.setId(4);  
  95.         System.out.println("sendEvent: SomeEvent");  
  96.         runtime.sendEvent(s2);  
  97.     }  
  98. }  


执行结果：

 

 

[plain] view plaincopy
 
  1. sendEvent: InitialEvent  
  2. context.id:0, id:0  
  3. sendEvent: SomeEvent  
  4. Class:blog.SomeEvent, id:2  
  5. sendEvent: InitialEvent  
  6. context.id:1, id:1  
  7. context.id:0, id:0  
  8. sendEvent: TerminateEvent  
  9. sendEvent: SomeEvent  


从结果可以看得出来，每发送一个InitialEvent，都会新建一个context，以至于context.id=0和1。并且当发送TerminateEvent后，再发送SomeEvent监听器也不会被触发了。

 

另外，context.id是每一种Context都会有的自带属性，而且针对OverLapping，还增加了startTime和endTime两种属性，表明context的开始时间和结束时间。

 

7. Context Condition

Context Condition主要包含Filter，Pattern，Crontab以及Time Period

A). Filter主要就是对属性值的过滤，比如：

 

[plain] view plaincopy
 
  1. create context NewUser partition by id from User(id > 10)  

 

B). Pattern是复杂事件流的代表，比如说“A事件到达后跟着B事件到达”这是一个完整的Pattern。Pattern是Esper里面很特别的东西，并且用它描述复杂的事件流是最合适不过的了。这里暂且不展开说，后面会有专门好几篇来讲解Pattern。

C). Crontab是定时任务，主要用于NoOverLapping，就像前面提到的(0, 9, *, *, *)，括号里的五项代表分，时，天，月，年。关于这个后面也会有讲解。

D). Time Period在这里只有一种表达式，就是after time_period_expression。例如：after 1 minute，after 5 sec。结合Context的例子如下：

 

[plain] view plaincopy
 
  1. // 以0秒为时间初始点，新建一个context，于10秒后开始，1分钟后结束。下一个context从1分20秒开始  
  2. create context NonOverlap10SecFor1Min start after 10 seconds end after 1 minute  

 

 

 

8. Context Nesting

Context也可以嵌套，意义就是多个Context联合在一起组成一个大的Context，以满足复杂的限制需求。语法结构：

 

[plain] view plaincopy
 
  1. create context context_name  
  2. context nested_context_name [as] nested_context_definition ,  
  3. context nested_context_name [as] nested_context_definition [, ...]  


举个例子：

 

 

[plain] view plaincopy
 
  1. create context NineToFiveSegmented  
  2. context NineToFive start (0, 9, *, *, *) end (0, 17, *, *, *),  
  3. context SegmentedByUser partition by userId from User  


应用和普通的Context没区别，在此就不举例了。另外针对嵌套Context，其自带的属性使用方式会有些变化。比如针对上面这个，若想查看NineToFive的startTime和SegmentedByUser的第一个属性值，要按照下面这样写：

 

 

[plain] view plaincopy
 
  1. context NineToFiveSegmented select  
  2.  context.NineToFive.startTime,  
  3.  context.SegmentedByUser.key1  
  4.  from User  

 


9. Output When Context Partition Ends

当Context销毁时，如果你想同时查看此时Context里的东西，那么Esper提供了一种办法来输出其内容。例如：

 

[plain] view plaincopy
 
  1. create context OverLapping initiated InitialEvent terminated TerminateEvent  
  2. context OverLapping select * from User output snapshot when terminated  

 

那么当终结事件发送到引擎后，会立刻输出OverLapping的快照。

如果你想以固定的频率查看Context的内容，Esper也支持。例如：

 

[plain] view plaincopy
 
  1. context OverLapping select * from User output snapshot every 2 minute // 每两分钟输出OverLapping的事件  

 

关于output表达式，后面也会有详解。

 

       以上的内容算是包含了Context的所有方面，可能还有些细节需要各位自己去研读他的手册，并且多加练习。Esper的内容之多以至于我说了很多次“后面会专门讲解”，不过也确实是因为内容复杂，所以不得不先跳过这些。在学习到之后的内容以后，再回过头来理解Context可能会有另一番效果。

 

原文：http://blog.csdn.net/luonanqin/article/details/10946329

posted on 2015-10-12 19:16  Yudar  阅读(746)  评论(0)  编辑  收藏  举报

Powered by: 博客园 Copyright © 2024 Yudar
Powered by .NET 8.0 on Kubernetes