码迷，mamicode.com
首页 > 其他好文 > 详细

Esper学习之四：Context

时间：2015-10-12 21:05:20      阅读：239      评论：0      收藏：0      [点我收藏+]

标签：

 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

Esper学习之四：Context

标签：

原文地址：http://www.cnblogs.com/yudar/p/4872568.html
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！