Spring 整合 Redis 的三个简单步骤

魔道不误砍柴功

已于 2023-01-13 16:33:44 修改

阅读量2.3k

点赞数 4

分类专栏： Java基础 Redis 文章标签： redis java

于 2023-01-13 16:21:48 首次发布

本文链接：https://blog.csdn.net/qq_35971258/article/details/128665821

版权

Java基础同时被 2 个专栏收录

69 篇文章 2 订阅

订阅专栏

Redis

13 篇文章 1 订阅

订阅专栏

一、导入 Redis 依赖

1、导入 Redis 客户端 jar 包依赖

导入 jar 包是需要注意，Redis 是属于 CS 架构模式，服务端需先启动，然后客户端主动去连它。但是客户端怎么去连接服务端呢？这里有两种方式：一种是 Jedis 客户端、另一种是 Lettuce 客户端可以和 Redis 服务器通信。所以这里就需要导入客户端的 jar 包依赖。

提示：Jedis、Lettuce 都是 Redis 的 Java 客户端，通过它可以对 Redis 服务端进行操作。这个就是 Redis、和 Jedis 之间的亲密关系。Redis 目前不能离开这两个客户端。

以下两个客户端连接器依赖导入一个即可（就看你要使用哪种客户端操作 Redis 服务端）：

提示：SpringBoot 默认使用的 Lettuce 客户端操作 Redis、连接池用的是 commons-pool2

Jedis 客户端依赖包如下：

	<dependency>
	    <groupId>redis.clients</groupId>
	    <artifactId>jedis</artifactId>
	    <version>3.3.0.RELEASE</version>
	</dependency>

Lettuce 客户端依赖包如下：

	<dependency>
	   	<groupId>io.lettuce</groupId>
	   	<artifactId>lettuce-core</artifactId>
	   	<version>5.3.0.RELEASE</version>
	</dependency>

2、导入 Spring 封装简单 API 的 jar 包依赖

但是直接使用上述客户端操作还是不太方便，所以 Spring 就对其进行封装，封装成更简单的 API 方便开发用，所以这里还需要导入封装 API 所在的 jar 包依赖。

导入 Spring 封装 Redis 客户端 API 的 jar 包如下：

	<dependency>
	   <groupId>org.springframework.data</groupId>
	   <artifactId>spring-data-redis</artifactId>
	   <version>2.3.0.RELEASE</version>
	</dependency>

3、导入连接池 jar 包依赖

另外还需要导入一个连接池的 jar 包依赖。如果不导入连接池，上面每次连接都需要重新创建连接对象，这样生成和释放连接太浪费时间，所以一般都会搭配连接池，提高性能。

导入连接池 jar 包依赖，可以看到是 apache 提供的连接池，而且还是 pool2，性能杠杠的。

   <dependency>
      <groupId>org.apache.commons</groupId>
      <artifactId>commons-pool2</artifactId>
      <version>2.8.0</version>
    </dependency>

总结以上需要 3 个 jar 包依赖，客户端 jar 包依赖、Spring API jar 包依赖、连接池 jar 包依赖。完整 maven 如下：

	<dependency>
	     <groupId>redis.clients</groupId>
	     <artifactId>jedis</artifactId>
	     <version>3.3.0.RELEASE</version>
	</dependency>
	
	<dependency>
	   <groupId>org.springframework.data</groupId>
	   <artifactId>spring-data-redis</artifactId>
	   <version>2.3.0.RELEASE</version>
	 </dependency>
	 
	<dependency>
	   <groupId>org.apache.commons</groupId>
	   <artifactId>commons-pool2</artifactId>
	   <version>2.8.0</version>
	</dependency>

gradle 配置如下：

dependencies {
	compile group: 'org.springframework.data', name: 'spring-data-redis', version: '2.3.0.RELEASE'
    compile group: 'redis.clients', name: 'jedis', version: '3.3.0'
    compile group: 'io.lettuce', name: 'lettuce-core', version: '5.3.0.RELEASE'
}

以上版本都是参照官方文档，不会爆 java.lang.NoClassDefFoundError: org/springframework/data/geo/Metric 版本异常。Spring-Data-Redis 官方文档点击链接 https://docs.spring.io/spring-data/redis/docs/2.3.0.RELEASE/reference/html/#reference 查看。其他版本的话点击官方 Github 链接https://github.com/redis/jedis/tree/jedis-3.0.1 查看对应版本。

二、编写 Redis 配置类

1、使用 Jedis 作为客户端连接器

JedisConfig 类如下：

@Configuration
public class JedisConfig {

	@Bean
	public RedisTemplate<String,String> restTemplate() {
		// 配置连接池
		JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
		// 最大空闲数
		jedisPoolConfig.setMaxIdle(50);
		// 最大连接数
		jedisPoolConfig.setMaxTotal(100);
		// 最大等待亳秒数
		jedisPoolConfig.setMaxWaitMillis(20000);


		// Redis 连接服务器配置
		RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration();
		redisConfig.setHostName("127.0.0.1");
		redisConfig.setPort(6379);
		redisConfig.setPassword("");
		redisConfig.setDatabase(0);


		// 修改 Redis 的连接器 Jedis 的默认连接池
		JedisClientConfiguration.JedisPoolingClientConfigurationBuilder builder =
				(JedisClientConfiguration.JedisPoolingClientConfigurationBuilder) JedisClientConfiguration.builder();
		JedisClientConfiguration jedisClientConfiguration = builder.poolConfig(jedisPoolConfig).build();


		// 采用 Jedis 作为 Redis 客户端,可用用 JedisConnectionFactory 工厂初始化连接池配置
		JedisConnectionFactory connectionFactory = new JedisConnectionFactory(redisConfig,jedisClientConfiguration);
		// 调用后初始化方法，没有它将抛出异常
		connectionFactory.afterPropertiesSet();

		// 定义 RedisTemplate，并设置连接工程
		RedisTemplate<String,String> redisTemplate = new RedisTemplate<String,String>();
		redisTemplate.setConnectionFactory(connectionFactory);


		// 设置自定 Redis 序列化器
		RedisSerializer<Object> jdkSerializationRedisSerializer = new JdkSerializationRedisSerializer();
		RedisSerializer<String> stringRedisSerializer = new StringRedisSerializer();
		// 默认使用 StringRedisSerializer 作为 K,V 序列化存储
		redisTemplate.setDefaultSerializer(stringRedisSerializer);
		// 对于普通类型 K 使用 StringRedisSerializer 序列化存储
		redisTemplate.setKeySerializer(stringRedisSerializer);
		// 对于普通类型 V 使用 JdkSerializationRedisSerializer 序列化存储(不推荐存储占用空间大)
		redisTemplate.setValueSerializer(jdkSerializationRedisSerializer);
		// 对于 Hash 类型 K 使用 StringRedisSerializer 序列化存储
		redisTemplate.setHashKeySerializer(stringRedisSerializer);
		// 对于 Hash 类型 V 使用 JdkSerializationRedisSerializer 序列化存储(不推荐存储占用空间大)
		redisTemplate.setHashValueSerializer(jdkSerializationRedisSerializer);
		return redisTemplate;
	}
}

主要还是借助 spring-data-redis 包下的 RedisTemplate 来操作 Redis 服务端。这个类是 Spring 对 Jedis、Lettuce 客户端的包装，提供更方便 API。现在对上面代码进行拆分分析。

2、JedisPoolConfig 类—配置连接池

Jedis、Lettuce 都有对应的连接池标准 API ，Jedis 对应的是 JedisPoolConfig、Lettuce 对应的是 GenericObjectPoolConfig 配置类。下面这段是 JedisPoolConfig 连接池的配置。

	// 配置连接池
	JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
	// 最大空闲数
	jedisPoolConfig.setMaxIdle(50);
	// 最大连接数
	jedisPoolConfig.setMaxTotal(100);
	// 最大等待亳秒数
	jedisPoolConfig.setMaxWaitMillis(20000);

连接池配置好之后，现在准备去连接 Redis 服务端，之前代码是通过 JedisConnectionFactory 类来去连接，但是现在这个类提供的 API 都已经过期，如下图示：

在这里插入图片描述

3、RedisStandaloneConfiguration 类—配置 Redis 连接和连接池对象

查看源码现在换成了 RedisStandaloneConfiguration 类。

在这里插入图片描述

4、JedisPoolingClientConfigurationBuilder 内部类—设置连接池对象

但是这个类在设置连接池对象的时候比较麻烦，需要通过一个内部类操作。然后通过调用内部类的 poolConfig() 方法才可以将连接池对象封装到 Jedis 客户端配置中，代码如下：

	// 修改 Redis 的连接器 Jedis 的默认连接池
	JedisClientConfiguration.JedisPoolingClientConfigurationBuilder builder =
			(JedisClientConfiguration.JedisPoolingClientConfigurationBuilder) JedisClientConfiguration.builder();
			
	JedisClientConfiguration jedisClientConfiguration = builder.poolConfig(jedisPoolConfig).build();

5、JedisConnectionFactory 类—Jedis 连接工厂

现在 redisConfig 封装着 Redis 连接服务端的 url 地址，jedisClientConfiguration 封装着客户端连接池信息，将这两个全部交给 JedisConnectionFactory 类。调用 afterPropertiesSet() 方法，就位初始化客户端和连接池。代码如下：

	// 采用 Jedis 作为 Redis 客户端,可用用 JedisConnectionFactory 工厂初始化连接池配置
	JedisConnectionFactory connectionFactory = new JedisConnectionFactory(redisConfig,jedisClientConfiguration);

	// 调用后初始化方法，没有它将抛出异常
	connectionFactory.afterPropertiesSet();

6、RedisTemplate 类—Spring 封装操作 Redis 的工具类

在 RedisTemplate 类中，我们需要将 JedisConnectionFactory 传给它，毕竟它封装的 API 底层都是通过 JedisConnectionFactory 工厂中的 Jedis 客户端操作的。代码如下：

	// 定义 RedisTemplate，并设置连接工程
	RedisTemplate<String,String> redisTemplate = new RedisTemplate<String,String>();
	redisTemplate.setConnectionFactory(connectionFactory);

7、K,V 序列化设置

最后就是设置 K,V 的序列化，序列化算法好的话，可以节省很多存储空间。传统的 JdkSerializationRedisSerializer 序列化不算好，序列化可以借鉴 Google 提供的包。

	// 设置自定 Redis 序列化器
	RedisSerializer<Object> jdkSerializationRedisSerializer = new JdkSerializationRedisSerializer();
	RedisSerializer<String> stringRedisSerializer = new StringRedisSerializer();
	// 默认使用 StringRedisSerializer 作为 K,V 序列化存储
	redisTemplate.setDefaultSerializer(stringRedisSerializer);
	// 对于普通类型 K 使用 StringRedisSerializer 序列化存储
	redisTemplate.setKeySerializer(stringRedisSerializer);
	// 对于普通类型 V 使用 JdkSerializationRedisSerializer 序列化存储(不推荐存储占用空间大)
	redisTemplate.setValueSerializer(jdkSerializationRedisSerializer);
	// 对于 Hash 类型 K 使用 StringRedisSerializer 序列化存储
	redisTemplate.setHashKeySerializer(stringRedisSerializer);
	// 对于 Hash 类型 V 使用 JdkSerializationRedisSerializer 序列化存储(不推荐存储占用空间大)
	redisTemplate.setHashValueSerializer(jdkSerializationRedisSerializer);

上面直接引入那三个 jar 包依赖，然后把 JedisConfig 配置类拷贝到项目中就可以使用。下面用 Lettuce 作为客户端，基本上一模一样，只是换了几个模板类。在这里不过多描述，直接拷贝代码即可。

8、使用 Lettuce 作为客户端连接器

就是将上面的 Jedis 包换成 Lettuce 包就可以，完整的 xml 如下：

    <dependency>
      <groupId>io.lettuce</groupId>
      <artifactId>lettuce-core</artifactId>
      <version>5.3.0.RELEASE</version>
    </dependency>
	
	<dependency>
	   <groupId>org.springframework.data</groupId>
	   <artifactId>spring-data-redis</artifactId>
	   <version>2.3.0.RELEASE</version>
	 </dependency>
	 
	<dependency>
	   <groupId>org.apache.commons</groupId>
	   <artifactId>commons-pool2</artifactId>
	   <version>2.8.0</version>
	</dependency>

然后配置 LettuceConfig 类，代码如下：

@Configuration
public class LettuceConfig {

	@Bean
	public RedisTemplate<String,String> restTemplate() {
		// 配置连接池
		GenericObjectPoolConfig<Object> lettucePoolConfig = new GenericObjectPoolConfig<Object>();
		// 最小空闲数
		lettucePoolConfig.setMinIdle(10);
		// 最大空闲数
		lettucePoolConfig.setMaxIdle(50);
		// 最大连接数
		lettucePoolConfig.setMaxTotal(100);
		// 最大等待时间
		lettucePoolConfig.setMaxWaitMillis(3000);

		// Redis 连接服务器配置
		RedisStandaloneConfiguration redisConnectConfig = new RedisStandaloneConfiguration();
		redisConnectConfig.setHostName("127.0.0.1");
		redisConnectConfig.setPort(6379);
		redisConnectConfig.setPassword("");
		redisConnectConfig.setDatabase(0);

		// 修改 Redis 的连接器 Lettuce 默认连接池
		LettuceClientConfiguration lettucePoolConfiguration = LettucePoolingClientConfiguration.builder()
				.commandTimeout(Duration.ofMillis(5000))
				.poolConfig(lettucePoolConfig)
				.build();

		// 采用 Lettuce 作为 Redis 客户端,可用用 LettuceConnectionFactory 工厂初始化连接池配置
		LettuceConnectionFactory connectionFactory = new LettuceConnectionFactory(redisConnectConfig,lettucePoolConfiguration);

		// 调用后初始化方法，没有它将抛出异常
		connectionFactory.afterPropertiesSet();

		// 定义 RedisTemplate，并设置连接工程
		RedisTemplate<String,String> redisTemplate = new RedisTemplate<String,String>();
		redisTemplate.setConnectionFactory(connectionFactory);

		// 设置自定 Redis 序列化器
		RedisSerializer<Object> jdkSerializationRedisSerializer = new JdkSerializationRedisSerializer();
		RedisSerializer<String> stringRedisSerializer = new StringRedisSerializer();
		// 默认使用 StringRedisSerializer 作为 K,V 序列化存储
		redisTemplate.setDefaultSerializer(stringRedisSerializer);
		// 对于普通类型 K 使用 StringRedisSerializer 序列化存储
		redisTemplate.setKeySerializer(stringRedisSerializer);
		// 对于普通类型 V 使用 JdkSerializationRedisSerializer 序列化存储(不推荐存储占用空间大)
		redisTemplate.setValueSerializer(jdkSerializationRedisSerializer);
		// 对于 Hash 类型 K 使用 StringRedisSerializer 序列化存储
		redisTemplate.setHashKeySerializer(stringRedisSerializer);
		// 对于 Hash 类型 V 使用 JdkSerializationRedisSerializer 序列化存储(不推荐存储占用空间大)
		redisTemplate.setHashValueSerializer(jdkSerializationRedisSerializer);
		return redisTemplate;
	}
}

三、JedisPool 的使用

最后补充一个用法，不使用 Spring 封装的 API RedisTemplate 操作 Redis，通过 JedisPool 直接获取 Jedis 客户端，然后通过 Jedis 向 Redis 服务端发送指令。代码如下：

	JedisPool jedisPool = new JedisPool(poolConfig, "localhost", Integer.parseInt("6379"), 1800);
	Jedis jedisClient = jedisPool.getResource();

看到这里了应该知道 Redis、Jedis、Lettuce 他们三有啥不可告人的关系了吧！

魔道不误砍柴功

关注

4
点赞
踩
13

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring 整合 Redis 的三个简单步骤

导入 jar 包是需要注意，Redis 是属于 CS 架构模式，服务端需先启动，然后客户端主动去连它。但是客户端怎么去连接服务端呢？这里有两种方式：一种是Jedis客户端、另一种是Lettuce客户端可以和 Redis 服务器通信。所以这里就需要导入客户端的 jar 包依赖。提示：Jedis、Lettuce 都是 Redis 的 Java 客户端，通过它可以对 Redis 服务端进行操作。这个就是 Redis、和 Jedis 之间的亲密关系。Redis 目前不能离开这两个客户端。
复制链接

扫一扫