Redis | 尝试封装一个操作工具类
介绍
本次主要介绍以下内容：
1、SpringMVC集成Redis
2、Spring Boot集成Redis（上）
3、Spring Boot集成Redis（中）
4、Spring Boot集成Redis（下）
5、使用redis为我们提供jar进行封装
6、使用Spring Boot提供的方法进行封装
内容比较多，会花一定的时间进行完善。
第一部分：SpringMVC集成Redis
第一步：依赖
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>${redis.version}</version>
</dependency>
第二步：bean注入
<!-- 引入jedis的properties配置文件 -->
<!--如果你有多个数据源需要通过<context:property-placeholder管理，且不愿意放在一个配置文件里，那么一定要加上ignore-unresolvable=“true"-->
<context:property-placeholder location="classpath:properties/redis.properties" ignore-unresolvable="true" />
<bean id="jedisPool" class="redis.clients.jedis.JedisPool">
<constructor-arg name="poolConfig" ref="jedisPoolConfig" />
<constructor-arg name="host" value="${redis.host}" />
<constructor-arg name="port" value="${redis.port}" type="int" />
<constructor-arg name="timeout" value="${redis.timeout}" type="int" />
<constructor-arg name="password" value="${redis.password}" />
<constructor-arg name="database" value="${redis.database}" type="int" />
</bean>
<bean class="redis.clients.jedis.JedisPoolConfig" id="jedisPoolConfig" />
这样，集成就算告一段落了，什么意思？简单来说，你可以开始编写操作Redis的代码了，所以，我们会放到后面说。
第二部分：Spring Boot集成Redis（上）
这部分主要说，将我们的项目换成Spring Boot，应该怎么操作呢？
有两种操作办法，1、依然通过引入配置文件的办法，简单来说，我们需要写一个配置，加载配置文件。2、也就是下面要说的。
jar还是之前那个。
在 application.yml 中添加如下配置：
# redis
redis:
host:
port: 6379
timeout: 3
password:
poolMaxTotal: 10
poolMaxIdle: 10
poolMaxWait: 3
配置代码：
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
/**
* @author Wenyi Feng
* @since 2018-12-04
*/
@Component
@ConfigurationProperties(prefix = "redis")
@Data
public class RedisConfig {
private String host;
private int port;
private int timeout;// 秒
private String password;
private int poolMaxTotal;
private int poolMaxIdle;
private int poolMaxWait;// 秒
}
构造连接池：
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
/**
* @author Wenyi Feng
* @since 2018-12-04
*/
@Service
public class RedisPoolFactory {
@Autowired
RedisConfig redisConfig;
@Bean
public JedisPool jedisPoolFactory() {
JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
jedisPoolConfig.setMaxIdle(redisConfig.getPoolMaxIdle());
jedisPoolConfig.setMaxTotal(redisConfig.getPoolMaxTotal());
jedisPoolConfig.setMaxWaitMillis(redisConfig.getPoolMaxWait() * 1000);
return new JedisPool(jedisPoolConfig, redisConfig.getHost(), redisConfig.getPort(),
redisConfig.getTimeout() * 1000,
redisConfig.getPassword(), 0);
}
}
第三部分：Spring Boot集成Redis（中）
使用Spring Boot的初衷就是简化我们的配置，那我们该怎么做呢？
第一步：依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
第二步：配置
spring:
redis:
host:
port: 6379
password:
这样就行了。
什么？这样就行了？
没错。
当然，操作代码，我们放到后面说。
第四部分：Spring Boot集成Redis（下）
上面是单台Redis，那么集群应该怎么做呢？如下：
spring:
redis:
host:
port: 6379
password:
cluster:
nodes:
使用英文逗号（,）隔开
第五部分：使用redis为我们提供jar进行封装
首先，要明确，Redis十分强大，所以，也是相当负责。当然你也可以觉得很简单。
我们知道redis是以key-value的形式保存数据的，那么这里就有一个问题，集合对象应该怎么保存呢？
所以，这里提供两种解决思路：一是将其转成String进行保存（这是Spring推荐的）；二是使用byte[]（这是Redis推荐的）。
好了，话不多少，我们开始撸代码。
依赖：
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>${redis.version}</version>
</dependency>
方案1:
/**
* 获取数据
* @param prefix 前缀
* @param key
* @param clazz
* @param <T>
* @return
*/
public <T> T get(KeyPrefix prefix, String key, Class<T> clazz) {
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
// 真正的key
String realKey = prefix.getPrefix() + key;
String str = jedis.get(realKey);
return stringToBean(str, clazz);
} finally {
returnToPool(jedis);
}
}
/**
* 设置对象
* @param prefix 前缀
* @param key
* @param obj
* @param <T>
* @return
*/
public <T> boolean set(KeyPrefix prefix, String key, T obj) {
Jedis jedis = null;
try {
jedis = jedisPool.getResource();
String str = beanToString(obj);
if (StringUtils.isEmpty(str)) {
return false;
}
// 生成真正的key
String realKey = prefix.getPrefix() + key;
int seconds = prefix.expireSeconds();
if (seconds <= 0) {
jedis.set(realKey, str);
} else {
jedis.setex(realKey, seconds, str);
}
return true;
} finally {
returnToPool(jedis);
}
}
方案2:
/**
* 将值存到Redis中
* @param key 唯一标识
* @param value 二进制格式数据
* @return 返回二进制格式数据，表示操作成功，反之，操作失败
*/
public byte[] set(byte[] key, byte[] value) {
Jedis jedis = getResource();
try {
jedis.set(key, value);
return value;
} finally {
jedis.close();
}
}
/**
* 通过一个key获取value
* @param key 唯一标识
* @return 二进制格式数据
*/
public byte[] get(byte[] key) {
Jedis jedis = getResource();
try {
return jedis.get(key);
} finally {
jedis.close();
}
}
方案一和方案二操作是一样的，不同的处理思路不一样，一个将对象转成字符串（启发：JSON），一个是将对象当作数据，进行序列化进行存储和读取。
第六部分：使用Spring Boot提供的方法进行封装
前面你是不是觉得好简单啊，其实我一直也是这么认为的。下面我们看看Spring是如何为我们解读Redis的。
首先我们知道Spring为我们提供了两个东东。
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Autowired
private RedisTemplate redisTemplate;
这下，你也应该明白我 前面说的了吧，Spring居然为String单独写了一个，而代码不足10行。
我们看看RedisTemplate提供了哪些方法。
RedisTemplate method 1
RedisTemplate method 2
RedisTemplate method 3
以上是部分截图。
我们来尝试写一个简单的例子：
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
/**
* @author Wenyi Feng
* @since 2018-12-04
*/
@Service
public class ByteRedisService {
@Resource
private RedisTemplate<byte[], byte[]> redisTemplate;
public void set(byte[] key, byte[] value) {
redisTemplate.opsForValue().set(key, value);
}
public byte[] get(byte[] key) {
return redisTemplate.opsForValue().get(key);
}
}
