Spring-data-redis 的使用实践

关于

无论是 Jedis 还是 JedisPool，都只是完成对 Redis 操作的极为基础的 API，在不依赖任何中间件的开发环境中，可以使用它们。但是，一般的 Java 开发，都会使用了 Spring 框架，可以使用 spring-data-redis 开源库来简化 Redis 操作的代码逻辑，做到最大程度的业务聚焦。

CRUD 中应用缓存的场景

在普通 CRUD 应用场景中，很多情况下需要同步操作缓存，推荐使用 Spring 的 spring-data-redis 开源库。

• 注：CRUD 是指 Create（创建），Retrieve（查询），Update（更新）和 Delete（删除）。

1. 创建缓存：

   在创建（Create）一个 POJO 实例的时候，对 POJO 实例进行分布式缓存，一般以“缓存前缀+ID”为缓存的 Key 键，POJO 对象为缓存的 Value 值，直接缓存 POJO 的二进制字节。

   • 前提是：POJO 必须可序列化，实现 java.io.Serializable 空接口。如果 POJO 不可序列化，也是可以缓存的，但是必须自己实现序列化的方式，例如使用 JSON 方式序列化。
2. 查询缓存：

   在查询（Retrieve）一个 POJO 实例的时候，首先应该根据 POJO 缓存的 Key 键，从 Redis 缓存中返回结果。

   • 如果不存在，才去查询数据库，并且能够将数据库的结果缓存起来。
3. 更新缓存：

   在更新（Update）一个 POJO 实例的时候，既需要更新数据库的 POJO 数据记录，也需要更新 POJO 的缓存记录。

4. 删除缓存：

   在删除（Delete）一个 POJO 实例的时候，既需要删除数据库的 POJO 数据记录，也需要删除 POJO 的缓存记录。

为了演示 CRUD 场景下 Redis 的缓存操作

首先定义一个简单的 POJO 实体类：聊天系统的用户类。

此类拥有一些简单的属性，例如 uid 和 nickName，且这些属性都具备基本的 getter 和 setter 方法：

package com.crazymakercircle.im.common.bean;
//...
import java.io.Serializable;
@Slf4j
public class User implements Serializable {
	String uid;
	String devId;
	String token;
	String nickName;
	//....省略 getter setter toString等方法
}

然后定义一个完成 CRUD 操作的 Service 接口，定义三个方法：

1. saveUser完成创建（C）、更新操作（U）。
2. getUser完成查询操作（R）。
3. deleteUser完成删除操作（D）。

Service接口的代码如下：

package com.crazymakercircle.redis.springJedis;
import com.crazymakercircle.im.common.bean.User;
public interface UserService {
	/**
	* CRUD 的创建/更新
	* @param user 用户
	*/
	User saveUser(final User user);
    
	/**
	* CRUD 的查询
	* @param id id
	* @return 用户
	*/
	User getUser(long id);
    
	/**
	* CRUD 的删除
	* @param id id
	*/
	void deleteUser(long id);
}

定义完了 Service 接口之后，接下来就是定义 Service 服务的具体实现。不过，这里聚焦的是：如何通过 spring-data-redis 库，使 Service 实现带缓存的功能？

配置 spring-redis.xml

使用 spring-data-redis 库的步骤：

1. 配置依赖：
2. 的第一步是，要在 Maven 的 pom 文件中加上 spring-data-redis 库的依赖，具体如下：

   <dependency>
   	<groupId>org.springframework.data</groupId>
   	<artifactId>spring-data-redis</artifactId>
   	<version>${springboot}</version>
   </dependency>
   

3. 配置：连接池实例、RedisTemplate模板实例；（均为 spring bean）

   这是两个 spring bean，可以配置在项目统一的 spring xml 配置文件中，也可以编写一个独立的 springredis.xml 配置文件。

   （以下采用第二种方式：）

   <!--加载配置文件 -->
   <context:property-placeholder location="classpath:redis.properties"/>
   
   <!--redis 数据源 -->
   <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
   	<!--最大空闲数 -->
   	<property name="maxIdle" value="${redis.maxIdle}"/>
   	<!--最大空连接数 -->
   	<property name="maxTotal" value="${redis.maxTotal}"/>
   	<!--最大等待时间 -->
   	<property name="maxWaitMillis" value="${redis.maxWaitMillis}"/>
   	<!--连接超时的时候是否阻塞，true表示阻塞，直到超过maxWaitMillis, 默认为true -->
   	<property name="blockWhenExhausted" value="${redis.blockWhenExhausted}"/>
   	<!--获取连接时，检测连接是否成功 -->
   	<property name="testOnBorrow" value="${redis.testOnBorrow}"/>
   </bean>
   
   <!-- Spring-redis 连接池管理工厂 -->
   <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
   	<!-- IP地址 -->
   	<property name="hostName" value="${redis.host}"/>
   	<!--端口号 -->
   	<property name="port" value="${redis.port}"/>
   	<!--连接池配置引用 -->
   	<property name="poolConfig" ref="poolConfig"/>
   	<!--usePool：是否使用连接池 -->
   	<property name="usePool" value="true"/>
   </bean>
   
   <!-- redis template definition -->
   <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
   	<property name="connectionFactory" ref="jedisConnectionFactory"/>
   	
   	<property name="keySerializer">
   		<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
   	</property>
   	<property name="valueSerializer">
   		<bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
   	</property>
   	<property name="hashKeySerializer">
   		<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
   	</property>
   	<property name="hashValueSerializer">
   		<bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/>
   	</property>
   	
   	<!--开启事务 -->
   	<property name="enableTransactionSupport" value="true"></property>
   </bean>
   
   <!--将 redisTemplate 封装成通用服务-->
   <bean id="springRedisService" class="com.crazymakercircle.redis.springJedis.CacheOperationService">
   	<property name="redisTemplate" ref="redisTemplate"/>
   </bean>
   
   
   <!-- 省略其他的spring-redis.xml配置，具体参见源代码 -->
   <!-- . . . -->
   

spring-data-redis 库在 JedisPool 提供连接池的基础上封装了自己的连接池—— RedisConnectionFactory 连接工厂；并且 spring-data-redis 封装了一个短期、非线程安全的连接类，名为 RedisConnection 连接类。

RedisConnection 类和 Jedis 库中的 Jedis 类原理一样，提供了与 Redis 客户端命令一对一的 API 函数，用于操作远程 Redis 服务。

在使用 spring-data-redis 时，虽然没有直接用到 Jedis 库，但是 spring-data-redis 库底层对 Redis 服务的操作还是调用 Jedis 库完成的。也就是说，spring-data-redis 库从一定程度上使大家更好地使用 Jedis 库。

RedisConnection 的 API 命令操作的对象都是字节级别的 Key 键和 Value 值。为了更进一步地减少开发的工作，spring-data-redis 库在 RedisConnection 连接类的基础上，针对不同的缓存类型，设计了五大数据类型的命令 API 集合，用于完成不同类型的数据缓存操作，并封装在 RedisTemplate 模板类中。

使用 RedisTemplate 模板 API

RedisTemplate 模板类位于核心包 org.springframework.data.redis.core 中，它封装了五大数据类型的命令 API 集合：

1. ValueOperations：字符串类型操作 API 集合。
2. ListOperations：列表类型操作 API 集合。
3. SetOperations：集合类型操作 API 集合。
4. ZSetOperations：有序集合类型 API 集合。
5. HashOperations：哈希类型操作 API 集合。

• 每一种类型的操作 API 基本上都和每一种类型的Redis客户端命令一一对应。但是在 API 的名称上并不完全一致，RedisTemplate 的 API 名称更加人性化。

  例如，Redis 客户端命令“setNX”——Key-Value不存在才设值，在 RedisTemplate 的 API 名称为“setIfAbsent”。

在代码中，除了基本数据类型的 Redis 操作（如：keys、hasKey）直接使用 redisTemplate 实例完成。其他的 API 命令，都是在不同类型的命令集合类上完成。

RedisTemplate 提供了5个方法，取得不同类型的命令集合，具体为：

1. redisTemplate.opsForValue()：取得 String 类型命令API集合。
2. redisTemplate.opsForList()：取得 List 类型命令API集合。
3. redisTemplate.opsForSet()：取得 Set 类型命令API集合。
4. redisTemplate.opsForHash()：取得 Hash 类型命令API集合。
5. redisTemplate.opsForZSet()：取得 Zset 类型命令API集合。

然后，在不同类型的命令 API 集合上，使用各种数据类型特有的 API 函数，完成具体的 Redis API 操作。

【在实际开发中，为了尽可能地减少第三方库的“入侵”，或者为了在不同的第三方库之间进行方便的切换，一般来说，要对第三方库进行封装。】

示例：

下面将 RedisTemplate 模板类的大部分缓存操作封装成一个自己的缓存操作 Service 服务 —— CacheOperationService，部分源代码节选如下：

package com.crazymakercircle.redis.springJedis;
//...
public class CacheOperationService {
	private RedisTemplateredisTemplate;
	
	public void setRedisTemplate(RedisTemplateredisTemplate) {
		this.redisTemplate = redisTemplate;
	}
	
	
	// --------------RedisTemplate基础操作 --------------------
	/**
	* 取得指定格式的所有的key键
	*
	* @param patens 匹配的表达式
	* @return key 的集合
	*/
	public Set getKeys(Object patens) {
		try {
			return redisTemplate.keys(patens);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
	
	/**
	* 指定缓存失效的时间
	*
	* @param key键
	* @param time 时间(秒)
	* @return
	*/
	public boolean expire(String key, long time) {
		try {
			if (time > 0) {
				redisTemplate.expire(key, time, TimeUnit.SECONDS);
			}
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}
	
	/**
	* 根据key 获取过期的时间
	* @param key 键不能为null
	* @return 时间(秒) 返回0代表为永久有效
	*/
	public long getExpire(String key) {
		return redisTemplate.getExpire(key, TimeUnit.SECONDS);
	}
	
	/**
	* 判断key是否存在
	* @param key 键
	* @return true则存在，false则不存在
	*/
	public boolean hasKey(String key) {
		try {
			return redisTemplate.hasKey(key);
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}
	
	/**
	* 删除缓存
	* @param key 可以传一个值或多个
	* @return 删除的个数
	*/
	public void del(String... key) {
		if (key != null &&key.length> 0) {
			if (key.length == 1) {
				redisTemplate.delete(key[0]);
			} else {
				redisTemplate.delete(CollectionUtils.arrayToList(key));
			}
		}
	}
	
	
	// --------------RedisTemplate操作 String字符串 --------------------
	/**
	* 获取String
	* @param key 键
	* @return 值
	*/
	public Object get(String key) {
		return key == null ? null : redisTemplate.opsForValue().get(key);
	}
	
	/**
	* 设置String
	* @param key 键
	* @param value 值
	* @return true则成功，false则失败
	*/
	public boolean set(String key, Object value) {
		try {
			redisTemplate.opsForValue().set(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}
	
	//...省略其他的String 操作，请参见源代码
	
	
	// --------------RedisTemplate操作list列表 --------------------
	/**
	* 获取list缓存的内容，start == 0 到 end == -1代表所有值
	* @param key 键
	* @param start开始,从0开始
	* @param end结束
	* @return
	*/
	public List<Object> lGet(String key, long start, long end) {
		try {
			return redisTemplate.opsForList().range(key, start, end);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
	
	/**
	* 将list放入缓存，从右边（后端）插入
	* @param key 键
	* @param value 值
	* @return
	*/
	public boolean lSet(String key, Object value) {
		try {
			redisTemplate.opsForList().rightPush(key, value);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}
	
	//...省略其他的list操作，请参见源代码
	
	
	// --------------RedisTemplate操作 Hash列表 --------------------
	/**
	* HashGet，设置map中的一个field
	* @param key 键不能为null
	* @param field项不能为null
	* @return 值
	*/
	public Object hget(String key, String field) {
		return redisTemplate.opsForHash().get(key, field);
	}
	
	/**
	* HashSet
	* @param key 键
	* @param map 对应多个键值
	* @return true 成功 false 失败
	*/
	public boolean hmset(String key, Map<String, Object> map) {
		try {
			redisTemplate.opsForHash().putAll(key, map);
			return true;
		} catch (Exception e) {
			e.printStackTrace();
			return false;
		}
	}
	
	//...省略其他的hash操作，请参见源代码
	
	
	// --------------RedisTemplate操作 Set集合 --------------------
	/**
	* 根据key获取Set中的所有值
	*
	* @param key 键
	* @return
	*/
	public Set<Object> sGet(String key) {
		try {
			return redisTemplate.opsForSet().members(key);
		} catch (Exception e) {
			e.printStackTrace();
			return null;
		}
	}
	
	/**
	* 将数据放入set缓存
	* @param key 键
	* @param values 值可以是多个
	* @return 成功个数
	*/
	public long sSet(String key, Object... values) {
		try {
			return redisTemplate.opsForSet().add(key, values);
		} catch (Exception e) {
			e.printStackTrace();
			return 0;
		}
	}
	
	//...省略其他的Set操作，请参见源代码
}