Geode中使用PDX序列化最佳实践

Geode PDX 序列化

Geode的便携式数据交换（PDX）是一种跨语言数据格式，可以降低分发和序列化对象的成本。 PDX将数据存储在您可以单独访问的命名字段中，以避免反序列化整个数据对象的成本。 PDX还允许您混合已添加或删除字段的对象版本。

PdxInstance

PdxInstance是PDX序列化字节周围的轻量级包装器。 它为应用程序提供对PDX序列化对象字段的运行时访问。

将JSON文档添加到Geode缓存

JSONFormatter API允许您将JSON格式的文档放入区域，然后通过将文档作为PdxInstances存储在内部来检索它们。

要 将JSON文档添加到Geode缓存 功能,必须配置:configure pdx --read-serialized=true --disk-store=DEFAULT

最佳实践

在gfsh中，在启动Server服务器之前执行以下命令：

gfsh>configure pdx --read-serialized=true --disk-store=DEFAULT
1

如果在配置前就启动了Server服务器,还需要重启Server服务器!

2种查询方式

1. OQL查询

gfsh>query --query="SELECT * FROM /region1 where id>102 limit 10"
Result : true Rows : 6

id | age | name --- | --- | ------------ 104 | 14 | username:104 109 | 19 |
username:109 106 | 16 | username:106 108 | 18 | username:108 105 | 15 |
username:105 107 | 17 | username:107
1
2
3
4
5
6

当区域里存放了不同对象的数据时,只会查出符合where条件的数据

2. Map方式查询

gfsh>query --query="SELECT key,value FROM /region1.entrySet where key>102 limit 10" 
Result : true Rows : 7

key | value --- | ----------------------------------------- 105 |
{"id":105,"age":15,"name":"username:105"} 103 |
{"id":103,"age":13,"name":"username:103"} 107 |
{"id":107,"age":17,"name":"username:107"} 109 |
{"id":109,"age":19,"name":"username:109"} 104 |
{"id":104,"age":14,"name":"username:104"} 106 |
{"id":106,"age":16,"name":"username:106"} 108 |
{"id":108,"age":18,"name":"username:108"}
1
2
3
4
5
6
7
8
9
10
11

当区域里存放了不同对象的数据时,使用where条件会报错!

Java测试代码

POJO实体类UserEntity

package wjw.test.geode;

import java.io.Serializable;
import java.util.Date;

public class UserEntity {

  private int id;
  private int age;
  private String name;
  private Date registerdDate;

  public UserEntity() {
    super();
  }

  public UserEntity(int id, int age, String name, Date registerdDate) {
    super();
    this.id = id;
    this.age = age;
    this.name = name;
    this.registerdDate = registerdDate;
  }

  public int getId() {
    return id;
  }

  public void setId(int id) {
    this.id = id;
  }

  public int getAge() {
    return age;
  }

  public void setAge(int age) {
    this.age = age;
  }

  public String getName() {
    return name;
  }

  public void setName(String name) {
    this.name = name;
  }

  public Date getRegisterdDate() {
    return registerdDate;
  }

  public void setRegisterdDate(Date registerdDate) {
    this.registerdDate = registerdDate;
  }

  @Override
  public String toString() {
    return "UserEntity [id=" + id + ", age=" + age + ", name=" + name + ", registerdDate=" + registerdDate + "]";
  }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

测试类TestJSONFormatter

package wjw.test.geode;

import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.geode.cache.Region;
import org.apache.geode.cache.client.ClientCache;
import org.apache.geode.cache.client.ClientCacheFactory;
import org.apache.geode.cache.client.ClientRegionFactory;
import org.apache.geode.cache.client.ClientRegionShortcut;
import org.apache.geode.cache.query.SelectResults;
import org.apache.geode.pdx.JSONFormatter;
import org.apache.geode.pdx.PdxInstance;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;

public class TestJSONFormatter {
	ClientCache cache;

	@Before
	public void setUp() throws Exception {
		cache = new ClientCacheFactory().addPoolLocator("T1", 10334).set("log-level", "WARN").create();
	}

	@After
	public void tearDown() throws Exception {
		cache.close();
	}

	@Test
	public void testList() throws Exception {
		ClientRegionFactory<Object, PdxInstance> regionFactory = cache
				.createClientRegionFactory(ClientRegionShortcut.PROXY);

		Region<Object, PdxInstance> region = regionFactory.create("region1");

		SelectResults<PdxInstance> selectResults = region.query("select * from /region1 limit 10");

		for (Object value : selectResults.asSet()) {
			System.out.println("getClassName:" + value.getClass().getName());
			if(value instanceof PdxInstance) {
			  System.out.println("getObject:" + ((PdxInstance) value).getObject());
			} else {
			  System.out.println(value);
			}
		}

		region.close();
	}

	@Test
	public void testAsKeyValue() throws Exception {
		ClientRegionFactory<Object, Object> regionFactory = cache.createClientRegionFactory(ClientRegionShortcut.PROXY);

		Region<Object, Object> region = regionFactory.create("region1");

		SelectResults<Object> selectResults = region
				.query("SELECT key,value FROM /region1.entrySet where key>102 limit 10");

		for (Object value : selectResults.asSet()) {
			System.out.println("getClassName:" + value.getClass().getName());
			System.out.println(value);
		}

		region.close();
	}

	@Test
	public void testAsOQL() throws Exception {
		ClientRegionFactory<Object, PdxInstance> regionFactory = cache
				.createClientRegionFactory(ClientRegionShortcut.PROXY);

		Region<Object, PdxInstance> region = regionFactory.create("region1");

		SelectResults<PdxInstance> selectResults = region.query("select * from /region1 where id>102 limit 10");

		for (PdxInstance value : selectResults.asSet()) {
			System.out.print("getClassName:" + value.getClassName());
			System.out.println("  getObject:" + value.getObject());

			UserEntity ent = org.wjw.efjson.JsonObject.fromJson(JSONFormatter.toJSON(value), UserEntity.class);
			
			System.out.println("UserEntity: "+ent);
		}

		region.close();
	}

	@Test
	public void testClear() throws Exception {
		ClientRegionFactory<Object, PdxInstance> regionFactory = cache
				.createClientRegionFactory(ClientRegionShortcut.PROXY);

		Region<Object, PdxInstance> region = regionFactory.create("region1");

		SelectResults<PdxInstance> selectResults = region.query("select * from /region1");

		@SuppressWarnings({ "rawtypes", "unchecked" })
		List<Object> keyList = new ArrayList(region.keySetOnServer());
		keyList.stream().forEach(key -> {
		  System.out.println("key: "+key+" value:"+region.get(key));
			region.remove(key);
		});

		region.close();
		
		System.out.println("clear all data in region1!");
	}

	@Test
	public void saveUserEntity() {
		ClientRegionFactory<Integer, PdxInstance> regionFactory = cache
				.createClientRegionFactory(ClientRegionShortcut.PROXY);

		Region<Integer, PdxInstance> region = regionFactory.create("region1");

		region.putAll(newUserEntity(10));

		region.close();
	}

	private Map<Integer, PdxInstance> newUserEntity(int size) {
		Map<Integer, PdxInstance> map = new HashMap<Integer, PdxInstance>();
		for (int i = 0; i < size; i++) {
			int id = i + 100;
			
			UserEntity ent = new UserEntity(id, 10 + i, "username:" + id, new Date());
			map.put(id, JSONFormatter.fromJSON(org.wjw.efjson.JsonObject.toJson(ent)));
		}
		return map;
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137