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

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

    There is a newer version: 3.40.2
    Show newest version
    /**
 * Copyright (c) 2013-2024 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.reactivestreams.Publisher;
import org.redisson.client.codec.ByteArrayCodec;
import org.redisson.client.codec.DoubleCodec;
import org.redisson.client.codec.StringCodec;
import org.redisson.client.protocol.RedisCommand;
import org.redisson.client.protocol.RedisCommands;
import org.redisson.client.protocol.decoder.*;
import org.redisson.reactive.CommandReactiveExecutor;
import org.springframework.data.geo.*;
import org.springframework.data.redis.connection.ReactiveGeoCommands;
import org.springframework.data.redis.connection.ReactiveRedisConnection.CommandResponse;
import org.springframework.data.redis.connection.ReactiveRedisConnection.MultiValueResponse;
import org.springframework.data.redis.connection.ReactiveRedisConnection.NumericResponse;
import org.springframework.data.redis.connection.RedisGeoCommands;
import org.springframework.data.redis.connection.RedisGeoCommands.GeoLocation;
import org.springframework.data.redis.connection.RedisGeoCommands.GeoRadiusCommandArgs;
import org.springframework.util.Assert;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.math.BigDecimal;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 
 * @author Nikita Koksharov
 *
 */
public class RedissonReactiveGeoCommands extends RedissonBaseReactive implements ReactiveGeoCommands {

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

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

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

            byte[] keyBuf = toByteArray(command.getKey());
            
            List args = new ArrayList();
            args.add(keyBuf);
            for (GeoLocation location : command.getGeoLocations()) {
                args.add(location.getPoint().getX());
                args.add(location.getPoint().getY());
                args.add(toByteArray(location.getName()));
            }
            
            Mono m = write(keyBuf, StringCodec.INSTANCE, RedisCommands.GEOADD, args.toArray());
            return m.map(v -> new NumericResponse<>(command, v));
        });
    }

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

            Assert.notNull(command.getKey(), "Key must not be null!");
            Assert.notNull(command.getFrom(), "From member must not be null!");
            Assert.notNull(command.getTo(), "To member must not be null!");

            byte[] keyBuf = toByteArray(command.getKey());
            byte[] fromBuf = toByteArray(command.getFrom());
            byte[] toBuf = toByteArray(command.getTo());
            
            Metric metric = RedisGeoCommands.DistanceUnit.METERS;
            if (command.getMetric().isPresent()) {
                metric = command.getMetric().get();
            }
            
            Mono m = write(keyBuf, DoubleCodec.INSTANCE, new RedisCommand("GEODIST", new DistanceConvertor(metric)), 
                                    keyBuf, fromBuf, toBuf, metric.getAbbreviation());
            return m.map(v -> new CommandResponse<>(command, v));
        });
    }
    
    private static final RedisCommand> GEOHASH = new RedisCommand>("GEOHASH", new ObjectListReplayDecoder());

    @Override
    public Flux> geoHash(Publisher commands) {
        return execute(commands, command -> {
            
            Assert.notNull(command.getKey(), "Key must not be null!");
            Assert.notNull(command.getMembers(), "Members must not be null!");
            
            byte[] keyBuf = toByteArray(command.getKey());
            List args = new ArrayList(command.getMembers().size() + 1);
            args.add(keyBuf);
            args.addAll(command.getMembers().stream().map(buf -> toByteArray(buf)).collect(Collectors.toList()));
            
            Mono> m = read(keyBuf, StringCodec.INSTANCE, GEOHASH, args.toArray());
            return m.map(v -> new MultiValueResponse<>(command, v));
        });
    }

    private final MultiDecoder> geoDecoder = new ListMultiDecoder2(new ObjectListReplayDecoder2(), new PointDecoder());
    
    @Override
    public Flux> geoPos(Publisher commands) {
        return execute(commands, command -> {
            
            Assert.notNull(command.getKey(), "Key must not be null!");
            Assert.notNull(command.getMembers(), "Members must not be null!");
            
            RedisCommand> cmd = new RedisCommand>("GEOPOS", geoDecoder);
            
            byte[] keyBuf = toByteArray(command.getKey());
            List args = new ArrayList(command.getMembers().size() + 1);
            args.add(keyBuf);
            args.addAll(command.getMembers().stream().map(buf -> toByteArray(buf)).collect(Collectors.toList()));
            
            Mono> m = read(keyBuf, StringCodec.INSTANCE, cmd, args.toArray());
            return m.map(v -> new MultiValueResponse<>(command, v));
        });
    }

    private final MultiDecoder>> postitionDecoder = new ListMultiDecoder2(new GeoResultsDecoder(), new CodecDecoder(), new PointDecoder(), new ObjectListReplayDecoder());
    
    @Override
    public Flux>>>> geoRadius(
            Publisher commands) {
        return execute(commands, command -> {

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

            GeoRadiusCommandArgs args = command.getArgs().orElse(GeoRadiusCommandArgs.newGeoRadiusArgs());
            byte[] keyBuf = toByteArray(command.getKey());
            
            List params = new ArrayList();
            params.add(keyBuf);
            params.add(BigDecimal.valueOf(command.getPoint().getX()).toPlainString());
            params.add(BigDecimal.valueOf(command.getPoint().getY()).toPlainString());
            params.add(command.getDistance().getValue());
            params.add(command.getDistance().getMetric().getAbbreviation());
            
            RedisCommand>> cmd;
            if (args.getFlags().contains(GeoRadiusCommandArgs.Flag.WITHCOORD)) {
                cmd = new RedisCommand>>("GEORADIUS_RO", postitionDecoder);
                params.add("WITHCOORD");
            } else {
                MultiDecoder>> distanceDecoder = new ListMultiDecoder2(new ByteBufferGeoResultsDecoder(command.getDistance().getMetric()), new GeoDistanceDecoder());
                cmd = new RedisCommand>>("GEORADIUS_RO", distanceDecoder);
                params.add("WITHDIST");
            }
            
            if (args.getLimit() != null) {
                params.add("COUNT");
                params.add(args.getLimit());
            }
            if (args.getSortDirection() != null) {
                params.add(args.getSortDirection().name());
            }
            
            Mono>> m = read(keyBuf, ByteArrayCodec.INSTANCE, cmd, params.toArray());
            return m.map(v -> new CommandResponse<>(command, Flux.fromIterable(v.getContent())));
        });
    }

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

            Assert.notNull(command.getKey(), "Key must not be null!");
            Assert.notNull(command.getMember(), "Member must not be null!");
            Assert.notNull(command.getDistance(), "Distance must not be null!");
            
            GeoRadiusCommandArgs args = command.getArgs().orElse(GeoRadiusCommandArgs.newGeoRadiusArgs());
            byte[] keyBuf = toByteArray(command.getKey());
            byte[] memberBuf = toByteArray(command.getMember());
            
            List params = new ArrayList();
            params.add(keyBuf);
            params.add(memberBuf);
            params.add(command.getDistance().getValue());
            params.add(command.getDistance().getMetric().getAbbreviation());
            
            RedisCommand>> cmd;
            if (args.getFlags().contains(GeoRadiusCommandArgs.Flag.WITHCOORD)) {
                cmd = new RedisCommand>>("GEORADIUSBYMEMBER_RO", postitionDecoder);
                params.add("WITHCOORD");
            } else {
                MultiDecoder>> distanceDecoder = new ListMultiDecoder2(new ByteBufferGeoResultsDecoder(command.getDistance().getMetric()), new GeoDistanceDecoder());
                cmd = new RedisCommand>>("GEORADIUSBYMEMBER_RO", distanceDecoder);
                params.add("WITHDIST");
            }
            
            if (args.getLimit() != null) {
                params.add("COUNT");
                params.add(args.getLimit());
            }
            if (args.getSortDirection() != null) {
                params.add(args.getSortDirection().name());
            }
            
            Mono>> m = read(keyBuf, ByteArrayCodec.INSTANCE, cmd, params.toArray());
            return m.map(v -> new CommandResponse<>(command, Flux.fromIterable(v.getContent())));
        });
    }

}
    
    
    
    

    




    
    
    © 2015 - 2024 Weber Informatics LLC | Privacy Policy