Skip to content

Commit f3d96c9

Browse files
andy-stark-redisandy-stark-redis
committed
DOC-5376 DOC-5375 temp Lettuce reactive hash and set examples
1 parent 8a287bf commit f3d96c9

File tree

2 files changed

+391
-0
lines changed

2 files changed

+391
-0
lines changed

‎local_examples/tmp/lettuce-reactive/HashExample.java‎

Lines changed: 161 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,161 @@
1+
// EXAMPLE: hash_tutorial
2+
package io.redis.examples.reactive;
3+
4+
import io.lettuce.core.*;
5+
import io.lettuce.core.api.reactive.RedisReactiveCommands;
6+
import io.lettuce.core.api.StatefulRedisConnection;
7+
// REMOVE_START
8+
import org.junit.jupiter.api.Test;
9+
import static org.assertj.core.api.Assertions.assertThat;
10+
// REMOVE_END
11+
12+
import reactor.core.publisher.Mono;
13+
14+
import java.util.*;
15+
16+
public class HashExample {
17+
18+
// REMOVE_START
19+
@Test
20+
// REMOVE_END
21+
public void run() {
22+
RedisClient redisClient = RedisClient.create("redis://localhost:6379");
23+
24+
try (StatefulRedisConnection<String, String> connection = redisClient.connect()) {
25+
RedisReactiveCommands<String, String> reactiveCommands = connection.reactive();
26+
// REMOVE_START
27+
// Clean up any existing data
28+
Mono<Void> cleanup = reactiveCommands.del("bike:1", "bike:1:stats").then();
29+
cleanup.block();
30+
// REMOVE_END
31+
32+
// STEP_START set_get_all
33+
Map<String, String> bike1 = new HashMap<>();
34+
bike1.put("model", "Deimos");
35+
bike1.put("brand", "Ergonom");
36+
bike1.put("type", "Enduro bikes");
37+
bike1.put("price", "4972");
38+
39+
Mono<Long> setGetAll = reactiveCommands.hset("bike:1", bike1).doOnNext(result -> {
40+
System.out.println(result); // >>> 4
41+
// REMOVE_START
42+
assertThat(result).isEqualTo(4L);
43+
// REMOVE_END
44+
});
45+
46+
setGetAll.block();
47+
48+
Mono<String> getModel = reactiveCommands.hget("bike:1", "model").doOnNext(result -> {
49+
System.out.println(result); // >>> Deimos
50+
// REMOVE_START
51+
assertThat(result).isEqualTo("Deimos");
52+
// REMOVE_END
53+
});
54+
55+
Mono<String> getPrice = reactiveCommands.hget("bike:1", "price").doOnNext(result -> {
56+
System.out.println(result); // >>> 4972
57+
// REMOVE_START
58+
assertThat(result).isEqualTo("4972");
59+
// REMOVE_END
60+
});
61+
62+
Mono<List<KeyValue<String, String>>> getAll = reactiveCommands.hgetall("bike:1").collectList().doOnNext(result -> {
63+
System.out.println(result);
64+
// >>> [KeyValue[type, Enduro bikes], KeyValue[brand, Ergonom],
65+
// KeyValue[price, 4972], KeyValue[model, Deimos]]
66+
// REMOVE_START
67+
List<KeyValue<String, String>> expected = new ArrayList<>(
68+
Arrays.asList(KeyValue.just("price", "4972"), KeyValue.just("model", "Deimos"),
69+
KeyValue.just("type", "Enduro bikes"), KeyValue.just("brand", "Ergonom")));
70+
assertThat(result).isEqualTo(expected);
71+
// REMOVE_END
72+
});
73+
// STEP_END
74+
75+
// STEP_START hmget
76+
Mono<List<KeyValue<String, String>>> hmGet = reactiveCommands.hmget("bike:1", "model", "price").collectList()
77+
.doOnNext(result -> {
78+
System.out.println(result);
79+
// >>> [KeyValue[model, Deimos], KeyValue[price, 4972]]
80+
// REMOVE_START
81+
List<KeyValue<String, String>> expected = new ArrayList<>(
82+
Arrays.asList(KeyValue.just("model", "Deimos"), KeyValue.just("price", "4972")));
83+
assertThat(result).isEqualTo(expected);
84+
// REMOVE_END
85+
});
86+
// STEP_END
87+
88+
Mono.when(getModel, getPrice, getAll, hmGet).block();
89+
90+
// STEP_START hincrby
91+
Mono<Void> hIncrBy = reactiveCommands.hincrby("bike:1", "price", 100).doOnNext(result -> {
92+
System.out.println(result); // >>> 5072
93+
// REMOVE_START
94+
assertThat(result).isEqualTo(5072L);
95+
// REMOVE_END
96+
}).flatMap(v -> reactiveCommands.hincrby("bike:1", "price", -100)).doOnNext(result -> {
97+
System.out.println(result); // >>> 4972
98+
// REMOVE_START
99+
assertThat(result).isEqualTo(4972L);
100+
// REMOVE_END
101+
}).then();
102+
// STEP_END
103+
hIncrBy.block();
104+
105+
// STEP_START incrby_get_mget
106+
Mono<Void> incrByGetMget = reactiveCommands.hincrby("bike:1:stats", "rides", 1).doOnNext(result -> {
107+
System.out.println(result); // >>> 1
108+
// REMOVE_START
109+
assertThat(result).isEqualTo(1L);
110+
// REMOVE_END
111+
}).flatMap(v -> reactiveCommands.hincrby("bike:1:stats", "rides", 1)).doOnNext(result -> {
112+
System.out.println(result); // >>> 2
113+
// REMOVE_START
114+
assertThat(result).isEqualTo(2L);
115+
// REMOVE_END
116+
}).flatMap(v -> reactiveCommands.hincrby("bike:1:stats", "rides", 1)).doOnNext(result -> {
117+
System.out.println(result); // >>> 3
118+
// REMOVE_START
119+
assertThat(result).isEqualTo(3L);
120+
// REMOVE_END
121+
}).flatMap(v -> reactiveCommands.hincrby("bike:1:stats", "crashes", 1)).doOnNext(result -> {
122+
System.out.println(result); // >>> 1
123+
// REMOVE_START
124+
assertThat(result).isEqualTo(1L);
125+
// REMOVE_END
126+
}).flatMap(v -> reactiveCommands.hincrby("bike:1:stats", "owners", 1)).doOnNext(result -> {
127+
System.out.println(result); // >>> 1
128+
// REMOVE_START
129+
assertThat(result).isEqualTo(1L);
130+
// REMOVE_END
131+
}).then();
132+
133+
incrByGetMget.block();
134+
135+
Mono<String> getRides = reactiveCommands.hget("bike:1:stats", "rides").doOnNext(result -> {
136+
System.out.println(result); // >>> 3
137+
// REMOVE_START
138+
assertThat(result).isEqualTo("3");
139+
// REMOVE_END
140+
});
141+
142+
Mono<List<KeyValue<String, String>>> getCrashesOwners = reactiveCommands.hmget("bike:1:stats", "crashes", "owners")
143+
.collectList().doOnNext(result -> {
144+
System.out.println(result);
145+
// >>> [KeyValue[crashes, 1], KeyValue[owners, 1]]
146+
// REMOVE_START
147+
List<KeyValue<String, String>> expected = new ArrayList<>(
148+
Arrays.asList(KeyValue.just("crashes", "1"), KeyValue.just("owners", "1")));
149+
150+
assertThat(result).isEqualTo(expected);
151+
// REMOVE_END
152+
});
153+
// STEP_END
154+
155+
Mono.when(getRides, getCrashesOwners).block();
156+
} finally {
157+
redisClient.shutdown();
158+
}
159+
}
160+
161+
}

‎local_examples/tmp/lettuce-reactive/SetExample.java‎

Lines changed: 230 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,230 @@
1+
// EXAMPLE: sets_tutorial
2+
package io.redis.examples.reactive;
3+
4+
import io.lettuce.core.*;
5+
import io.lettuce.core.api.reactive.RedisReactiveCommands;
6+
import io.lettuce.core.api.StatefulRedisConnection;
7+
// REMOVE_START
8+
import org.junit.jupiter.api.Test;
9+
import static org.assertj.core.api.Assertions.assertThat;
10+
// REMOVE_END
11+
12+
import reactor.core.publisher.Mono;
13+
14+
import java.util.*;
15+
16+
public class SetExample {
17+
18+
// REMOVE_START
19+
@Test
20+
// REMOVE_END
21+
public void run() {
22+
RedisClient redisClient = RedisClient.create("redis://localhost:6379");
23+
24+
try (StatefulRedisConnection<String, String> connection = redisClient.connect()) {
25+
RedisReactiveCommands<String, String> reactiveCommands = connection.reactive();
26+
// REMOVE_START
27+
// Clean up any existing data
28+
Mono<Void> cleanup = reactiveCommands.del("bikes:racing:france", "bikes:racing:usa", "bikes:racing:italy").then();
29+
cleanup.block();
30+
// REMOVE_END
31+
32+
// STEP_START sadd
33+
Mono<Void> sAdd = reactiveCommands.sadd("bikes:racing:france", "bike:1").doOnNext(result -> {
34+
System.out.println(result); // >>> 1
35+
// REMOVE_START
36+
assertThat(result).isEqualTo(1L);
37+
// REMOVE_END
38+
}).flatMap(v -> reactiveCommands.sadd("bikes:racing:france", "bike:1")).doOnNext(result -> {
39+
System.out.println(result); // >>> 0
40+
// REMOVE_START
41+
assertThat(result).isEqualTo(0L);
42+
// REMOVE_END
43+
}).flatMap(v -> reactiveCommands.sadd("bikes:racing:france", "bike:2", "bike:3")).doOnNext(result -> {
44+
System.out.println(result); // >>> 2
45+
// REMOVE_START
46+
assertThat(result).isEqualTo(2L);
47+
// REMOVE_END
48+
}).flatMap(v -> reactiveCommands.sadd("bikes:racing:usa", "bike:1", "bike:4")).doOnNext(result -> {
49+
System.out.println(result); // >>> 2
50+
// REMOVE_START
51+
assertThat(result).isEqualTo(2L);
52+
// REMOVE_END
53+
}).then();
54+
// STEP_END
55+
sAdd.block();
56+
57+
// STEP_START sismember
58+
Mono<Boolean> sIsMember1 = reactiveCommands.sismember("bikes:racing:usa", "bike:1").doOnNext(result -> {
59+
System.out.println(result); // >>> true
60+
// REMOVE_START
61+
assertThat(result).isTrue();
62+
// REMOVE_END
63+
});
64+
65+
Mono<Boolean> sIsMember2 = reactiveCommands.sismember("bikes:racing:usa", "bike:2").doOnNext(result -> {
66+
System.out.println(result); // >>> false
67+
// REMOVE_START
68+
assertThat(result).isFalse();
69+
// REMOVE_END
70+
});
71+
// STEP_END
72+
73+
// STEP_START sinter
74+
Mono<List<String>> sInter = reactiveCommands.sinter("bikes:racing:france", "bikes:racing:usa").collectList()
75+
.doOnNext(result -> {
76+
System.out.println(result); // >>> [bike:1]
77+
// REMOVE_START
78+
assertThat(result).containsExactly("bike:1");
79+
// REMOVE_END
80+
});
81+
// STEP_END
82+
83+
// STEP_START scard
84+
Mono<Long> sCard = reactiveCommands.scard("bikes:racing:france").doOnNext(result -> {
85+
System.out.println(result); // >>> 3
86+
// REMOVE_START
87+
assertThat(result).isEqualTo(3L);
88+
// REMOVE_END
89+
});
90+
// STEP_END
91+
92+
Mono.when(sIsMember1, sIsMember2, sInter, sCard).block();
93+
94+
// STEP_START sadd_smembers
95+
Mono<Void> sAddSMembers = reactiveCommands.sadd("bikes:racing:france", "bike:1", "bike:2", "bike:3")
96+
.doOnNext(result -> {
97+
System.out.println(result); // >>> 3
98+
// REMOVE_START
99+
assertThat(result).isEqualTo(0L);
100+
// REMOVE_END
101+
}).flatMap(v -> reactiveCommands.smembers("bikes:racing:france").collectList()).doOnNext(result -> {
102+
System.out.println(result); // >>> [bike:1, bike:2, bike:3]
103+
// REMOVE_START
104+
assertThat(result).containsExactlyInAnyOrder("bike:1", "bike:2", "bike:3");
105+
// REMOVE_END
106+
}).then();
107+
// STEP_END
108+
sAddSMembers.block();
109+
110+
// STEP_START smismember
111+
Mono<Boolean> sIsMember3 = reactiveCommands.sismember("bikes:racing:france", "bike:1").doOnNext(result -> {
112+
System.out.println(result); // >>> true
113+
// REMOVE_START
114+
assertThat(result).isTrue();
115+
// REMOVE_END
116+
});
117+
118+
Mono<List<Boolean>> sMIsMember = reactiveCommands.smismember("bikes:racing:france", "bike:2", "bike:3", "bike:4")
119+
.collectList().doOnNext(result -> {
120+
System.out.println(result); // >>> [true, true, false]
121+
// REMOVE_START
122+
assertThat(result).containsExactly(true, true, false);
123+
// REMOVE_END
124+
});
125+
// STEP_END
126+
127+
// STEP_START sdiff
128+
Mono<List<String>> sDiff = reactiveCommands.sdiff("bikes:racing:france", "bikes:racing:usa").collectList()
129+
.doOnNext(result -> {
130+
System.out.println(result); // >>> [bike:2, bike:3]
131+
// REMOVE_START
132+
assertThat(result).containsExactlyInAnyOrder("bike:2", "bike:3");
133+
// REMOVE_END
134+
});
135+
// STEP_END
136+
137+
Mono.when(sIsMember3, sMIsMember, sDiff).block();
138+
139+
// STEP_START multisets
140+
Mono<Void> add3sets = reactiveCommands.sadd("bikes:racing:france", "bike:1", "bike:2", "bike:3")
141+
.doOnNext(result -> {
142+
System.out.println(result); // >>> 0
143+
// REMOVE_START
144+
assertThat(result).isEqualTo(0L);
145+
// REMOVE_END
146+
}).flatMap(v -> reactiveCommands.sadd("bikes:racing:usa", "bike:1", "bike:4")).doOnNext(result -> {
147+
System.out.println(result); // >>> 0
148+
// REMOVE_START
149+
assertThat(result).isEqualTo(0L);
150+
// REMOVE_END
151+
}).flatMap(v -> reactiveCommands.sadd("bikes:racing:italy", "bike:1", "bike:2", "bike:3", "bike:4"))
152+
.doOnNext(result -> {
153+
System.out.println(result); // >>> 4,
154+
// REMOVE_START
155+
assertThat(result).isEqualTo(4L);
156+
// REMOVE_END
157+
}).then();
158+
add3sets.block();
159+
160+
Mono<List<String>> multisets1 = reactiveCommands
161+
.sinter("bikes:racing:france", "bikes:racing:usa", "bikes:racing:italy").collectList().doOnNext(result -> {
162+
System.out.println(result); // >>> [bike:1]
163+
// REMOVE_START
164+
assertThat(result).containsExactly("bike:1");
165+
// REMOVE_END
166+
});
167+
168+
Mono<List<String>> multisets2 = reactiveCommands
169+
.sunion("bikes:racing:france", "bikes:racing:usa", "bikes:racing:italy").collectList().doOnNext(result -> {
170+
System.out.println(result); // >>> [bike:1, bike:2, bike:3, bike:4]
171+
// REMOVE_START
172+
assertThat(result).containsExactlyInAnyOrder("bike:1", "bike:2", "bike:3", "bike:4");
173+
// REMOVE_END
174+
});
175+
176+
Mono<List<String>> multisets3 = reactiveCommands
177+
.sdiff("bikes:racing:france", "bikes:racing:usa", "bikes:racing:italy").collectList().doOnNext(result -> {
178+
System.out.println(result); // >>> []
179+
// REMOVE_START
180+
assertThat(result).isEmpty();
181+
// REMOVE_END
182+
});
183+
184+
Mono<List<String>> multisets4 = reactiveCommands.sdiff("bikes:racing:usa", "bikes:racing:france").collectList()
185+
.doOnNext(result -> {
186+
System.out.println(result); // >>> [bike:4]
187+
// REMOVE_START
188+
assertThat(result).containsExactly("bike:4");
189+
// REMOVE_END
190+
});
191+
192+
Mono<List<String>> multisets5 = reactiveCommands.sdiff("bikes:racing:france", "bikes:racing:usa").collectList()
193+
.doOnNext(result -> {
194+
System.out.println(result); // >>> [bike:2, bike:3]
195+
// REMOVE_START
196+
assertThat(result).containsExactlyInAnyOrder("bike:2", "bike:3");
197+
// REMOVE_END
198+
});
199+
// STEP_END
200+
201+
Mono.when(multisets1, multisets2, multisets3, multisets4, multisets5).block();
202+
203+
// STEP_START srem
204+
Mono<Void> sRem = reactiveCommands.sadd("bikes:racing:france", "bike:1", "bike:2", "bike:3", "bike:4", "bike:5")
205+
.doOnNext(result -> {
206+
System.out.println(result); // >>> 2
207+
// REMOVE_START
208+
assertThat(result).isEqualTo(2L);
209+
// REMOVE_END
210+
}).flatMap(v -> reactiveCommands.srem("bikes:racing:france", "bike:1")).doOnNext(result -> {
211+
System.out.println(result); // >>> 1
212+
// REMOVE_START
213+
assertThat(result).isEqualTo(1L);
214+
// REMOVE_END
215+
}).flatMap(v -> reactiveCommands.spop("bikes:racing:france")).doOnNext(result -> {
216+
System.out.println(result); // >>> bike:3 (for example)
217+
}).flatMap(v -> reactiveCommands.smembers("bikes:racing:france").collectList()).doOnNext(result -> {
218+
System.out.println(result); // >>> [bike:2, bike:4, bike:5] (for example)
219+
}).flatMap(v -> reactiveCommands.srandmember("bikes:racing:france")).doOnNext(result -> {
220+
System.out.println(result); // >>> bike:4 (for example)
221+
}).then();
222+
// STEP_END
223+
224+
sRem.block();
225+
} finally {
226+
redisClient.shutdown();
227+
}
228+
}
229+
230+
}

0 commit comments

Comments
 (0)