Springboot-Redis - 3.Redis连接方式

Redis连接方式

✌RedisConnection 和 RedisConnectionFactory：

好的，我们来详细讨论 RedisConnection 和 RedisConnectionFactory 在Spring Boot中的使用。

✍1. RedisConnectionFactory

作用:

RedisConnectionFactory 用于创建和管理 RedisConnection 实例。在Spring Data Redis中，这是与Redis服务器通信的主要入口点。

使用场景:

• 配置Spring Boot应用程序以连接到Redis。
• 当需要动态地从不同的数据源创建连接时。

优点:

• 抽象了连接创建的过程，使得更换Redis的客户端实现变得简单。
• 管理连接的生命周期，包括连接池。

缺点:

• 限制了对某些客户端特定功能的直接访问。

示例代码:

在Spring Boot项目中，你可以使用Lettuce或Jedis作为Redis客户端。以下是使用Lettuce的配置示例:

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;

@Configuration
public class RedisConfig {

    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        return new LettuceConnectionFactory("localhost", 6379);
    }
}

✍2. RedisConnection

作用:

RedisConnection 提供了直接与Redis进行交互的低级命令绑定。

使用场景:

• 需要执行不常见或特定的Redis命令。
• 当高级API如RedisTemplate不能满足需求时。

优点:

• 提供了对所有Redis命令的直接访问。
• 更灵活，可以用于执行复杂或特定的操作。

缺点:

• 更低级，可能需要更多的代码来执行简单的操作。
• 需要手动管理资源，如关闭连接。

示例代码:

使用 RedisConnectionFactory 获取 RedisConnection 的示例:

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.connection.RedisConnectionFactory;

@Service
public class RedisService {

    @Autowired
    private RedisConnectionFactory redisConnectionFactory;

    public byte[] getRawValue(byte[] key) {
        RedisConnection connection = redisConnectionFactory.getConnection();
        try {
            return connection.get(key);
        } finally {
            connection.close();
        }
    }
}

注意: 在实际项目中，通常推荐使用高级的API如RedisTemplate，除非有特定的需求需要使用RedisConnection。

✌Jedis

✍ 作用：

Jedis 是一个简单、直接的 Redis 客户端，为 Redis 的所有特性提供了全面的支持。

✍ 使用场景：

• 当你需要一个简单、轻量级且快速的客户端时。
• 当你不需要响应式或异步编程支持时。

✍ 优点：

• 轻量级。
• 易于使用。
• 提供了对 Redis 所有特性的支持。

✍ 缺点：

• 不支持响应式或异步编程。
• 单一的连接实例不是线程安全的，通常需要使用连接池来管理多个连接。

✍ 示例代码：

首先，将 Jedis 依赖添加到你的 pom.xml 中：

<dependency>
    <groupId>redis.clientsgroupId>
    <artifactId>jedisartifactId>
dependency>

在 Spring Boot 中使用 Jedis：

@Configuration
public class RedisConfig {

    @Value("${spring.redis.host}")
    private String redisHost;

    @Value("${spring.redis.port}")
    private int redisPort;

    @Bean
    public JedisConnectionFactory jedisConnectionFactory() {
        return new JedisConnectionFactory(new RedisStandaloneConfiguration(redisHost, redisPort));
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(jedisConnectionFactory());
        return template;
    }
}

✌Lettuce

✍ 作用：

Lettuce 是一个基于 Netty 的连接库，支持同步、异步和响应式模式。

✍ 使用场景：

• 当你需要异步或响应式编程支持时。
• 在微服务或高并发应用中，需要高性能和可扩展性时。

✍ 优点：

• 基于 Netty，性能优越。
• 支持同步、异步和响应式模式。
• 单一连接实例是线程安全的。

✍ 缺点：

• 相对于 Jedis，它更重，因为它依赖于 Netty。

✍ 示例代码：

首先，将 Lettuce 依赖添加到你的 pom.xml 中：

<dependency>
    <groupId>io.lettuce.coregroupId>
    <artifactId>lettuce-coreartifactId>
dependency>

在 Spring Boot 中使用 Lettuce：

@Configuration
public class RedisConfig {

    @Value("${spring.redis.host}")
    private String redisHost;

    @Value("${spring.redis.port}")
    private int redisPort;

    @Bean
    public LettuceConnectionFactory lettuceConnectionFactory() {
        return new LettuceConnectionFactory(new RedisStandaloneConfiguration(redisHost, redisPort));
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(lettuceConnectionFactory());
        return template;
    }
}

注意：在默认情况下，如果你在 pom.xml 中包含了 spring-boot-starter-data-redis，Spring Boot 会默认选择 Lettuce 作为客户端库。如果你想使用 Jedis，你需要明确添加 Jedis 的依赖并排除 Lettuce 的依赖。

✌Redis支持读写分离（写主节点，读从节点）

✍作用:

读写分离是一种常见的数据库架构策略，主要用于提高系统的吞吐量和性能。在这种架构中，所有的写操作（例如 INSERT、UPDATE、DELETE）都发送到主（master）节点，而读操作（例如 SELECT）可以分发到一个或多个从（replica）节点。

✍使用场景:

• 当系统的读操作远远多于写操作，从而可能导致主节点成为性能瓶颈时。
• 当需要提高系统的可用性和故障切换能力时。

✍优点:

• 提高系统的读取性能和吞吐量。
• 分散读取压力，避免主节点成为性能瓶颈。
• 提供数据的冗余备份。

✍缺点:

• 增加了系统的复杂性。
• 数据在主节点和从节点之间可能存在短暂的不一致。
• 需要更多的硬件资源。

✍示例代码:

在 Spring Boot 项目中使用 Lettuce 进行读写分离：

1. 添加 Lettuce 依赖：

<dependency>
    <groupId>io.lettuce.coregroupId>
    <artifactId>lettuce-coreartifactId>
    <version>your-lettuce-versionversion>
dependency>

2. 配置 Redis 连接工厂以实现读写分离：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;

@Configuration
public class RedisConfig {

    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder()
                .readFrom(REPLICA_PREFERRED) // 优先从 replica 读取
                .build();

        return new LettuceConnectionFactory(redisStandaloneConfiguration(), clientConfig);
    }
}

在这个示例中，我们使用 Lettuce 的 readFrom 方法配置了读写分离策略，使得读操作优先从 replica 节点获取。

注意: 使用读写分离时，需要确保应用程序可以容忍数据在主节点和从节点之间的短暂不一致。