github-forks
/
redisson
mirror of https://github.com/redisson/redisson.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Fixed - hRandFieldWithValues() and hRandField() methods of Spring Data Redis module throw ClassCastException. #4688

Browse Source
pull/4694/head
Nikita Koksharov 2 years ago
parent 1de67f7388
commit aa9051dd6a
11 changed files with 376 additions and 12 deletions
Show Stats Download Patch File Download Diff File

55
redisson-spring-data/redisson-spring-data-26/src/main/java/org/redisson/spring/data/connection/ObjectMapEntryReplayDecoder.java
Unescape Escape View File

@ -0,0 +1,55 @@
/**
* Copyright (c) 2013-2022 Nikita Koksharov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.redisson.spring.data.connection;
import org.redisson.client.codec.Codec;
import org.redisson.client.handler.State;
import org.redisson.client.protocol.Decoder;
import org.redisson.client.protocol.decoder.MultiDecoder;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
/**
*
* @author Nikita Koksharov
*
*/
public class ObjectMapEntryReplayDecoder implements MultiDecoder<List<Entry<Object, Object>>> {
@Override
public Decoder<Object> getDecoder(Codec codec, int paramNum, State state) {
if (paramNum % 2 != 0) {
return codec.getMapValueDecoder();
}
return codec.getMapKeyDecoder();
}
@Override
public List<Entry<Object, Object>> decode(List<Object> parts, State state) {
Map<Object, Object> result = new LinkedHashMap<>(parts.size() / 2);
for (int i = 0; i < parts.size(); i++) {
if (i % 2 != 0) {
result.put(parts.get(i-1), parts.get(i));
}
}
return new ArrayList<>(result.entrySet());
}
}

12
redisson-spring-data/redisson-spring-data-26/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java
Unescape Escape View File

@ -2637,20 +2637,22 @@ public class RedissonConnection extends AbstractRedisConnection {
return zUnionWithScores(null, (Weights) null, sets);
}
private static final RedisCommand<Object> HRANDFIELD = new RedisCommand<Object>("HRANDFIELD");
private static final RedisCommand<Object> HRANDFIELD = new RedisCommand<>("HRANDFIELD");
@Override
public byte[] hRandField(byte[] key) {
Assert.notNull(key, "Key must not be null!");
return read(key, ByteArrayCodec.INSTANCE, HRANDFIELD, (Object) key);
return read(key, ByteArrayCodec.INSTANCE, HRANDFIELD, key);
}
private static final RedisCommand<Entry<Object, Object>> HRANDFIELD_SINGLE = new RedisCommand("HRANDFIELD", new SingleMapEntryDecoder());
@Override
public Entry<byte[], byte[]> hRandFieldWithValues(byte[] key) {
Assert.notNull(key, "Key must not be null!");
return read(key, ByteArrayCodec.INSTANCE, RedisCommands.HRANDFIELD, (Object) key);
return read(key, ByteArrayCodec.INSTANCE, HRANDFIELD_SINGLE, key, 1, "WITHVALUES");
}
private static final RedisCommand<List<Object>> HRANDFIELD_LIST = new RedisCommand<>("HRANDFIELD", new ObjectListReplayDecoder<>());
@ -2662,11 +2664,13 @@ public class RedissonConnection extends AbstractRedisConnection {
return read(key, ByteArrayCodec.INSTANCE, HRANDFIELD_LIST, key, count);
}
private static final RedisCommand<List<Entry<Object, Object>>> HRANDFIELD_VALUES = new RedisCommand("HRANDFIELD",
new ObjectMapEntryReplayDecoder(), new EmptyListConvertor());
@Override
public List<Entry<byte[], byte[]>> hRandFieldWithValues(byte[] key, long count) {
Assert.notNull(key, "Key must not be null!");
return read(key, ByteArrayCodec.INSTANCE, RedisCommands.HRANDFIELD, (Object) key, count);
return read(key, ByteArrayCodec.INSTANCE, HRANDFIELD_VALUES, key, count, "WITHVALUES");
}
@Override

47
redisson-spring-data/redisson-spring-data-26/src/main/java/org/redisson/spring/data/connection/SingleMapEntryDecoder.java
Unescape Escape View File

@ -0,0 +1,47 @@
/**
* Copyright (c) 2013-2022 Nikita Koksharov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.redisson.spring.data.connection;
import org.redisson.client.codec.Codec;
import org.redisson.client.handler.State;
import org.redisson.client.protocol.Decoder;
import org.redisson.client.protocol.decoder.MultiDecoder;
import java.util.AbstractMap;
import java.util.List;
import java.util.Map.Entry;
/**
*
* @author Nikita Koksharov
*
*/
public class SingleMapEntryDecoder implements MultiDecoder<Entry<Object, Object>> {
@Override
public Decoder<Object> getDecoder(Codec codec, int paramNum, State state) {
if (paramNum % 2 != 0) {
return codec.getMapValueDecoder();
}
return codec.getMapKeyDecoder();
}
@Override
public Entry<Object, Object> decode(List<Object> parts, State state) {
return new AbstractMap.SimpleEntry<>(parts.get(0), parts.get(1));
}
}

55
redisson-spring-data/redisson-spring-data-27/src/main/java/org/redisson/spring/data/connection/ObjectMapEntryReplayDecoder.java
Unescape Escape View File

@ -0,0 +1,55 @@
/**
* Copyright (c) 2013-2022 Nikita Koksharov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.redisson.spring.data.connection;
import org.redisson.client.codec.Codec;
import org.redisson.client.handler.State;
import org.redisson.client.protocol.Decoder;
import org.redisson.client.protocol.decoder.MultiDecoder;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
/**
*
* @author Nikita Koksharov
*
*/
public class ObjectMapEntryReplayDecoder implements MultiDecoder<List<Entry<Object, Object>>> {
@Override
public Decoder<Object> getDecoder(Codec codec, int paramNum, State state) {
if (paramNum % 2 != 0) {
return codec.getMapValueDecoder();
}
return codec.getMapKeyDecoder();
}
@Override
public List<Entry<Object, Object>> decode(List<Object> parts, State state) {
Map<Object, Object> result = new LinkedHashMap<>(parts.size() / 2);
for (int i = 0; i < parts.size(); i++) {
if (i % 2 != 0) {
result.put(parts.get(i-1), parts.get(i));
}
}
return new ArrayList<>(result.entrySet());
}
}

12
redisson-spring-data/redisson-spring-data-27/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java
Unescape Escape View File

@ -2636,20 +2636,22 @@ public class RedissonConnection extends AbstractRedisConnection {
return zUnionWithScores(null, (Weights) null, sets);
}
private static final RedisCommand<Object> HRANDFIELD = new RedisCommand<Object>("HRANDFIELD");
private static final RedisCommand<Object> HRANDFIELD = new RedisCommand<>("HRANDFIELD");
@Override
public byte[] hRandField(byte[] key) {
Assert.notNull(key, "Key must not be null!");
return read(key, ByteArrayCodec.INSTANCE, HRANDFIELD, (Object) key);
return read(key, ByteArrayCodec.INSTANCE, HRANDFIELD, key);
}
private static final RedisCommand<Entry<Object, Object>> HRANDFIELD_SINGLE = new RedisCommand("HRANDFIELD", new SingleMapEntryDecoder());
@Override
public Entry<byte[], byte[]> hRandFieldWithValues(byte[] key) {
Assert.notNull(key, "Key must not be null!");
return read(key, ByteArrayCodec.INSTANCE, RedisCommands.HRANDFIELD, (Object) key);
return read(key, ByteArrayCodec.INSTANCE, HRANDFIELD_SINGLE, key, 1, "WITHVALUES");
}
private static final RedisCommand<List<Object>> HRANDFIELD_LIST = new RedisCommand<>("HRANDFIELD", new ObjectListReplayDecoder<>());
@ -2661,11 +2663,13 @@ public class RedissonConnection extends AbstractRedisConnection {
return read(key, ByteArrayCodec.INSTANCE, HRANDFIELD_LIST, key, count);
}
private static final RedisCommand<List<Entry<Object, Object>>> HRANDFIELD_VALUES = new RedisCommand("HRANDFIELD",
new ObjectMapEntryReplayDecoder(), new EmptyListConvertor());
@Override
public List<Entry<byte[], byte[]>> hRandFieldWithValues(byte[] key, long count) {
Assert.notNull(key, "Key must not be null!");
return read(key, ByteArrayCodec.INSTANCE, RedisCommands.HRANDFIELD, (Object) key, count);
return read(key, ByteArrayCodec.INSTANCE, HRANDFIELD_VALUES, key, count, "WITHVALUES");
}
@Override

47
redisson-spring-data/redisson-spring-data-27/src/main/java/org/redisson/spring/data/connection/SingleMapEntryDecoder.java
Unescape Escape View File

@ -0,0 +1,47 @@
/**
* Copyright (c) 2013-2022 Nikita Koksharov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.redisson.spring.data.connection;
import org.redisson.client.codec.Codec;
import org.redisson.client.handler.State;
import org.redisson.client.protocol.Decoder;
import org.redisson.client.protocol.decoder.MultiDecoder;
import java.util.AbstractMap;
import java.util.List;
import java.util.Map.Entry;
/**
*
* @author Nikita Koksharov
*
*/
public class SingleMapEntryDecoder implements MultiDecoder<Entry<Object, Object>> {
@Override
public Decoder<Object> getDecoder(Codec codec, int paramNum, State state) {
if (paramNum % 2 != 0) {
return codec.getMapValueDecoder();
}
return codec.getMapKeyDecoder();
}
@Override
public Entry<Object, Object> decode(List<Object> parts, State state) {
return new AbstractMap.SimpleEntry<>(parts.get(0), parts.get(1));
}
}

52
redisson-spring-data/redisson-spring-data-30/src/main/java/org/redisson/spring/data/connection/ObjectMapEntryReplayDecoder.java
Unescape Escape View File

@ -0,0 +1,52 @@
/**
* Copyright (c) 2013-2022 Nikita Koksharov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.redisson.spring.data.connection;
import org.redisson.client.codec.Codec;
import org.redisson.client.handler.State;
import org.redisson.client.protocol.Decoder;
import org.redisson.client.protocol.decoder.MultiDecoder;
import java.util.*;
import java.util.Map.Entry;
/**
*
* @author Nikita Koksharov
*
*/
public class ObjectMapEntryReplayDecoder implements MultiDecoder<List<Entry<Object, Object>>> {
@Override
public Decoder<Object> getDecoder(Codec codec, int paramNum, State state) {
if (paramNum % 2 != 0) {
return codec.getMapValueDecoder();
}
return codec.getMapKeyDecoder();
}
@Override
public List<Entry<Object, Object>> decode(List<Object> parts, State state) {
Map<Object, Object> result = new LinkedHashMap<>(parts.size() / 2);
for (int i = 0; i < parts.size(); i++) {
if (i % 2 != 0) {
result.put(parts.get(i-1), parts.get(i));
}
}
return new ArrayList<>(result.entrySet());
}
}

12
redisson-spring-data/redisson-spring-data-30/src/main/java/org/redisson/spring/data/connection/RedissonConnection.java
Unescape Escape View File

@ -2562,20 +2562,22 @@ public class RedissonConnection extends AbstractRedisConnection {
return zUnionWithScores(null, (Weights) null, sets);
}
private static final RedisCommand<Object> HRANDFIELD = new RedisCommand<Object>("HRANDFIELD");
private static final RedisCommand<Object> HRANDFIELD = new RedisCommand<>("HRANDFIELD");
@Override
public byte[] hRandField(byte[] key) {
Assert.notNull(key, "Key must not be null!");
return read(key, ByteArrayCodec.INSTANCE, HRANDFIELD, (Object) key);
return read(key, ByteArrayCodec.INSTANCE, HRANDFIELD, key);
}
private static final RedisCommand<Entry<Object, Object>> HRANDFIELD_SINGLE = new RedisCommand("HRANDFIELD", new SingleMapEntryDecoder());
@Override
public Entry<byte[], byte[]> hRandFieldWithValues(byte[] key) {
Assert.notNull(key, "Key must not be null!");
return read(key, ByteArrayCodec.INSTANCE, RedisCommands.HRANDFIELD, (Object) key);
return read(key, ByteArrayCodec.INSTANCE, HRANDFIELD_SINGLE, key, 1, "WITHVALUES");
}
private static final RedisCommand<List<Object>> HRANDFIELD_LIST = new RedisCommand<>("HRANDFIELD", new ObjectListReplayDecoder<>());
@ -2587,11 +2589,13 @@ public class RedissonConnection extends AbstractRedisConnection {
return read(key, ByteArrayCodec.INSTANCE, HRANDFIELD_LIST, key, count);
}
private static final RedisCommand<List<Entry<Object, Object>>> HRANDFIELD_VALUES = new RedisCommand("HRANDFIELD",
new ObjectMapEntryReplayDecoder(), new EmptyListConvertor());
@Override
public List<Entry<byte[], byte[]>> hRandFieldWithValues(byte[] key, long count) {
Assert.notNull(key, "Key must not be null!");
return read(key, ByteArrayCodec.INSTANCE, RedisCommands.HRANDFIELD, (Object) key, count);
return read(key, ByteArrayCodec.INSTANCE, HRANDFIELD_VALUES, key, count, "WITHVALUES");
}
@Override

46
redisson-spring-data/redisson-spring-data-30/src/main/java/org/redisson/spring/data/connection/SingleMapEntryDecoder.java
Unescape Escape View File

@ -0,0 +1,46 @@
/**
* Copyright (c) 2013-2022 Nikita Koksharov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.redisson.spring.data.connection;
import org.redisson.client.codec.Codec;
import org.redisson.client.handler.State;
import org.redisson.client.protocol.Decoder;
import org.redisson.client.protocol.decoder.MultiDecoder;
import java.util.*;
import java.util.Map.Entry;
/**
*
* @author Nikita Koksharov
*
*/
public class SingleMapEntryDecoder implements MultiDecoder<Entry<Object, Object>> {
@Override
public Decoder<Object> getDecoder(Codec codec, int paramNum, State state) {
if (paramNum % 2 != 0) {
return codec.getMapValueDecoder();
}
return codec.getMapKeyDecoder();
}
@Override
public Entry<Object, Object> decode(List<Object> parts, State state) {
return new AbstractMap.SimpleEntry<>(parts.get(0), parts.get(1));
}
}

17
redisson-spring-data/redisson-spring-data-30/src/test/java/org/redisson/spring/data/connection/RedissonConnectionTest.java
Unescape Escape View File

@ -16,6 +16,8 @@ import org.springframework.data.redis.core.ScanOptions;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.types.Expiration;
import java.util.List;
import java.util.Map;
import java.util.Set;
public class RedissonConnectionTest extends BaseConnectionTest {
@ -121,5 +123,20 @@ public class RedissonConnectionTest extends BaseConnectionTest {
assertThat(t.next().getValue()).isEqualTo("value2".getBytes());
}
@Test
public void testRandFieldWithValues() {
connection.hSet("map".getBytes(), "key1".getBytes(), "value1".getBytes());
connection.hSet("map".getBytes(), "key2".getBytes(), "value2".getBytes());
connection.hSet("map".getBytes(), "key3".getBytes(), "value3".getBytes());
List<Map.Entry<byte[], byte[]>> s = connection.hRandFieldWithValues("map".getBytes(), 2);
assertThat(s).hasSize(2);
Map.Entry<byte[], byte[]> s2 = connection.hRandFieldWithValues("map".getBytes());
assertThat(s2).isNotNull();
byte[] f = connection.hRandField("map".getBytes());
assertThat((Object) f).isIn("key1".getBytes(), "key2".getBytes(), "key3".getBytes());
}
}

33
redisson/src/main/java/org/redisson/client/protocol/convertor/EmptyListConvertor.java
Unescape Escape View File

@ -0,0 +1,33 @@
/**
* Copyright (c) 2013-2022 Nikita Koksharov
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.redisson.client.protocol.convertor;
import java.util.Collections;
/**
* @author Nikita Koksharov
*/
public class EmptyListConvertor implements Convertor<Object> {
@Override
public Object convert(Object obj) {
if (obj == null) {
return Collections.emptyList();
}
return obj;
}
}
Write Preview
Loading…
Cancel
Save