6 spring-boot 集成 redis

集成redis，需要：

1、添加Jedis依赖，添加Fastjson依赖

2、添加配置

Fastjson用于将json对象序列化为json字符串，其优点是序列化之后仍然是明文可读的。然后再存入到redis服务器里面。

一、添加依赖，在pom.xml中添加如下代码：

<dependency>
  <groupId>redis.clients</groupId>
  <artifactId>jedis</artifactId>
</dependency>

<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>fastjson</artifactId>
  <version>1.2.38</version>

</dependency>

二、添加配置

在 application.properties中添加如下代码：

redis.host=192.168.8.131
redis.port=6379
redis.timeout=3
redis.password=123456
redis.poolMaxTotal=10
redis.poolMaxIdle=10

redis.poolMaxWait=3

然后，新建包 com.mydre.miaosha.redis，在包中新建类 RedisConfig.java用来存储配置信息。在类中加入如下代码：

package com.mydre.miaosha.redis;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
@Component
@ConfigurationProperties(prefix="redis") //会把配置文件中redis开头的配置都搭建进来。
public class RedisConfig {
private String host;
private int port;
private int timeout;//秒
private String password;
private int poolMaxTotal;
private int poolMaxIdle;
private int poolMaxWait;//秒

然后生成setter，getter方法即可。

github中有关jedis的操作

然后在com.mydre.miaosha.redis包下新建类RedisService：

package com.mydre.miaosha.redis;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.alibaba.fastjson.JSON;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
@Service
public class RedisService {
@Autowired
JedisPool jedisPool;
public <T> T get(String key, Class<T> clazz){
Jedis jedis = null;
try{
jedis = jedisPool.getResource();
String str = jedis.get(key);
T t = stringToBean(str, clazz);
return t;
}finally{
returnToPool(jedis);
}
}
public <T> boolean set(String key, T value){
Jedis jedis = null;
try{
jedis = jedisPool.getResource();
String str = beanToString(value);
if(str == null || str.length() <= 0){
return false;
}
jedis.set(key, str);
return true;
}finally{
returnToPool(jedis);
}
}
private <T> String beanToString(T value) {
if(value == null){
return null;
}
Class<?> clazz = value.getClass();
if(clazz == int.class || clazz == Integer.class){
return "" + value;
}else if(clazz == String.class){
return (String)value;
}else if(clazz == long.class || clazz == Long.class){
return "" + value;
}else{
return JSON.toJSONString(value);
}
}
@SuppressWarnings("unchecked")
private <T> T stringToBean(String str, Class<T> clazz) {
if(str == null || str.length() <= 0 || clazz == null){
return null;
}
if(clazz == int.class || clazz == Integer.class){
return (T)Integer.valueOf(str);
}else if(clazz == String.class){
return (T)str;
}else if(clazz == long.class || clazz == Long.class){
return (T)Long.valueOf(str);
}else{
return JSON.toJavaObject(JSON.parseObject(str), clazz);
}

}
private void returnToPool(Jedis jedis) {
if(jedis != null){
jedis.close();
}

}

}

然后在com.mydre.miaosha.redis包下新建类RedisPoolFactory：

package com.mydre.miaosha.redis;
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;
@Service
public class RedisPoolFactory {
@Autowired
RedisConfig redisConfig;

@Bean
public JedisPool JedisPoolFactory(){
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxIdle(redisConfig.getPoolMaxIdle());
poolConfig.setMaxTotal(redisConfig.getPoolMaxTotal());
poolConfig.setMaxWaitMillis(redisConfig.getPoolMaxWait() * 1000);
JedisPool jp = new JedisPool(poolConfig, redisConfig.getHost(), redisConfig.getPort(),
redisConfig.getTimeout() * 1000, redisConfig.getPassword(), 0);
return jp;
}
}

先在DemoController.java中粗略地添加代码：

@Autowired
RedisService redisService;
@RequestMapping("/redis/get")
@ResponseBody
public Result<Long> redisGet(){
Long v1 = redisService.get("key1", Long.class);
return Result.success(v1);
}
然后访问 http://localhost:8080/redis/get

下面测试一下向redis数据库中存入数据，在DemoController.java中添加如下代码：

@RequestMapping("/redis/set")
@ResponseBody
public Result<String> redisSet(){
boolean ret = redisService.set("key2", "com.imooc");
String str = redisService.get("key2", String.class); //第二个形参是类 类型的变量
return Result.success(str);

}

然后 run as Java Application，在浏览器中输入 http://localhost:8080/demo/redis/set

然后查看centos中的redis数据库，如下：

[root@localhost mk]# redis-cli
127.0.0.1:6379> get key2
(error) NOAUTH Authentication required.
127.0.0.1:6379> auth 123456
OK
127.0.0.1:6379> get key2
"com.imooc"

127.0.0.1:6379> 

可见，redis数据库中已经存入了值。

然后，使用常见的模板模式对 通用缓存key进行封装。

接口只是定义一些契约，抽象类用来实现共通的实现，把一些特殊的实现留给自己的子类。

在 com.mydre.miaosha.redis包下新建接口 KeyPrefix.java ，抽象类 BasePrefix.java ， 实现类 UserKey.java。

接口KeyPrefix.java中代码：

package com.mydre.miaosha.redis;
public interface KeyPrefix {
public int expireSeconds();
public String getPrefix();

}

抽象类 BasePrefix.java中代码：

package com.mydre.miaosha.redis;
public abstract class BasePrefix implements KeyPrefix{
private int expireSeconds;
private String prefix;
public BasePrefix(){}
public BasePrefix(String prefix){//只传入一个参数，永不过期
this(0, prefix);
}
public BasePrefix(int expireSeconds, String prefix){
this.expireSeconds = expireSeconds;
this.prefix = prefix;
}
public int expireSeconds() {//默认0代表永不过期
return this.expireSeconds;
}
public String getPrefix() {
String className = getClass().getSimpleName();
return className + ":" + this.prefix;
}

}

实现类UserKey中代码：

package com.mydre.miaosha.redis;
public class UserKey extends BasePrefix{
private UserKey(String prefix){
super(prefix);
}
public static UserKey getById = new UserKey("id");
public static UserKey getByName = new UserKey("name");

}

修改 DemoController.java中的部分代码如下：

@Autowired
RedisService redisService;
@RequestMapping("/redis/get")
@ResponseBody
public Result<User> redisGet(){
User user = redisService.get(UserKey.getById, "" + 1, User.class);
return Result.success(user);
}

@RequestMapping("/redis/set")
@ResponseBody
public Result<Boolean> redisSet(){
User user = new User();
user.setId(1);
user.setName("1111");
redisService.set(UserKey.getById,"" + 1, user);
return Result.success(true);

}

然后再浏览器中进行访问：http://localhost:8080/demo/redis/set

http://localhost:8080/demo/redis/get

然后，在redis数据库中进行查看：

127.0.0.1:6379> keys *
1) "UserKey:id1"
2) "key2"
3) "key1"

127.0.0.1:6379> 

为了处理更多的情况，需要对RedisService.java文件进行修改：

/*
* 获取单个对象
* */
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);  //从redis数据库中取出的value是String类型
T t = stringToBean(str, clazz);
return t;
}finally{
returnToPool(jedis);
}
}
/*
* 设置对象
* */
public <T> boolean set(KeyPrefix prefix, String key, T value){
Jedis jedis = null;
try{
jedis = jedisPool.getResource();
String str = beanToString(value); //将bean转换为字符串String，然后再存入redis数据库里面
if(str == null || str.length() <= 0){
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);//设置过期时间为 seconds
}
return true;
}finally{
returnToPool(jedis);
}
}
/*
* 判断key是否存在
* */
public <T> boolean exists(KeyPrefix prefix, String key){
Jedis jedis = null;
try{
jedis = jedisPool.getResource();
//生成真正的key
String realKey = prefix.getPrefix() + key;
return jedis.exists(realKey);
}finally{
returnToPool(jedis);
}
}
/*
* 增加值
* */
public <T> Long incr(KeyPrefix prefix, String key){
Jedis jedis = null;
try{
jedis = jedisPool.getResource();
//生成真正的key
String realKey = prefix.getPrefix() + key;
return jedis.incr(realKey);
}finally{
returnToPool(jedis);
}
}
/*
* 减少值
* */
public <T> Long decr(KeyPrefix prefix, String key){
Jedis jedis = null;
try{
jedis = jedisPool.getResource();
//生成真正的key
String realKey = prefix.getPrefix() + key;
return jedis.decr(realKey);
}finally{
returnToPool(jedis);
}
}