各位互联网大厂的后端开发精英们，在日常开发中，想必大家都面临过系统性能优化的挑战。当系统数据量逐渐增大、并发请求不断增多时，如何提升系统的响应速度和稳定性，成为了我们必须攻克的难题。而 Redis，这款高性能的内存数据库，以其出色的读写速度和丰富的数据结构，成为了众多后端开发者优化系统的得力助手。今天，咱们就来深入探究一下在 Spring Boot3 中连接 Redis 的那些实用方式 。

背景介绍

在当今互联网业务飞速发展的大环境下，我们开发的系统面临着海量数据和高并发请求的双重挑战。Spring Boot3 作为一款强大的后端开发框架，为我们提供了便捷的开发体验，但单靠其自身功能，在应对复杂业务场景时，仍显不足。Redis 作为一款高性能的内存数据库，以其超快的读写速度、丰富的数据结构和强大的分布式特性，成为了众多互联网大厂优化系统性能的得力助手。将 Spring Boot3 与 Redis 进行整合，能够极大地提升系统的整体性能和稳定性，满足业务快速发展的需求。

Spring Boot3 连接 Redis 的方式

使用 Spring Data Redis 默认配置

依赖引入：在 Spring Boot 项目中，我们首先需要引入spring - boot - starter - data - redis依赖，它为我们操作 Redis 提供了基础支持。在pom.xml文件中添加如下依赖代码：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

添加该依赖后，Spring Boot 会自动为我们配置RedisConnectionFactory、StringRedisTemplate和RedisTemplate实例。

配置文件设置：默认情况下，Spring Boot 会尝试连接本地localhost:6379的 Redis 服务器。若你的 Redis 服务器部署在其他地址，或者有密码等特殊配置，就需要在配置文件（application.properties或application.yml）中进行修改。以application.yml为例，常见配置如下：

spring:
  data:
    redis:
      host: your - redis - host # Redis服务器主机地址
      port: 6379 # Redis服务器端口
      password: your - password # Redis密码，若有
      database: 0 # Redis数据库索引，默认为0

序列化方式：Spring Boot 默认使用
JdkSerializationRedisSerializer进行序列化。但在实际开发中，这种序列化方式可能存在一些问题，比如序列化后的结果可读性差、占用空间较大等。我们可以通过配置RedisTemplate来使用自定义的序列化器，如
Jackson2JsonRedisSerializer，它能将对象序列化为 JSON 格式，更直观且节省空间。配置示例如下：

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(objectMapper);
        redisTemplate.setValueSerializer(serializer);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

使用 Lettuce 客户端

Lettuce 简介：Spring Boot 从 2.x 版本开始，默认使用 Lettuce 作为 Redis 客户端。Lettuce 基于 Netty 框架实现，其连接是线程安全的，并且支持异步、非阻塞的连接操作。在高并发和大规模连接的情况下，Lettuce 能更有效地利用系统资源，性能通常优于传统的 Jedis 客户端。

配置参数：在配置文件中，我们可以对 Lettuce 连接池等相关参数进行配置。同样以application.yml为例：

spring:
  data:
    redis:
      lettuce:
        pool:
          max - active: 100 # 最大活跃连接数，可根据业务并发量调整，默认8，负值表示无限制
          max - idle: 50 # 最大空闲连接数，默认8
          min - idle: 10 # 最小空闲连接数，默认0
          max - wait: 300ms # 连接池最大等待时间，超过该时间抛出异常，默认-1（负值表示无限制）

通过这些参数配置，可以更好地管理 Lettuce 连接池，优化 Redis 连接的使用效率。

操作 Redis：配置完成后，我们就可以通过RedisTemplate或StringRedisTemplate配合 Lettuce 连接工厂来操作 Redis 了。例如，在一个Service类中使用RedisTemplate进行简单的字符串存取操作：

@Service
public class RedisService {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

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

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

使用 Jedis 客户端

依赖引入：若你习惯使用 Jedis 客户端，在 Spring Boot3 项目中也可以引入 Jedis 相关依赖来使用。在pom.xml文件中添加如下依赖：

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

自定义配置：与 Lettuce 不同，使用 Jedis 需要我们自定义配置 Jedis 连接工厂等相关 Bean。配置类示例如下：

@Configuration
public class JedisConfig {
    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.password}")
    private String password;
    @Value("${spring.redis.timeout}")
    private int timeout;

    @Bean
    public JedisConnectionFactory jedisConnectionFactory() {
        JedisConnectionFactory jedisConnectionFactory = new JedisConnectionFactory();
        jedisConnectionFactory.setHostName(host);
        jedisConnectionFactory.setPort(port);
        jedisConnectionFactory.setPassword(password);
        jedisConnectionFactory.setTimeout(timeout);
        return jedisConnectionFactory;
    }

    @Bean
    public RedisTemplate<String, String> redisTemplate(JedisConnectionFactory jedisConnectionFactory) {
        RedisTemplate<String, String> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(jedisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

在上述配置中，我们读取配置文件中的 Redis 连接信息，创建了JedisConnectionFactory和RedisTemplate。

操作 Redis：通过RedisTemplate或StringRedisTemplate结合 Jedis 连接工厂，就可以像使用 Lettuce 客户端一样操作 Redis 了。例如：

@Service
public class JedisRedisService {
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

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

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

使用 Redisson 框架实现分布式锁等功能

Redisson 简介：在分布式系统中，多个服务实例可能同时对共享资源进行操作，这就容易引发数据一致性问题。Redisson 框架提供了丰富且强大的分布式锁实现，以及分布式集合、分布式对象等多种分布式相关功能，能很好地解决这些问题。

依赖引入：在项目中引入 Redisson 的依赖，在pom.xml文件中添加如下代码：

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson - spring - boot - starter</artifactId>
    <version>3.16.1</version>
</dependency>

配置 Redisson：在配置文件（application.yml）中进行简单配置：

spring:
  redis:
    redisson:
      config: classpath:redisson.yml

这里假设redisson.yml配置文件已经在classpath路径下，该配置文件中可以详细配置 Redisson 连接 Redis 的各种参数，如单机模式、集群模式等。

使用分布式锁示例：通过RedissonClient获取锁对象来实现分布式锁。例如，在一个库存扣减的场景中：

@Service
public class StockService {
    @Autowired
    private RedissonClient redissonClient;

    public void deductStock(String productId, int quantity) {
        RLock lock = redissonClient.getLock("product:" + productId + ":stock:lock");
        try {
            boolean isLocked = lock.tryLock(10, TimeUnit.SECONDS);
            if (isLocked) {
                // 查询库存
                int stock = getStock(productId);
                if (stock >= quantity) {
                    // 扣减库存
                    updateStock(productId, stock - quantity);
                } else {
                    throw new RuntimeException("库存不足");
                }
            } else {
                throw new RuntimeException("获取锁失败");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("获取锁过程中发生中断");
        } finally {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }

    private int getStock(String productId) {
        // 这里模拟从数据库或其他存储中查询库存
        return 100;
    }

    private void updateStock(String productId, int stock) {
        // 这里模拟更新库存到数据库或其他存储
    }
}

在上述代码中，我们通过RedissonClient获取了一个分布式锁，在获取锁成功后进行库存扣减操作，操作完成后释放锁，从而保证了在分布式环境下库存扣减操作的原子性和数据一致性。

不同连接方式的对比与选择

（一）性能对比

1. Lettuce：由于其基于 Netty 的异步、非阻塞特性，在高并发场景下，Lettuce 能充分利用系统资源，减少线程上下文切换开销，性能表现出色。尤其是在需要处理大量并发连接或异步操作的场景中，Lettuce 的优势更为明显。
2. Jedis：Jedis 基于传统的阻塞 I/O（BIO），每个操作都是同步的，在单线程环境中表现良好。但在多线程高并发场景下，由于每个操作都会阻塞当前线程，可能导致性能瓶颈。不过，如果项目并发量较低，且对线程安全性要求不高，Jedis 也是一个简单易用的选择。
3. Spring Data Redis 默认配置：默认使用 Lettuce 客户端，性能上与 Lettuce 基本一致。但由于其自动配置的特性，在一些定制化需求较高的场景下，可能需要进一步调整配置以满足性能要求。
4. Redisson 框架：Redisson 在实现分布式锁等功能时，会引入一定的网络开销和锁竞争开销。但其通过优化的分布式算法和高效的网络通信，在合理的并发量下，仍能保证较好的性能。不过，相比直接操作 Redis 进行简单的数据存取，使用 Redisson 实现复杂功能时性能会略有下降。

（二）功能特性对比

1. Lettuce：除了基本的 Redis 连接和操作功能外，Lettuce 还支持异步操作、响应式编程，并且对集群、Sentinel 等 Redis 高级特性有良好的支持，功能较为全面。
2. Jedis：Jedis 功能相对较为基础，主要侧重于提供对 Redis 的基本操作接口。虽然也能通过一些扩展实现集群等功能，但在功能丰富度上略逊于 Lettuce。
3. Spring Data Redis 默认配置：提供了一套基于 Spring 框架的 Redis 操作抽象，方便在 Spring 项目中使用 Redis。除了基本的缓存、数据存储等功能外，还支持 Spring 的缓存注解等特性，与 Spring 生态系统集成度高。
4. Redisson 框架：专注于解决分布式系统中的各种问题，如分布式锁、分布式集合、分布式对象等。其提供的功能在分布式场景下非常实用，但对于简单的单机 Redis 操作，可能显得过于复杂。

（三）适用场景选择

1. 高并发读写场景：如果项目面临高并发读写的挑战，且对性能要求极高，建议优先选择 Lettuce 客户端或 Spring Data Redis 默认配置（默认使用 Lettuce）。它们能在高并发下充分发挥 Redis 的性能优势，提升系统整体响应速度。
2. 简单项目或低并发场景：对于一些简单的项目，并发量较低，且对功能特性要求不高的场景，Jedis 客户端是一个不错的选择。其简单易用，配置相对较少，能快速实现 Redis 的基本操作。
3. 分布式系统场景：当项目涉及分布式系统，需要解决分布式锁、分布式数据一致性等问题时，Redisson 框架无疑是最佳选择。它提供的丰富分布式功能，能有效保障分布式系统的稳定性和数据一致性。
4. 与 Spring 生态紧密结合场景：若项目基于 Spring 框架开发，且希望充分利用 Spring 的各种特性，如缓存注解、事务管理等，Spring Data Redis 默认配置是最合适的。它能无缝集成到 Spring 项目中，方便开发和维护。

总结

在 Spring Boot3 项目中连接 Redis 有多种实用方式，每种方式都有其特点和适用场景。通过合理选择连接方式，并进行适当的配置和优化，我们能够充分发挥 Redis 的强大功能，提升系统的性能和稳定性。希望本文介绍的内容能对各位互联网大厂的后端开发人员在实际项目中有所帮助，让我们一起打造更高效、更强大的后端系统 。