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>

pom 配置

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}

config.properties

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;

redis 链接pojo

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;
 }

 }

RedisConfig

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;
 }

 }

RedisUtil

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);
 }
 }

redis应用