SpringCloud中Redis的使用

1.引入redis相关jar包

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

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>1.0.2</version>
</dependency>

2.配置Redis相关信息

#redis 配置
# Redis数据库索引（默认为0）
spring.redis.database=${dev.spring.redis.database}
# Redis服务器地址
spring.redis.host=${dev.spring.redis.host}
# Redis服务器连接端口
spring.redis.port=${dev.spring.redis.port}
# Redis服务器连接密码（默认为空）
spring.redis.password=${dev.spring.redis.password}
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=${dev.spring.redis.pool.max-active}
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=${dev.spring.redis.pool.max-wait}
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=${dev.spring.redis.pool.max-idle}
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=${dev.spring.redis.pool.min-idle}
# 连接超时时间（毫秒）
spring.redis.timeout=${dev.spring.redis.timeout}

3.读取Redis链接信息 RedisConn

@Component
@ConfigurationProperties(prefix = "spring.redis")
public class RedisConn {
private String host;
//prefix+参数名  对应于配置文件config.properties中的spring.redis.*信息
private int port;

private int timeout;

4.RedisConfig

package com.sinosoft.product.service.redis;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;


@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
@Autowired
private RedisConn redisConn;

/**
* 生产key的策略
*
* @return
*/

@Bean
@Override
public KeyGenerator keyGenerator() {
return new KeyGenerator() {

@Override
public Object generate(Object target, Method method, Object... params) {
StringBuilder sb = new StringBuilder();
sb.append(target.getClass().getName());
sb.append(method.getName());
for (Object obj : params) {
sb.append(obj.toString());
}
return sb.toString();
}
};

}

/**
* 管理缓存
*
* @param redisTemplate
* @return
*/

@SuppressWarnings("rawtypes")
@Bean
public CacheManager CacheManager(RedisTemplate redisTemplate) {
RedisCacheManager rcm = new RedisCacheManager(redisTemplate);
// 设置cache过期时间,时间单位是秒
rcm.setDefaultExpiration(60);
Map<String, Long> map = new HashMap<String, Long>();
map.put("test", 60L);
rcm.setExpires(map);
return rcm;
}

/**
* redis 数据库连接池
* @return
*/

@Bean
public JedisConnectionFactory redisConnectionFactory() {
JedisConnectionFactory factory = new JedisConnectionFactory();
factory.setHostName(redisConn.getHost());
factory.setPort(redisConn.getPort());
factory.setTimeout(redisConn.getTimeout()); // 设置连接超时时间
return factory;
}

/**
* redisTemplate配置
*
* @param factory
* @return
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
@Bean
public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
StringRedisTemplate template = new StringRedisTemplate(factory);
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);
template.setValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}

}

5.RedisUtils  Redis工具类

package com.sinosoft.product.service.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;

import java.io.Serializable;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil{
@SuppressWarnings("rawtypes")
@Autowired
private RedisTemplate redisTemplate;

/**
* 批量删除对应的value
*
* @param keys
*/
public void remove(final String... keys) {
for (String key : keys) {
remove(key);
}
}

/**
* 批量删除key
*
* @param pattern
*/
@SuppressWarnings("unchecked")
public void removePattern(final String pattern) {
Set<Serializable> keys = redisTemplate.keys(pattern);
if (keys.size() > 0)
redisTemplate.delete(keys);
}

/**
* 删除对应的value
*
* @param key
*/
@SuppressWarnings("unchecked")
public void remove(final String key) {
if (exists(key)) {
redisTemplate.delete(key);
}
}

/**
* 判断缓存中是否有对应的value
*
* @param key
* @return
*/
@SuppressWarnings("unchecked")
public boolean exists(final String key) {
return redisTemplate.hasKey(key);
}

/**
* 读取缓存
*
* @param key
* @return
*/
@SuppressWarnings("unchecked")
public Object get(final String key) {
Object result = null;
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
result = operations.get(key);
return result;
}

/**
* 写入缓存
*
* @param key
* @param value
* @return
*/
@SuppressWarnings("unchecked")
public boolean set(final String key, Object value) {
boolean result = false;
try {
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
operations.set(key, value);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}

/**
* 写入缓存
*
* @param key
* @param value
* @return
*/
@SuppressWarnings("unchecked")
public boolean set(final String key, Object value, Long expireTime) {
boolean result = false;
try {
ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
operations.set(key, value);
redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}

}

6.Redis的使用

//注入Redis的工具类

@Autowired
private RedisUtils redisUtil;

//判断Redis中是否存在对应key的信息，若存在则在reids中获取，若不存在从数据库查询，同时存入redis缓存中

if (redisUtil.exists(calcode+calFlag)) {
Log.info("从Redis缓存中获取产品计算编码:{" + calcode+calFlag + "}信息");
tLMCalCulate = (LMCalCulate) redisUtil.get(calcode+calFlag);
} else {
LMCalCulateExample tLMCalCulateExample=new LMCalCulateExample();
tLMCalCulateExample.createCriteria().andCalcodeEqualTo(calcode).andCalflgEqualTo(calFlag);
List<LMCalCulate> tListLMCalCulate = lMCalCulateMapper.selectByExample(tLMCalCulateExample);
if(null!=tListLMCalCulate && tListLMCalCulate.size()>0){
tLMCalCulate=tListLMCalCulate.get(0);
redisUtil.set(calcode+calFlag, tLMCalCulate);
}
}