Esper学习之二：事件类型

Esper对事件有特殊的数据结构约定。能处理的事件结构有：POJO，java.util.Map，Object Array，XML

1.POJO

对于POJO，Esper要求对每一个私有属性要有getter方法。Esper允许不必按照JavaBean规定的格式，但是getter方法是必须的。又或者可以在配置文件中配置可访问的方法来代替getter。简单示例如下

1. public class Person
2. {
3. String name;
4. int age;
5. public String getName()
6. {
7. return name;
8. }
9. public int getAge()
10. {
11. return age;
12. }
13. }

Esper同样也能支持复杂的数据类型以及嵌套。稍微复杂的Person如下

1. import java.util.List;
2. import java.util.Map;
3. public class Person
4. {
5. String name;
6. int age;
7. List<Child> children;
8. Map<String, Integer> phones;
9. Address address;
10. public String getName()
11. {
12. return name;
13. }
14. public int getAge()
15. {
16. return age;
17. }
18. public List<Child> getChildren()
19. {
20. return children;
21. }
22. public Map<String, Integer> getPhones()
23. {
24. return phones;
25. }
26. public Address getAddress()
27. {
28. return address;
29. }
30. }
31. class Child
32. {
33. String name;
34. int gender;
35. // 省略getter方法
36. }
37. class Address
38. {
39. String road;
40. String street;
41. int houseNo;
42. // 省略getter方法
43. }

如上所示，Esper能支持包含了集合类型和嵌套类的POJO，示例的EPL语句如下

1. // 当Person类型的事件中name为luonanqin时，Esper能得到对应的age,children和address
2. select age,children,address from Person where name="luonanqin"

如果我不想要所有的child，而是想要第二个。并且我想得到家里的电话号码，那么Person需要改动一下

1. import java.util.List;
2. import java.util.Map;
3. public class Person
4. {
5. String name;
6. int age;
7. List<Child> children;
8. Map<String, Integer> phones;
9. Address address;
10. public String getName()
11. {
12. return name;
13. }
14. public int getAge()
15. {
16. return age;
17. }
18. public Child getChildren(int index)
19. {
20. return children.get(index);
21. }
22. public int getPhones(String name)
23. {
24. return phones.get(name);
25. }
26. public Address getAddress()
27. {
28. return address;
29. }
30. // Address，Child不变
31. }

对应的EPL如下

1. // 当Person类型的事件中name为luonanqin时，Esper能得到对应的第二个孩子,家里的电话和家庭住址在哪条路上
2. select children[1], phones('home'), address.road where Person where name="luonanqin"

Esper支持事件的更新，对此Esper要求提供对应的setter方法。Person需要再有点小该度。示例如下

1. import java.util.List;
2. import java.util.Map;
3. public class Person
4. {
5. String name;
6. int age;
7. List<Child> children;
8. Map<String, Integer> phones;
9. Address address;
10. public String getName()
11. {
12. return name;
13. }
14. public int getAge()
15. {
16. return age;
17. }
18. public Child getChildren(int index)
19. {
20. return children.get(index);
21. }
22. // 此方法用于phones属性的更新
23. public void setPhones(String name, Integer number){
24. phones.put(name, number);
25. }
26. public int getPhones(String name)
27. {
28. return phones.get(name);
29. }
30. public Address getAddress()
31. {
32. return address;
33. }
34. // Address，Child不变
35. }

对应的EPL如下

1. // 当Person类型的事件中name为luonanqin时，更新家里的电话
2. update Person set phones('home') = 123456789 where name="luonanqin"

Esper对POJO的支持基本上就是上面所说的，另外他还支持实现了多个接口类或者抽象类的POJO，使用方法和普通的POJO没什么区别，这里就不列举了。

2.Map

Esper支持原生Java Map结构的事件。相对于POJO来说，Map的结构更利于事件类型的热加载，毕竟不是class，所以不需要重启JVM。所以如果系统对重启比较敏感，建议使用Map来定义事件的结构。Map的结构很简单，主要分为事件定义名和事件属性列表。我们继续拿Person来讲解

1. import java.util.HashMap;
2. import java.util.List;
3. import java.util.Map;
4. import com.espertech.esper.client.EPAdministrator;
5. import com.espertech.esper.client.EPServiceProvider;
6. import com.espertech.esper.client.EPServiceProviderManager;
7. public class PersonMap
8. {
9. public static void main(String[] args)
10. {
11. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
12. EPAdministrator admin = epService.getEPAdministrator();
13. // Person定义
14. Map<String,Object> person = new HashMap<String,Object>();
15. person.put("name", String.class);
16. person.put("age", int.class);
17. person.put("children", List.class);
18. person.put("phones", Map.class);
19. // 注册Person到Esper
20. admin.getConfiguration().addEventType("Person", person);
21. }
22. }

如上所示，Map结构的事件需要将属性名作为key，属性的数据类型作为value保存到Map中，然后再通过Esper的接口注册到Esper。其中addEventType的两个参数分别代表事件定义的名称和所定义的结构。

对应的EPL和POJO的没有区别

1. // 当Person类型的事件中name为luonanqin时，Esper能得到对应的age,children
2. select age,children from Person where name="luonanqin"

Map对于嵌套类的定义比较特别。如果嵌套的类是POJO，那就如上面所示。如果嵌套的还是Map，那么定义方式就需要改变。我们为Person加上Address，示例如下

1. import java.util.HashMap;
2. import java.util.List;
3. import java.util.Map;
4. import com.espertech.esper.client.EPAdministrator;
5. import com.espertech.esper.client.EPServiceProvider;
6. import com.espertech.esper.client.EPServiceProviderManager;
7. public class PersonMap
8. {
9. public static void main(String[] args)
10. {
11. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
12. EPAdministrator admin = epService.getEPAdministrator();
13. // Address定义
14. Map<String, Object> address = new HashMap<String, Object>();
15. address.put("road", String.class);
16. address.put("street", String.class);
17. address.put("houseNo", int.class);
18. // Person定义
19. Map<String, Object> person = new HashMap<String, Object>();
20. person.put("name", String.class);
21. person.put("age", int.class);
22. person.put("children", List.class);
23. person.put("phones", Map.class);
24. person.put("address", "Address");
25. // 注册Address到Esper
26. admin.getConfiguration().addEventType("Address", address);
27. // 注册Person到Esper
28. admin.getConfiguration().addEventType("Person", person);
29. }
30. }

如上所示，有两个关键点：

1.Person在定义Address属性时，map的value不是Address.class，而是Address字符串，而这就代表引擎里的Address对应的Map结构定义

2.事件定义注册必须是Address先于Person，因为Person用到了Address，而引擎是根据Address注册时用的名字去查找Address定义的，所以如果名字写错，引擎就找不到Address了

如果Person有多个Address，则以数组方式定义Person的多个Address时，代码又变成下面的样子了

1. person.put("addresses", "Address[]");

另外对于Map，Esper只支持增量更新，也就是说只能增加Map中的属性定义，而不能修改或者删除某个属性（实际上属性增多并不影响其处理性能，所以没有删除在我看来也没什么。至于修改，也只能是先注销再注册了）。我们为Person增加一个gender属性，示例如下

1. import java.util.Arrays;
2. import java.util.HashMap;
3. import java.util.List;
4. import java.util.Map;
5. import com.espertech.esper.client.EPAdministrator;
6. import com.espertech.esper.client.EPServiceProvider;
7. import com.espertech.esper.client.EPServiceProviderManager;
8. import com.espertech.esper.client.EventType;
9. public class PersonMap
10. {
11. public static void main(String[] args)
12. {
13. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
14. EPAdministrator admin = epService.getEPAdministrator();
15. // Address定义
16. Map<String, Object> address = new HashMap<String, Object>();
17. address.put("road", String.class);
18. address.put("street", String.class);
19. address.put("houseNo", int.class);
20. // Person定义
21. Map<String, Object> person = new HashMap<String, Object>();
22. person.put("name", String.class);
23. person.put("age", int.class);
24. person.put("children", List.class);
25. person.put("phones", Map.class);
26. person.put("address", "Address");
27. // 注册Address到Esper
28. admin.getConfiguration().addEventType("Address", address);
29. // 注册Person到Esper
30. admin.getConfiguration().addEventType("Person", person);
31. // 新增一个gender属性
32. person.put("gender", int.class);
33. admin.getConfiguration().updateMapEventType("Person", person);
34. /** 输出结果：
35. * Person props: [address, age, name, children, phones, gender]
36. */
37. EventType event = admin.getConfiguration().getEventType("Person");
38. System.out.println("Person props: " + Arrays.asList(event.getPropertyNames()));
39. }
40. }

 

3.Object Array

对象数组和Map很像，基本没有差别。只是定义方式不一样，Esper同样也只支持增量更新。这里继续用Person为大家做例子

1. import java.util.Arrays;
2. import java.util.Map;
3. import com.espertech.esper.client.EPAdministrator;
4. import com.espertech.esper.client.EPServiceProvider;
5. import com.espertech.esper.client.EPServiceProviderManager;
6. import com.espertech.esper.client.EventType;
7. public class PersonArray
8. {
9. /**
10. * @param args
11. */
12. public static void main(String[] args)
13. {
14. EPServiceProvider epService = EPServiceProviderManager.getDefaultProvider();
15. EPAdministrator admin = epService.getEPAdministrator();
16. // Address定义
17. String[] addressPropNames = { "road", "street", "houseNo" };
18. Object[] addressPropTypes = { String.class, String.class, int.class };
19. // Child定义
20. String[] childPropNames = { "name", "age" };
21. Object[] childPropTypes = { String.class, int.class };
22. // Person定义
23. String[] personPropNames = { "name", "age", "children", "phones", "address" };
24. Object[] personPropTypes = { String.class, int.class, "Child[]", Map.class, "Address" };
25. // 注册Address到Esper
26. admin.getConfiguration().addEventType("Address", addressPropNames, addressPropTypes);
27. // 注册Child到Esper
28. admin.getConfiguration().addEventType("Child", childPropNames, childPropTypes);
29. // 注册Person到Esper
30. admin.getConfiguration().addEventType("Person", personPropNames, personPropTypes);
31. // 新增一个gender属性
32. admin.getConfiguration().updateObjectArrayEventType("Person", new String[] { "gender" }, new Object[] { int.class });
33. /** 输出结果：
34. * Person props: [name, age, children, phones, address, gender]
35. */
36. EventType event = admin.getConfiguration().getEventType("Person");
37. System.out.println("Person props: " + Arrays.asList(event.getPropertyNames()));
38. }
39. }

上面的例子包含了对象数组这种事件格式的所有特性，我就不多加解释了。

4.XML

待续