boot RedisTemplate

package com.osvue.win.app.config;

import java.lang.reflect.Method;

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;

@Configuration
public class RedisConfig extends CachingConfigurerSupport {

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

 /**
  * 缓存配置管理器
  */
 @Bean
 public CacheManager cacheManager(LettuceConnectionFactory factory) {
  // 以锁写入的方式创建RedisCacheWriter对象
  RedisCacheWriter writer = RedisCacheWriter.lockingRedisCacheWriter(factory);
  // 创建默认缓存配置对象
  RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();
  RedisCacheManager cacheManager = new RedisCacheManager(writer, config);
  return cacheManager;
 }

 @Bean
 public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory factory) {
  RedisTemplate<String, Object> template = new RedisTemplate<>();
  template.setConnectionFactory(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);
  StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
  // 在使用注解@Bean返回RedisTemplate的时候，同时配置hashKey与hashValue的序列化方式。
  // key采用String的序列化方式
  template.setKeySerializer(stringRedisSerializer);
  // value序列化方式采用jackson
  template.setValueSerializer(jackson2JsonRedisSerializer);
  // hash的key也采用String的序列化方式
  template.setHashKeySerializer(stringRedisSerializer);
  // hash的value序列化方式采用jackson
  template.setHashValueSerializer(jackson2JsonRedisSerializer);
  template.afterPropertiesSet();
  return template;
 }

}

 @Autowired
 private RedisTemplate<String, Object> redisTemplate;
 @Autowired
 private StringRedisTemplate stringRedisTemplate;

 /**
  * 普通缓存放入
  * 
  * @param key        键
  * @param value      值
  * @param expireTime 超时时间(秒)
  * @return true成功 false失败
  */
 public Boolean set(String key, Object value, int expireTime) {
  try {
   redisTemplate.opsForValue().set(key, value, expireTime, TimeUnit.SECONDS);
   return true;
  } catch (Exception e) {
   e.printStackTrace();
   return false;
  }
 }

 /**
  * 普通缓存放入
  * 
  * @param key        键
  * @param value      值
  * @param expireTime 超时时间(秒)
  * @return true成功 false失败
  */

 public Boolean set(String key, String value, int expireTime) {
  try {
   stringRedisTemplate.opsForValue().set(key, value, expireTime, TimeUnit.SECONDS);
   return true;
  } catch (Exception e) {
   e.printStackTrace();
   return false;
  }
 }

 /**
  * 普通缓存放入
  * 
  * @param key   键
  * @param value 值
  * @return true成功 false失败
  */
 public Boolean set(String key, Object value) {
  try {
   redisTemplate.opsForValue().set(key, value);
   return true;
  } catch (Exception e) {
   e.printStackTrace();
   return false;
  }
 }

 /**
  * 普通缓存放入
  * 
  * @param key   键
  * @param value 值
  * @return true成功 false失败
  */
 public Boolean set(String key, String value) {
  try {
   redisTemplate.opsForValue().set(key, value);
   return true;
  } catch (Exception e) {
   e.printStackTrace();
   return false;
  }
 }

 /**
  * 普通缓存获取
  * 
  * @param key 键
  * @return 值
  */

 public String get(String key) {
  return key == null ? null : (String) stringRedisTemplate.opsForValue().get(key);
 }

 /**
  * 在原有的值基础上新增字符串到末尾。
  * 
  * @param key   键
  * @param value 追加的值
  * @return true成功 false失败
  */

 public void append(String key, String value) {
  stringRedisTemplate.opsForValue().append(key, value);
 }

 /**
  * 截取key键对应值得字符串，从开始下标位置开始到结束下标的位置(包含结束下标)的字符串。
  * 
  * @param key   键
  * @param start 开始位置
  * @param end   结束位置
  * @return
  */

 public String get(String key, long start, long end) {
  return stringRedisTemplate.opsForValue().get(key, start, end);
 }

 /**
  * 获取原来key键对应的值并重新赋新值。
  * 
  * @param key   键
  * @param value 值
  * @return 原来旧值
  */

 public Object getAndSet(String key, String value) {
  return stringRedisTemplate.opsForValue().getAndSet(key, value);
 }

 /**
  * 覆盖从指定位置开始的值。
  * 
  * @param key    键
  * @param value  值
  * @param offset 位置
  */

 public void set(String key, String value, long offset) {
  redisTemplate.opsForValue().set(key, value, offset);
 }

 /**
  * 普通缓存获取
  * 
  * @param key 键
  * @return 值
  */

 public Object getObject(String key) {
  return key == null ? null : redisTemplate.opsForValue().get(key);
 }

 /**
  * 获取指定字符串的长度。
  * 
  * @param key
  * @return 长度
  */

 public long size(String key) {
  return stringRedisTemplate.opsForValue().size(key);
 }

 /**
  * 如果键不存在则新增,存在则不改变已经有的值
  * 
  * @param key
  * @param value
  * @return true成功 false失败
  */

 public boolean setIfAbsent(String key, String value) {
  return stringRedisTemplate.opsForValue().setIfAbsent(key, value);
 }

 /**
  * 删除指定KEY的缓存
  * 
  * @param keys
  */
 public void del(String... keys) {
  if (keys != null && keys.length > 0) {
   if (keys.length == 1) {
    redisTemplate.delete(keys[0]);
   } else {
    redisTemplate.delete(CollectionUtils.arrayToList(keys));
   }
  }
 }

 /**
  * 根据key设置过期时间
  * 
  * @param key     键
  * @param seconds 超时时间(秒)
  * @return true成功 false失败
  */
 public boolean expire(String key, long seconds) {
  return redisTemplate.expire(key, seconds, TimeUnit.SECONDS);
 }

 /**
  * 根据key获取过期时间
  * 
  * @param key 键 不能为null
  * @return 时间(秒) 返回0代表为永久有效
  */
 public long getExpire(String key) {
  return redisTemplate.getExpire(key, TimeUnit.SECONDS);
 }

 /**
  * 递增
  * 
  * @param key   键
  * @param delta 要增加几(大于0)
  * @return 返回增加后的值
  */
 public long incr(String key, long delta) {
  if (delta < 0) {
   throw new RuntimeException("递增因子必须大于0");
  }
  return stringRedisTemplate.opsForValue().increment(key, delta);
 }

 /**
  * 递减
  * 
  * @param key   键
  * @param delta 要减少几(小于0)
  * @return 返回减少后的值
  */
 public long decr(String key, long delta) {
  if (delta < 0) {
   throw new RuntimeException("递减因子必须大于0");
  }
  return stringRedisTemplate.opsForValue().increment(key, -delta);
 }

 /**
  * 设置map集合到redis。
  * 
  * @param map
  */
 public void multiSet(Map map) {
  stringRedisTemplate.opsForValue().multiSet(map);
 }

 /**
  * 根据集合取出对应的value值。* @param list
  * 
  * @return
  */
 public List multiGet(List list) {
  return stringRedisTemplate.opsForValue().multiGet(list);
 }