SpringBoot开发详解（十一） -- Redis在SpringBoot中的整合

原文链接：http://blog.csdn.net/qq_31001665

如有侵权，请联系博主删除博客，谢谢各位小伙伴，好久不见。最近一直都没有更新，因为公司的项目一直在抓进度，又是表结构更替，又是重构，还要迭代需求。感觉项目都快做烂了……所以一个公司的好坏真的和领导者有极大的关系，许多程序员真的只是三年程序员，谢三年代码就去转岗管理了，最后导致技术水平有限，管理水平又跟不上。好，我废话少说，开始这次的内容，这次我们聊一下NoSql数据库Redis在SpringBoot中的使用。

Redis在Spring Boot中的集成

Maven依赖引入：Redis是一个基于内存的日志型可持久化的缓存数据库，保存形式为key-value格式。还不清楚的小伙伴可以先学习一下，Redis在现在的开发中可是很常用的哦。首先，我们先在maven中引入相关依赖：

<!--redis依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

1
2
3
4
5
之后我们把Redis的相关配置写入yml，这里建议根据之前不同的环境写入不同的配置，Redis默认使用的端口是6379，通常Redis默认使用0号数据库，默认共有16个数据库：

#redis配置
redis:
#  数据库索引
database: 0
#    服务器地址
host: 127.0.0.1
#    服务器连接端口
port: 6379
#    链接密码
password:
#    链接池
pool:
#    最大连接数（负值表示没有限制）
max-active: 8
#      最大阻塞等待时间（负值表示没有限制）
max-wait: 1
#      最大空闲链接
max-idle: 8
#      最小空闲链接
min-idle: 0
#    链接超时时间（毫秒）
timeout: 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
此时，我们已经完成了Redis的所有配置，可以直接来使用了，我们写一个测试用例来测试一下：

@SpringBootTest
@RunWith(SpringJUnit4ClassRunner.class)
public class RedisAutoTest {

@Autowired
private StringRedisTemplate stringRedisTemplate;

@Test
public void save(){

stringRedisTemplate.opsForValue().set("zzp","big z");
Assert.assertEquals("big z",stringRedisTemplate.opsForValue().get("zzp"));
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14



OK，没有问题，同样的我们使用rdm打开看下是否成功存入了。

OK，也没有任何问题。 
在这个测试用例中我们使用的StringRedisTemplate，因为我们之前说过redis使用key-value格式保存数据，这里其实保存的就是

public class UserInfo implements Serializable{

private static final long serialVersionUID = 1L;

private String tel;

private String nickName;

@Max(value = 999999,message = "超过最大数值")
@Min(value = 000000,message = "密码设定不正确")
private String passWord;

public UserInfo() {
}

@Override
public String toString() {
return "UserInfo{" +
"tel='" + tel + '\'' +
", nickName='" + nickName + '\'' +
", passWord='" + passWord + '\'' +
'}';
}

public UserInfo(String tel, String nickName, String passWord) {
this.tel = tel;
this.nickName = nickName;
this.passWord = passWord;
}

public String getTel() {
return tel;
}

public void setTel(String tel) {
this.tel = tel;
}

public String getNickName() {
return nickName;
}

public void setNickName(String nickName) {
this.nickName = nickName;
}

public String getPassWord() {
return passWord;
}

public void setPassWord(String passWord) {
this.passWord = passWord;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
然后我们驶向下序列化接口：

public class RedisObjectSerializer implements RedisSerializer<Object> {

private Converter<Object,byte[]> serializer = new SerializingConverter();
private Converter<byte[],Object> deserializer = new DeserializingConverter();

static final byte[] EMPTY_ARRAY = new byte[0];

@Override
public byte[] serialize(Object o) throws SerializationException {

if(o == null){
return EMPTY_ARRAY;
}

try {
return serializer.convert(o);
}catch (Exception e){
return EMPTY_ARRAY;
}
}

@Override
public Object deserialize(byte[] bytes) throws SerializationException {
if(isEmpty(bytes)){
return null;
}
try {
return deserializer.convert(bytes);
}catch (Exception e){
throw new SerializationException("Can not deserializer",e);
}

}

private boolean isEmpty(byte[] data){

return (data == null || data.length == 0);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
之后我们在将RedisTemplate重新配置下，使用我们自己的序列化对象：

@Configuration
public class RedisConfig {

@Bean
JedisConnectionFactory jedisConnectionFactory(){
return  new JedisConnectionFactory();
}

/**
* 存入对象序列化信息
* @return
*/
@Bean
public RedisTemplate<String,UserInfo> redisSerizlizerObj(){
RedisTemplate<String,UserInfo> redisTemplate = new RedisTemplate<String,UserInfo>();
redisTemplate.setConnectionFactory(jedisConnectionFactory());
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(new RedisObjectSerializer());
return redisTemplate;
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
完成该工作后，我们可以继续写测试用例来验证我们的相关配置了

@Autowired
private RedisTemplate<String,UserInfo> Template;

@Test
public void testobjSerializer() throws InterruptedException {
UserInfo user = new UserInfo("111111","snow","112358");
Template.opsForValue().set("User:snow",user);
Assert.assertEquals(true,redisTemplate.hasKey("User:snow"));
}

1
2
3
4
5
6
7
8
9
测试结果一切正常，我们同样通过rdm可以看到我们所存入的序列化对象：



但是，将每一个对象都写一个RedisTemplate未免太过麻烦，其实我们开发中，会存入对象的toString方法。所以我将存入对象ToString方法的代码页给到大家，大家可以根据自己的需要来使用：

/**
* 存入对象tostring后的信息
* @return
*/
@Bean
public RedisTemplate<String,String> redisTemplate(){
RedisTemplate<String,String> redisTemplate = new StringRedisTemplate();
redisTemplate.setConnectionFactory(jedisConnectionFactory());Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
同样通过测试用例来验证可以发现，可以使用：

@Test
public void testobj() throws InterruptedException {
UserInfo user = new UserInfo("15201803745","snow","112358");
ValueOperations<String,UserInfo> operations = redisTemplate.opsForValue();
operations.set("User:zzp",user);
Thread.sleep(1000);
operations.set("User:zzq",user);
Thread.sleep(1000);
Assert.assertEquals(true,redisTemplate.hasKey("User:zzp"));
Assert.assertEquals(true,redisTemplate.hasKey("User:zzq"));
}

1
2
3
4
5
6
7
8
9
10
11




Redis的使用其实远远不止这些，包括事物等都是可以通过Redis处理的。一般开发中我们会使用Jedis对Redis进行操作，可是由于这时介绍Redis在SpringBoot中集成的，所以就不再多言了，如果有想知道的小伙伴可以告诉我，我在来说说如何使用Jedis操作。