SpringBoot集成redis集群存储字符串和对象

SpringBoot集成redis集群相比于Springmvc方便了很多，本例中使用的是3台机器搭建的redis cluster集群，为3主3从的配置，集体的搭建细节在此不做示例。具体集成redis步骤如下所示：

首先需要引入依赖：

Spring Boot提供的数据访问框架Spring Data Redis基于Jedis。可以通过引入spring-boot-starter-redis来配置依赖关系

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-redis</artifactId>
</dependency>

参数配置：

   在application.yml(ps:要是使用application.properties配置类似)中加入如下配置：

spring:
redis:
cluster:
nodes:
- 10.7.28.179:6379
- 10.7.28.180:6379
- 10.7.28.181:6379
- 10.7.28.179:6380
- 10.7.28.180:6380
- 10.7.28.181:6380
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active: 8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait: -1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle: 8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle: 0
# 连接超时时间（毫秒）
spring.redis.timeout: 0

测试访问：

@RunWith(SpringRunner.class)
@SpringBootTest
public class TestRedis {
@Autowired
private StringRedisTemplate stringRedisTemplate;

/**
* redis缓存测试放入普通的字符串
* @throws Exception
*/
@Test
public void testRedisByString() throws Exception {
// 保存字符串
stringRedisTemplate.opsForValue().set("aaa", "122");
Assert.assertEquals("111", stringRedisTemplate.opsForValue().get("aaa"));
}
}通过上面简单的测试就可以在redis上面存储数据了 不过上面的方式只支持String类型的存储，我们平时比较常用的还有存储对象，下面介绍下存储对象的方式：

创建要存储的对象：
package tf56.SpringBoot.domain;

import java.io.Serializable;

/**
* 创建需要放入redis的对象
*/
public class UserRedis implements Serializable {
private static final long serialVersionUID = -1L;
private String username;
private Integer age;
public UserRedis(String username, Integer age) {
this.username = username;
this.age = age;
}

public String getUsername() {
return username;
}

public void setUsername(String username) {
this.username=username;
}

public Integer getAge() {
return age;
}

public void setAge(Integer age) {
this.age=age;
}
}实现对象的序列化接口：
package tf56.SpringBoot.utils;

import org.springframework.core.convert.converter.Converter;
import org.springframework.core.serializer.support.DeserializingConverter;
import org.springframework.core.serializer.support.SerializingConverter;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;

/**
* 实现对象的序列化接口
*/
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];
public Object deserialize(byte[] bytes) {
if (isEmpty(bytes)) {
return null;
}
try {
return deserializer.convert(bytes);
} catch (Exception ex) {
throw new SerializationException("Cannot deserialize", ex);
}
}
public byte[] serialize(Object object) {
if (object == null) {
return EMPTY_ARRAY;
}
try {
return serializer.convert(object);
} catch (Exception ex) {
return EMPTY_ARRAY;
}
}
private boolean isEmpty(byte[] data) {
return (data == null || data.length == 0);
}
}配置实例：
package tf56.SpringBoot.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisClusterConfiguration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisSentinelConfiguration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.repository.configuration.EnableRedisRepositories;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import tf56.SpringBoot.domain.UserRedis;

import javax.annotation.Resource;
import java.util.Arrays;
import java.util.List;

/**
* 配置针对UserRedis的RedisTemplate实例

*/
@Configuration
@EnableRedisRepositories
public class RedisConfig {
/**
* 如果这里注入了JedisConnectionFactory,加载的时候application.yml中的配置不会起作用，所以
* 初始化JedisConnectionFactory对象的时候需要加入clusterNodes节点信息
*/
List<String> clusterNodes = Arrays.asList("10.7.28.179:6379", "10.7.28.179:6380", "10.7.28.180:6379", "10.7.28.180:6380", "10.7.28.181:6379", "10.7.28.181:6380");

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

@Bean
public RedisTemplate<String, UserRedis> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String, UserRedis> template = new RedisTemplate<String, UserRedis>();
template.setConnectionFactory(jedisConnectionFactory());
template.setKeySerializer(new StringRedisSerializer());
template.setValueSerializer(new RedisObjectSerializer());
return template;
}

}完成配置后，编写测试实现效果：
package tf56.SpringBoot.controller;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;
import tf56.SpringBoot.domain.UserRedis;

/**
* Created by Administrator on 2017/8/30.
*/
@RunWith(SpringRunner.class)
@SpringBootTest
public class TestRedis {

@Autowired
private RedisTemplate<String, UserRedis> redisTemplate;

/**
* redis 缓存测试存放对象
* @throws Exception
*/
@Test
public void testRedisByObject() throws Exception {
// 保存对象
UserRedis user = new UserRedis("超人", 20);
redisTemplate.opsForValue().set(user.getUsername(), user);
user = new UserRedis("蝙蝠侠", 30);
redisTemplate.opsForValue().set(user.getUsername(), user);
user = new UserRedis("蜘蛛侠", 40);
redisTemplate.opsForValue().set(user.getUsername(), user);

System.out.println(redisTemplate.opsForValue().get("超人").getAge());
System.out.println(redisTemplate.opsForValue().get("蝙蝠侠").getAge());
System.out.println(redisTemplate.opsForValue().get("蜘蛛侠").getAge());
}
}