一、导入 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 他们三有啥不可告人的关系了吧！

Spring 整合 Redis 的三个简单步骤

一、导入 Redis 依赖

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

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

3、导入连接池 jar 包依赖

二、编写 Redis 配置类

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

2、JedisPoolConfig 类—配置连接池

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

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

5、JedisConnectionFactory 类—Jedis 连接工厂

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

7、K,V 序列化设置

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

三、JedisPool 的使用

相关文章

糖果(差分约束+找最小值)

区块链技术相关概述

WebDAV之葫芦儿·派盘+MiXplorer

SSH免密登录配置

ucos3+emwin+appwizard控制硬件LED

Docker容器管理常用

从零开始学习Redis

离散数学与组合数学-02二元关系

Swift（1）

CadSoftTools Web CAD SDK 14.1.0.51184 Crack

克里金法学习笔记

Android so库开发——使用addr2line查看so异常信息（四）

时序数据库TDengine建模思路

纯 CSS3 卡通小火车行驶动画

二叉树21：合并二叉树

Vuex状态管理

微信小程序wxss相关介绍、全局配置和tabbar知识以及发送数据请求(post,get)

数据探索性分析(EDA)——不平衡样本处理

【4】k8s_NameSpacePod

案例分享|方形锂电池铝壳外观缺陷检测