SpringBoot integration of three ways Redis

AutoConfig load
Write your own code loads
xml load

Use these three methods are required:

1. Add dependence

2. Write configuration information

= 0 spring.redis.database
spring.redis.host = localhost
spring.redis.port = 6379
# connection timeout time ms (milliseconds)
spring.redis.timeout = 3000

# Maximum connection pool idle connections, the default value is 8.
. 8-IDLE = spring.redis.pool.max
# minimum connection pool idle connections, the default value is 0.
IDLE = 0-spring.redis.pool.min
# If the assignment is -1, it indicates not limited; for maxActive jedis example if one has been assigned a pool, the pool state at this time is exhausted (exhausted).
Active =. 8-spring.redis.pool.max
# maximum time to wait for an available connection, in milliseconds, the default value is -1, never times out. If the wait time is exceeded, directly thrown JedisConnectionException
spring.redis.pool.max = the wait--1

Method 1: Use Autoconfiguration automatically loaded.

Since the introduction of the spring-boot-start-data-redis above, can be used to load configuration properties RedisAutoConfiguration class file.

**
* Standard Redis configuration.
*/
@Configuration
protected static class RedisConfiguration {

@Bean
@ConditionalOnMissingBean(name = "redisTemplate")
public RedisTemplate<Object, Object> redisTemplate(
RedisConnectionFactory redisConnectionFactory)
throws UnknownHostException {
RedisTemplate<Object, Object> template = new RedisTemplate<Object, Object>();
template.setConnectionFactory(redisConnectionFactory);
return template;
}

@Bean
@ConditionalOnMissingBean(StringRedisTemplate.class)
public StringRedisTemplate stringRedisTemplate(
RedisConnectionFactory redisConnectionFactory)
throws UnknownHostException {
StringRedisTemplate template = new StringRedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
return template;
}
}

Redis this way will default configuration loaded in the applicaiton, provides two bean

RedisTemplate <Object, Object> may all operate on the data type object in Redis and key value, the object will use a default serialization JdkSerializationRedisSerializer

StringRedisTemplate Redis can be operated and the key value data of type String.

Second way: write your own code is loaded.

@Configuration
public class RedisConfig{

private Logger logger = LoggerFactory.getLogger(this.getClass());

@Value("${spring.redis.host}")
private String host;

@Value("${spring.redis.port}")
private int port;

@Value("${spring.redis.timeout}")
private int timeout;

@Value("${spring.redis.password}")
private String password;

@Value("${spring.redis.database}")
private int database;

@Value("${spring.redis.pool.max-idle}")
private int maxIdle;

@Value("${spring.redis.pool.min-idle}")
private int minIdle;

/**
* redis模板，存储关键字是字符串，值是Jdk序列化
* @Description:
* @param factory
* @return
*/
@Bean
public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory factory) {
RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(factory);
RedisSerializer<String> redisSerializer = new StringRedisSerializer();
redisTemplate.setKeySerializer(redisSerializer);
redisTemplate.setHashKeySerializer(redisSerializer);
//JdkSerializationRedisSerializer序列化方式;
JdkSerializationRedisSerializer jdkRedisSerializer=new JdkSerializationRedisSerializer();
redisTemplate.setValueSerializer(jdkRedisSerializer);
redisTemplate.setHashValueSerializer(jdkRedisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
}

Three ways: using xml loaded.

In the program entry is added:

@ImportResource(locations={"classpath:spring-redis.xml"})

In the resource file folder under the new spring-redis.xml

use:

Template injected with annotations directly call just fine.

@Repository
public class RedisService {

@Autowired
StringRedisTemplate stringRedisTemplate;

public void add(String key, User user, Long time) {
Gson gson = new Gson();
stringRedisTemplate.opsForValue().set(key, gson.toJson(user), time, TimeUnit.MINUTES);
}

public void add(String key, List<User> users, Long time) {
Gson gson = new Gson();
String src = gson.toJson(users);
stringRedisTemplate.opsForValue().set(key, src, time, TimeUnit.MINUTES);
}

public User get(String key) {
String source = stringRedisTemplate.opsForValue().get(key);
if (!StringUtils.isEmpty(source)) {
return new Gson().fromJson(source, User.class);
}
return null;
}

public List<User> getUserList(String key) {
String source = stringRedisTemplate.opsForValue().get(key);
if (!StringUtils.isEmpty(source)) {
return new Gson().fromJson(source, new TypeToken<List<User>>() {
}.getType());
}
return null;
}

public void delete(String key) {
stringRedisTemplate.opsForValue().getOperations().delete(key);
}
}

If the test is then:

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

@Autowired
RedisService redisService;

@Before
public void setUp() {

}

@Test
public void get() {
User user = new User();
user.setName("wangjianfeng");
user.setAge(22);
redisService.add("userByName:" + user.getName(), user, 10L);
List<User> list = new ArrayList<>();
list.add(user);
redisService.add("list", list, 10L);
User user1 = redisService.get("userByName:wangjianfeng");
Assert.notNull(user1, "user is null");
List<User> list2 = redisService.getUserList("list");
Assert.notNull(list2, "list is null");
}
}

SpringBoot use Redis cache:

Springboot offers many cache manager, such as:

SimpleCacheManager
EhCacheManager
CaffeineCacheManager
GuavaCacheManager
CompositeCacheManager

SpringData provides the cache manager: RedisCacheManager

In SpringBoot, the entry in the program, together with a suitable configuration @EnableCaching automated annotation manager.

Then we use to write their own code configuration, modify RedisConfig @EnableCaching add annotations, and inherit CachingCongigurerSupport

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport{
...
}

SpringBoot integration of three ways Redis

Guess you like