All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • org.redisson.spring.data.connection.RedissonReactiveStringCommands Maven / Gradle / Ivy

    /**
 * Copyright (c) 2013-2020 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 java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

import org.reactivestreams.Publisher;
import org.redisson.client.codec.ByteArrayCodec;
import org.redisson.client.codec.StringCodec;
import org.redisson.client.handler.State;
import org.redisson.client.protocol.Decoder;
import org.redisson.client.protocol.RedisCommand;
import org.redisson.client.protocol.RedisCommands;
import org.redisson.client.protocol.RedisStrictCommand;
import org.redisson.client.protocol.convertor.BooleanReplayConvertor;
import org.redisson.reactive.CommandReactiveExecutor;
import org.springframework.data.domain.Range;
import org.springframework.data.redis.connection.ReactiveRedisConnection.AbsentByteBufferResponse;
import org.springframework.data.redis.connection.ReactiveRedisConnection.BooleanResponse;
import org.springframework.data.redis.connection.ReactiveRedisConnection.ByteBufferResponse;
import org.springframework.data.redis.connection.ReactiveRedisConnection.KeyCommand;
import org.springframework.data.redis.connection.ReactiveRedisConnection.MultiValueResponse;
import org.springframework.data.redis.connection.ReactiveRedisConnection.NumericResponse;
import org.springframework.data.redis.connection.ReactiveRedisConnection.RangeCommand;
import org.springframework.data.redis.connection.ReactiveStringCommands;
import org.springframework.data.redis.connection.RedisStringCommands.BitOperation;
import org.springframework.data.redis.connection.RedisStringCommands.SetOption;
import org.springframework.util.Assert;

import io.netty.buffer.ByteBuf;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

/**
 * 
 * @author Nikita Koksharov
 *
 */
public class RedissonReactiveStringCommands extends RedissonBaseReactive implements ReactiveStringCommands {

    RedissonReactiveStringCommands(CommandReactiveExecutor executorService) {
        super(executorService);
    }

    private static final RedisCommand SET = new RedisCommand("SET", new BooleanReplayConvertor());
    
    @Override
    public Flux> set(Publisher commands) {
        return execute(commands, command -> {

            Assert.notNull(command.getKey(), "Key must not be null!");
            Assert.notNull(command.getValue(), "Value must not be null!");

            byte[] key = toByteArray(command.getKey());
            byte[] value = toByteArray(command.getValue());
            
            if (!command.getExpiration().isPresent()) {
                Mono m = write(key, StringCodec.INSTANCE, SET, key, value);
                return m.map(v -> new BooleanResponse<>(command, v));
            } else if (command.getExpiration().get().isPersistent()) {
                if (!command.getOption().isPresent() || command.getOption().get() == SetOption.UPSERT) {
                    Mono m = write(key, StringCodec.INSTANCE, SET, key, value);
                    return m.map(v -> new BooleanResponse<>(command, v));
                }
                if (command.getOption().get() == SetOption.SET_IF_ABSENT) {
                    Mono m = write(key, StringCodec.INSTANCE, SET, key, value, "NX");
                    return m.map(v -> new BooleanResponse<>(command, v));
                }
                if (command.getOption().get() == SetOption.SET_IF_PRESENT) {
                    Mono m = write(key, StringCodec.INSTANCE, SET, key, value, "XX");
                    return m.map(v -> new BooleanResponse<>(command, v));
                }
            } else {
                if (!command.getOption().isPresent() || command.getOption().get() == SetOption.UPSERT) {
                    Mono m = write(key, StringCodec.INSTANCE, RedisCommands.SET, key, value, "PX", command.getExpiration().get().getExpirationTimeInMilliseconds());
                    return m.map(v -> new BooleanResponse<>(command, v));
                }
                if (command.getOption().get() == SetOption.SET_IF_ABSENT) {
                    Mono m = write(key, StringCodec.INSTANCE, RedisCommands.SET, key, value, "PX", command.getExpiration().get().getExpirationTimeInMilliseconds(), "NX");
                    return m.map(v -> new BooleanResponse<>(command, v));
                }
                if (command.getOption().get() == SetOption.SET_IF_PRESENT) {
                    Mono m = write(key, StringCodec.INSTANCE, RedisCommands.SET, key, value, "PX", command.getExpiration().get().getExpirationTimeInMilliseconds(), "XX");
                    return m.map(v -> new BooleanResponse<>(command, v));
                }
            }
            throw new IllegalArgumentException();
        });
    }

    private static final RedisCommand GET = new RedisCommand("GET", new Decoder() {
        @Override
        public Object decode(ByteBuf buf, State state) throws IOException {
            if (buf.readableBytes() == 0) {
                System.out.println("null:");
                return null;
            }
            
            byte[] result = new byte[buf.readableBytes()];
            buf.readBytes(result);
            return result;
        }
        
    });
    
    @Override
    public Flux> get(Publisher keys) {
        return execute(keys, command -> {

            Assert.notNull(command.getKey(), "Key must not be null!");

            byte[] keyBuf = toByteArray(command.getKey());
            Mono m = read(keyBuf, ByteArrayCodec.INSTANCE, GET, keyBuf);
            return m.map(v -> new ByteBufferResponse<>(command, ByteBuffer.wrap(v)))
                    .defaultIfEmpty(new AbsentByteBufferResponse<>(command));
        });
    }

    @Override
    public Flux> getSet(Publisher commands) {
        return execute(commands, command -> {

            Assert.notNull(command.getKey(), "Key must not be null!");
            Assert.notNull(command.getValue(), "Value must not be null!");

            if (command.getExpiration().isPresent() || command.getOption().isPresent()) {
                throw new IllegalArgumentException("Command must not define expiration nor option for GETSET.");
            }

            byte[] keyBuf = toByteArray(command.getKey());
            byte[] valueBuf = toByteArray(command.getValue());
            
            Mono m = write(keyBuf, ByteArrayCodec.INSTANCE, RedisCommands.GETSET, keyBuf, valueBuf);
            return m.map(v -> new ByteBufferResponse<>(command, ByteBuffer.wrap(v)));
        });
    }

    @Override
    public Flux, ByteBuffer>> mGet(Publisher> keysets) {
        return execute(keysets, coll -> {

            Assert.notNull(coll, "List must not be null!");
            
            Object[] params = coll.stream().map(buf -> toByteArray(buf)).toArray(Object[]::new);

            Mono> m = read(null, ByteArrayCodec.INSTANCE, RedisCommands.MGET, params);
            return m.map(v -> {
                List values = v.stream().map(array -> {
                    if (array == null) {
                        return ByteBuffer.allocate(0);
                    }
                    return ByteBuffer.wrap(array);
                }).collect(Collectors.toList());
                return new MultiValueResponse<>(coll, values);
            });
        });
    }

    @Override
    public Flux> setNX(Publisher values) {
        return execute(values, command -> {

            Assert.notNull(command.getKey(), "Key must not be null!");
            Assert.notNull(command.getValue(), "Value must not be null!");

            if (command.getExpiration().isPresent() || command.getOption().isPresent()) {
                throw new IllegalArgumentException("Command must not define expiration nor option for GETSET.");
            }

            byte[] keyBuf = toByteArray(command.getKey());
            byte[] valueBuf = toByteArray(command.getValue());
            
            Mono m = write(keyBuf, StringCodec.INSTANCE, RedisCommands.SETNX, keyBuf, valueBuf);
            return m.map(v -> new BooleanResponse<>(command, v));
        });
    }

    private static final RedisCommand SETEX = new RedisCommand("SETEX", new BooleanReplayConvertor());
    
    @Override
    public Flux> setEX(Publisher commands) {
        return execute(commands, command -> {

            Assert.notNull(command.getKey(), "Key must not be null!");
            Assert.notNull(command.getValue(), "Value must not be null!");

            if (!command.getExpiration().isPresent()) {
                throw new IllegalArgumentException("Expiration must not be null!");
            }

            byte[] keyBuf = toByteArray(command.getKey());
            byte[] valueBuf = toByteArray(command.getValue());
            
            Mono m = write(keyBuf, StringCodec.INSTANCE, SETEX, 
                    keyBuf, command.getExpiration().get().getExpirationTimeInSeconds(), valueBuf);
            return m.map(v -> new BooleanResponse<>(command, v));
        });
    }

    private static final RedisCommand PSETEX = new RedisCommand("PSETEX");
    
    @Override
    public Flux> pSetEX(Publisher commands) {
        return execute(commands, command -> {

            Assert.notNull(command.getKey(), "Key must not be null!");
            Assert.notNull(command.getValue(), "Value must not be null!");

            if (!command.getExpiration().isPresent()) {
                throw new IllegalArgumentException("Expiration must not be null!");
            }

            byte[] keyBuf = toByteArray(command.getKey());
            byte[] valueBuf = toByteArray(command.getValue());
            
            Mono m = write(keyBuf, StringCodec.INSTANCE, PSETEX, 
                    keyBuf, command.getExpiration().get().getExpirationTimeInMilliseconds(), valueBuf);
            return m.map(v -> new BooleanResponse<>(command, true));
        });
    }

    private static final RedisCommand MSET = new RedisCommand("MSET", new BooleanReplayConvertor());
    
    @Override
    public Flux> mSet(Publisher commands) {
        return execute(commands, command -> {

            Assert.notNull(command.getKeyValuePairs(), "KeyValuePairs must not be null!");

            List params = convert(command);
            
            Mono m = write(params.get(0), StringCodec.INSTANCE, MSET, params.toArray());
            return m.map(v -> new BooleanResponse<>(command, v));
        });
    }

    protected List convert(MSetCommand command) {
        List params = new ArrayList(command.getKeyValuePairs().size());
        command.getKeyValuePairs().entrySet().forEach(e -> {
            byte[] keyBuf = toByteArray(e.getKey());
            byte[] valueBuf = toByteArray(e.getValue());
            params.add(keyBuf);
            params.add(valueBuf);
        });
        return params;
    }

    @Override
    public Flux> mSetNX(Publisher source) {
        return execute(source, command -> {

            Assert.notNull(command.getKeyValuePairs(), "KeyValuePairs must not be null!");

            List params = convert(command);
            
            Mono m = write(params.get(0), StringCodec.INSTANCE, RedisCommands.MSETNX, params.toArray());
            return m.map(v -> new BooleanResponse<>(command, v));
        });
    }

    private static final RedisStrictCommand APPEND = new RedisStrictCommand("APPEND");
    
    @Override
    public Flux> append(Publisher commands) {
        return execute(commands, command -> {

            Assert.notNull(command.getKey(), "Key must not be null!");
            Assert.notNull(command.getValue(), "Value must not be null!");

            byte[] keyBuf = toByteArray(command.getKey());
            byte[] valueBuf = toByteArray(command.getValue());
            
            Mono m = write(keyBuf, StringCodec.INSTANCE, APPEND, keyBuf, valueBuf);
            return m.map(v -> new NumericResponse<>(command, v));
        });
    }

    private static final RedisCommand GETRANGE = new RedisCommand("GETRANGE");
    
    @Override
    public Flux> getRange(Publisher commands) {
        return execute(commands, command -> {

            Assert.notNull(command.getKey(), "Key must not be null!");
            Assert.notNull(command.getRange(), "Range must not be null!");

            byte[] keyBuf = toByteArray(command.getKey());
            Mono m = read(keyBuf, ByteArrayCodec.INSTANCE, GETRANGE, 
                    keyBuf, command.getRange().getLowerBound().getValue().orElse(0L), 
                            command.getRange().getUpperBound().getValue().orElse(-1L));
            return m.map(v -> new ByteBufferResponse<>(command, ByteBuffer.wrap(v)));
        });
    }

    private static final RedisCommand SETRANGE = new RedisCommand("SETRANGE");
    
    @Override
    public Flux> setRange(Publisher commands) {
        return execute(commands, command -> {

            Assert.notNull(command.getKey(), "Key must not be null!");
            Assert.notNull(command.getValue(), "Value must not be null!");
            Assert.notNull(command.getOffset(), "Offset must not be null!");

            byte[] keyBuf = toByteArray(command.getKey());
            byte[] valueBuf = toByteArray(command.getValue());
            Mono m = write(keyBuf, StringCodec.INSTANCE, SETRANGE, keyBuf, command.getOffset(), valueBuf);
            return m.map(v -> new NumericResponse<>(command, v));
        });
    }

    @Override
    public Flux> getBit(Publisher commands) {
        return execute(commands, command -> {

            Assert.notNull(command.getKey(), "Key must not be null!");
            Assert.notNull(command.getOffset(), "Offset must not be null!");

            byte[] keyBuf = toByteArray(command.getKey());
            Mono m = read(keyBuf, StringCodec.INSTANCE, RedisCommands.GETBIT, keyBuf, command.getOffset());
            return m.map(v -> new BooleanResponse<>(command, v));
        });
    }

    @Override
    public Flux> setBit(Publisher commands) {
        return execute(commands, command -> {

            Assert.notNull(command.getKey(), "Key must not be null!");
            Assert.notNull(command.getOffset(), "Offset must not be null!");

            byte[] keyBuf = toByteArray(command.getKey());
            Mono m = write(keyBuf, StringCodec.INSTANCE, RedisCommands.SETBIT, keyBuf, command.getOffset(), command.getValue() ? 1 : 0);
            return m.map(v -> new BooleanResponse<>(command, v));
        });
    }

    @Override
    
    public Flux> bitCount(Publisher commands) {
        return execute(commands, command -> {

            Assert.notNull(command.getKey(), "Key must not be null!");

            Range range = command.getRange();
            if (range == null) {
                range = Range.unbounded();
            }
            
            byte[] keyBuf = toByteArray(command.getKey());
            Mono m;
            if (range == Range.unbounded()) {
                m = write(keyBuf, StringCodec.INSTANCE, RedisCommands.BITCOUNT, keyBuf); 
            } else {
                m = write(keyBuf, StringCodec.INSTANCE, RedisCommands.BITCOUNT, 
                        keyBuf, range.getLowerBound().getValue().orElse(0L), 
                        range.getUpperBound().getValue().get());
            }
            return m.map(v -> new NumericResponse<>(command, v));
        });
    }

    @Override
    public Flux> bitField(Publisher commands) {
        return null;
    }

    private static final RedisStrictCommand BITOP = new RedisStrictCommand("BITOP");
    
    @Override
    public Flux> bitOp(Publisher commands) {
        return execute(commands, command -> {

            Assert.notNull(command.getDestinationKey(), "DestinationKey must not be null!");
            Assert.notEmpty(command.getKeys(), "Keys must not be null or empty");
            
            if (command.getBitOp() == BitOperation.NOT && command.getKeys().size() > 1) {
                throw new UnsupportedOperationException("NOT operation doesn't support more than single source key");
            }

            List params = new ArrayList(command.getKeys().size() + 2);
            params.add(command.getBitOp());
            params.add(toByteArray(command.getDestinationKey()));
            params.addAll(command.getKeys().stream().map(v -> toByteArray(v)).collect(Collectors.toList()));

            Mono m = write(toByteArray(command.getDestinationKey()), StringCodec.INSTANCE, BITOP, params.toArray());
            return m.map(v -> new NumericResponse<>(command, v));
        });
    }
    
    private static final RedisStrictCommand BITPOS = new RedisStrictCommand("BITPOS");

    @Override
    public Flux> bitPos(Publisher commands) {
        return execute(commands, command -> {

            List params = new ArrayList<>();
            params.add(toByteArray(command.getKey()));
            params.add(command.getBit() ? 1 : 0);
            
            if (command.getRange() != null) {
                if (command.getRange().getLowerBound().getValue().isPresent()) {
                    params.add(command.getRange().getLowerBound().getValue().get());
                }
                if (command.getRange().getUpperBound().getValue().isPresent()) {
                    if (!command.getRange().getLowerBound().getValue().isPresent()) {
                        throw new IllegalArgumentException("LowerBound must not be null");
                    }
                    params.add(command.getRange().getUpperBound().getValue().get());
                }
            }

            Mono m = read((byte[])params.get(0), StringCodec.INSTANCE, BITPOS, params.toArray());
            return m.map(v -> new NumericResponse<>(command, v));
        });
    }

    @Override
    public Flux> strLen(Publisher keys) {
        return execute(keys, command -> {

            Assert.notNull(command.getKey(), "Key must not be null!");

            byte[] keyBuf = toByteArray(command.getKey());
            Mono m = read(keyBuf, StringCodec.INSTANCE, RedisCommands.STRLEN, keyBuf);
            return m.map(v -> new NumericResponse<>(command, v));
        });
    }

}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy