Spring Boot中使用Redis

目录

1.依赖

2.依赖关系

3.配置

4.RedisTemplate

5.基础操作

6.事务

---

1.依赖

maven依赖如下，需要说明的是，spring-boot-starter-data-redis里默认是使用lettuce作为redis客户端的驱动，但是lettuce其实用的比较少，我们常用的还是jedis作为客户端的驱动，所以这里排除掉lettuce，引入jedis：

    org.springframework.boot
    spring-boot-starter-data-redis
    
        
            io.lettuce
            lettuce-core
        
    



    redis.clients
    jedis

2.依赖关系

spring data redis中依赖的关系：

这个依赖关系想表达的是，Spring 是通过 RedisConnection操作Redis的，RedisConnection 则对原生的 Jedis 行封装。要获取RedisConnection接口对象是通过RedisConnectionFactory 生成的 。

3.配置

配置文件进行配置：

# Redis 连接配置
# 单机 Redis
spring.redis.host=127.0.0.1
spring.redis.port=6379
# 连接池配置
spring.redis.jedis.pool.max-idle=30
spring.redis.jedis.pool.max-total=50
spring.redis.jedis.pool.max-wait=2000ms

代码进行配置：

@Configuration
public class RedisConfig {
    private RedisConnectionFactory connectionFactory = null;

    @Bean
    public RedisConnectionFactory initRedisConnectionFactory(){
        if(connectionFactory!=null){
            return connectionFactory;
        }
        JedisPoolConfig poolConfig =new JedisPoolConfig();
        //最大空闲数
        poolConfig.setMaxIdle(30);
        //最大连接数
        poolConfig.setMaxTotal(50);
        //最大等待毫秒数
        poolConfig.setMaxWaitMillis(2000);
        //创建Jedis连接工厂
        JedisConnectionFactory connectionFactory=new JedisConnectionFactory(poolConfig);
        //获取单机的redis配置，如果是集群的话用集群配置类
        RedisStandaloneConfiguration rscfg=connectionFactory.getStandaloneConfiguration();
        connectionFactory.setHostName("127.0.0.1");
        connectionFactory.setPort(6379);
        return connectionFactory;
    }
}

4.RedisTemplate

这里要说明的是如果是直接使用RedisConnection来操作redis就需要我们手动去找RedisConnectionFactory拿RedisConnection，并且需要每次手动关闭RedisConnection。所以Spring Data Redis里面提供了RedisTemplate来方便操作，其封装自jedis，屏蔽了资源获取和释放的步骤。

使用RedisTemplate的时候要注意的核心是它的序列化器，RedisTemplate有多种序列化器，不同的序列化器在键值写入、读出redis的过程中使用的序列化方式会不同，序列化出来的结果也会不同。比如处理字符就需要用字符串专用的序列化器、处理对象需要使用对象专用的序列化器。

目前有的序列化器如下：

StringRedisSerializer：

StringRedisSerializer 是 RedisTemplate 默认使用的 Key 和 Value 的序列化器，它将字符串序列化为字节数组，使用 UTF-8 编码。由于 Redis 中 Key 和 Value 都是字符串，因此默认的 StringRedisSerializer 序列化器已经可以满足大部分情况的需要。

Jackson2JsonRedisSerializer：

Jackson2JsonRedisSerializer 是一个基于 Jackson 的 Redis Key 和 Value 的序列化器，它可以将对象序列化为 JSON 格式的字符串，并存储到 Redis 中。使用 Jackson2JsonRedisSerializer 序列化器需要添加 Jackson 的依赖，可以将对象转换为 JSON 格式的字符串，也可以将 JSON 格式的字符串转换为对象。

JdkSerializationRedisSerializer：

JdkSerializationRedisSerializer 是一种基于 Java 自带的序列化方式的序列化器，它可以将对象序列化为字节数组进行存储。虽然 JdkSerializationRedisSerializer 简单易用，但是它的效率比较低，序列化后的字节数组也比较大，不适合存储大量的数据。

GenericJackson2JsonRedisSerializer：

GenericJackson2JsonRedisSerializer 是一个支持泛型的 Jackson2JsonRedisSerializer，它可以序列化任意类型的对象，并将对象序列化为 JSON 格式的字符串。它在序列化和反序列化时都需要指定目标类型。

OxmSerializer：

OxmSerializer 是一种基于 Spring 的 O/X 映射框架的序列化器，它支持将对象序列化为 XML 格式的字符串。虽然 OxmSerializer 灵活性较高，但是序列化和反序列化的性能比较低，不适合存储大量的数据。

总之，在选择序列化器时需要根据实际情况进行选择，根据数据类型和性能要求选择合适的序列化器。

使用的时候直接set进去即可，set的时候给了很多生效粒度选择，是对所有redis类型的数据结构都生效，还是对某一类redis的数据结构类型生效：

比如我想使用String序列化器，在全局都生效：

@Bean
public RedisTemplate initRedisTemplate(){
  RedisTemplate redisTemplate = new RedisTemplate<>();
  redisTemplate.setDefaultSerializer(new StringRedisSerializer());
  return redisTemplate;
}

5.基础操作

以下是使用RedisTemplate操作redis基本数据类型的代码示例：

要注意的是@Bean定义RedisTemplate的时候泛型要和使用时的泛型对齐。

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class RedisService {

    @Autowired
    private RedisTemplate redisTemplate;
    
    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    public void setString(String key, String value) {
        stringRedisTemplate.opsForValue().set(key, value);
    }

    public String getString(String key) {
        return stringRedisTemplate.opsForValue().get(key);
    }

    public void setHash(String key, String hashKey, Object value) {
        HashOperations hashOps = redisTemplate.opsForHash();
        hashOps.put(key, hashKey, value);
    }

    public Object getHash(String key, String hashKey) {
        HashOperations hashOps = redisTemplate.opsForHash();
        return hashOps.get(key, hashKey);
    }

    public void setList(String key, Object value) {
        ListOperations listOps = redisTemplate.opsForList();
        listOps.rightPush(key, value);
    }

    public Object getList(String key, long index) {
        ListOperations listOps = redisTemplate.opsForList();
        return listOps.index(key, index);
    }

    public void setSet(String key, Object value) {
        SetOperations setOps = redisTemplate.opsForSet();
        setOps.add(key, value);
    }

    public Object getSet(String key) {
        SetOperations setOps = redisTemplate.opsForSet();
        return setOps.members(key);
    }

    public void setZSet(String key, Object value, double score) {
        ZSetOperations zsetOps = redisTemplate.opsForZSet();
        zsetOps.add(key, value, score);
    }

    public Object getZSet(String key, long start, long end) {
        ZSetOperations zsetOps = redisTemplate.opsForZSet();
        return zsetOps.range(key, start, end);
    }

}

6.事务

以下是使用事务的代码示例：

@Autowired
private RedisTemplate redisTemplate;

public void transactionalOperation() {
    // 开启 Redis 事务
    redisTemplate.multi();

    try {
        // 执行多个 Redis 命令
        redisTemplate.opsForValue().set("key1", "value1");
        redisTemplate.opsForValue().set("key2", "value2");

        // 提交事务
        redisTemplate.exec();
    } catch (Exception e) {
        // 回滚事务
        redisTemplate.discard();
    }
}