SpringData的ReactiveRedisTemplate简单使用教程

一、导入依赖

<!--导入ReactiveRedisTemplate的依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
</dependency>

<!--项目使用响应式编程webflux编写，所以导入webflux依赖-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

二、在yml配置文件中设置redis

spring:
  redis:
    host: 10.9.48.190 #redis的ip地址
    port: 6379 #redis的端口号
    password: dc3 #redis的密码

三、编写序列化配置文件

import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import org.springframework.stereotype.Component;

@Component
public class MyRedisSerializationContext implements RedisSerializationContext {
    private StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
    private GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();

    //设置key的序列化方式
    @Override
    public SerializationPair getKeySerializationPair() {
        return SerializationPair.fromSerializer(stringRedisSerializer);
    }

    //设置value的序列化方式
    @Override
    public SerializationPair getValueSerializationPair() {
        return SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer);
    }

    //设置hashkey的序列化方式
    @Override
    public SerializationPair getHashKeySerializationPair() {
        return SerializationPair.fromSerializer(stringRedisSerializer);
    }

    //设置hashvalue的序列化方式
    @Override
    public SerializationPair getHashValueSerializationPair() {
        return SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer);
    }

    //设置spring字符串的序列化方式
    @Override
    public SerializationPair<String> getStringSerializationPair() {
        return SerializationPair.fromSerializer(stringRedisSerializer);
    }
}

四、穿件创建模板对象，使用自定义的序列化方式

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.ReactiveRedisConnectionFactory;
import org.springframework.data.redis.core.ReactiveRedisTemplate;

@Configuration
public class RedisConfig {
    /**
     * 创建模板对象，使用自定义的序列化方式
     * @param factory
     * @param context 我们手动指定的序列化方式
     * @return
     */
    @Bean
    public ReactiveRedisTemplate reactiveRedisTemplate(ReactiveRedisConnectionFactory factory,MyRedisSerializationContext context){
        return new ReactiveRedisTemplate(factory, context);
    }
}

五、使用ReactiveRedisTemplate操作redis数据库

ReactiveRedisTemplate类下的几乎都是使用redisTemplate.opsForxxx().xxx();进行使用，可以根据意思进行判断方法的使用方式。

import com.baidu.cache.service.CacheService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ReactiveRedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.Assert;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.time.Duration;
import java.time.temporal.ChronoUnit;
import java.util.Map;
import java.util.stream.Collectors;

@Service
public class CacheServiceImpl implements CacheService {

    private ReactiveRedisTemplate redisTemplate;

    @Autowired
    public void setRedisTemplate(ReactiveRedisTemplate reactiveRedisTemplate) {
        this.redisTemplate = reactiveRedisTemplate;
    }

    @Override
    public void setValue(String key, Object value) {
        //存储key-value数据
        redisTemplate.opsForValue().set(key, value).subscribe();
    }

    @Override
    public Mono<String> getValue(String key) {
        //根据key查询value
        return redisTemplate.opsForValue().get(key);
    }

    @Override
    public void setValueWithExp(String key, String value, Long expireTime) {
        Assert.isTrue(expireTime!=null&&expireTime>0,()->{
            throw new RuntimeException("时间不能小于0");
        });
        //存储key-value数据，并设置时间，单位秒
        redisTemplate.opsForValue().set(key,value, Duration.of(expireTime, ChronoUnit.SECONDS)).subscribe();
    }

    @Override
    public void setValueWithPExp(String key, String value, Long pExpireTime) {
        Assert.isTrue(pExpireTime!=null&&pExpireTime>0,()->{
            throw new RuntimeException("时间不能小于0");
        });
        //存储key-value数据，并设置时间，单位毫秒
        redisTemplate.opsForValue().set(key,value, Duration.of(pExpireTime, ChronoUnit.MILLIS)).subscribe();

    }

    @Override
    public Mono<Long> incrementBy(String key, long delta) {
        //根据key设置value+delta
        return redisTemplate.opsForValue().increment(key,delta);
    }

    @Override
    public Mono<Boolean> setNx(String key, String value) {
        Assert.hasText(key,()->{
            throw new RuntimeException("key不能为空");
        });
        //如果key-value存在则添加
        return redisTemplate.opsForValue().setIfAbsent(key, value);
    }

    @Override
    public Mono<Boolean> hSet(String key, String field, Object value) {
        //TODO 断言判断数据不能为空
		//添加hash-map的数据
        return redisTemplate.opsForHash().put(key, field, value);
    }

    @Override
    public Mono<Boolean> hMset(String key, Map data) {
        return redisTemplate.opsForHash().putAll(key, data);
    }

    @Override
    public Mono<String> hGet(String key, String field) {
        return redisTemplate.opsForHash().get(key, field);
    }

    @Override
    public Mono<Map> hGetAll(String key) {
        //获取数据
        Flux<Map.Entry<String,String>> entries = redisTemplate.opsForHash().entries(key);
        //将数据从flux转成mono再返回
        return entries.collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
    }

    @Override
    public Mono<Boolean> setExp(String key, Long expTime) {
       return redisTemplate.expire(key,Duration.ofMinutes(expTime));
    }
}