yml配置文件

  1. spring:
  2.   redis:
  3.     database: 0              # Redis数据库索引（默认为0）
  4.     host: 124.223.204.195    # Redis服务器地址
  5.     port: 6379               #Redis服务器连接端口
  6.     password: LCXlcx0726     #Redis服务器连接密码（默认为空）
  7.     lettuce:
  8.       pool:
  9.         max-active: 8        #连接池最大连接数（使用负值表示没有限制） 默认 8
  10.         max-wait: -1         #连接池最大阻塞等待时间（使用负值表示没有限制） 默认 -1
  11.         max-idle: 8          #连接池中的最大空闲连接 默认 8
  12.         min-idle: 0          #连接池中的最小空闲连接 默认 0
  13.     timeout: 30000           #连接超时时间（毫秒）

RedisConfig Redis配置类

  1. import com.fasterxml.jackson.annotation.JsonAutoDetect;
  2. import com.fasterxml.jackson.annotation.PropertyAccessor;
  3. import com.fasterxml.jackson.databind.ObjectMapper;
  4. import org.springframework.cache.annotation.CachingConfigurerSupport;
  5. import org.springframework.cache.annotation.EnableCaching;
  6. import org.springframework.context.annotation.Bean;
  7. import org.springframework.context.annotation.Configuration;
  8. import org.springframework.data.redis.connection.RedisConnectionFactory;
  9. import org.springframework.data.redis.core.*;
  10. import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
  11. import org.springframework.data.redis.serializer.StringRedisSerializer;
  13. /**
  14. * redis配置类
  15. */
  16. @Configuration
  17. @EnableCaching //开启注解
  18. public class RedisConfig extends CachingConfigurerSupport {
  20.     /**
  21.     * retemplate相关配置
  22.     */
  23.     @Bean
  24.     public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
  26.         RedisTemplate<String, Object> template = new RedisTemplate<>();
  27.         // 配置连接工厂
  28.         template.setConnectionFactory(factory);
  30.         //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
  31.         Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
  33.         ObjectMapper om = new ObjectMapper();
  34.         // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
  35.         om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  36.         // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
  37.         om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  38.         jacksonSeial.setObjectMapper(om);
  40.         // 值采用json序列化
  41.         template.setValueSerializer(jacksonSeial);
  42.         //使用StringRedisSerializer来序列化和反序列化redis的key值
  43.         template.setKeySerializer(new StringRedisSerializer());
  45.         // 设置hash key 和value序列化模式
  46.         template.setHashKeySerializer(new StringRedisSerializer());
  47.         template.setHashValueSerializer(jacksonSeial);
  48.         template.afterPropertiesSet();
  50.         return template;
  51.     }
  53.     /**
  54.     * 对hash类型的数据操作
  55.     */
  56.     @Bean
  57.     public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
  58.         return redisTemplate.opsForHash();
  59.     }
  61.     /**
  62.     * 对redis字符串类型数据操作
  63.     */
  64.     @Bean
  65.     public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
  66.         return redisTemplate.opsForValue();
  67.     }
  69.     /**
  70.     * 对链表类型的数据操作
  71.     */
  72.     @Bean
  73.     public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
  74.         return redisTemplate.opsForList();
  75.     }
  77.     /**
  78.     * 对无序集合类型的数据操作
  79.     */
  80.     @Bean
  81.     public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
  82.         return redisTemplate.opsForSet();
  83.     }
  85.     /**
  86.     * 对有序集合类型的数据操作
  87.     */
  88.     @Bean
  89.     public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
  90.         return redisTemplate.opsForZSet();
  91.     }
  93. }

RedisCache 工具类

  1. import org.springframework.beans.factory.annotation.Autowired;
  2. import org.springframework.data.redis.core.BoundSetOperations;
  3. import org.springframework.data.redis.core.HashOperations;
  4. import org.springframework.data.redis.core.RedisTemplate;
  5. import org.springframework.data.redis.core.ValueOperations;
  6. import org.springframework.stereotype.Component;
  8. import java.util.*;
  9. import java.util.concurrent.TimeUnit;
  11. @SuppressWarnings(value = { "unchecked", "rawtypes" })
  12. @Component
  13. public class RedisCache
  14. {
  15.     @Autowired
  16.     public RedisTemplate redisTemplate;
  18.     /**
  19.      * 缓存基本的对象，Integer、String、实体类等
  20.      *
  21.      * @param key 缓存的键值
  22.      * @param value 缓存的值
  23.      */
  24.     public <T> void setCacheObject(final String key, final T value)
  25.     {
  26.         redisTemplate.opsForValue().set(key, value);
  27.     }
  29.     /**
  30.      * 缓存基本的对象，Integer、String、实体类等
  31.      *
  32.      * @param key 缓存的键值
  33.      * @param value 缓存的值
  34.      * @param timeout 时间
  35.      * @param timeUnit 时间颗粒度
  36.      */
  37.     public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit)
  38.     {
  39.         redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
  40.     }
  42.     /**
  43.      * 设置有效时间
  44.      *
  45.      * @param key Redis键
  46.      * @param timeout 超时时间
  47.      * @return true=设置成功；false=设置失败
  48.      */
  49.     public boolean expire(final String key, final long timeout)
  50.     {
  51.         return expire(key, timeout, TimeUnit.SECONDS);
  52.     }
  54.     /**
  55.      * 设置有效时间
  56.      *
  57.      * @param key Redis键
  58.      * @param timeout 超时时间
  59.      * @param unit 时间单位
  60.      * @return true=设置成功；false=设置失败
  61.      */
  62.     public boolean expire(final String key, final long timeout, final TimeUnit unit)
  63.     {
  64.         return redisTemplate.expire(key, timeout, unit);
  65.     }
  67.     /**
  68.      * 获得缓存的基本对象。
  69.      *
  70.      * @param key 缓存键值
  71.      * @return 缓存键值对应的数据
  72.      */
  73.     public <T> T getCacheObject(final String key)
  74.     {
  75.         ValueOperations<String, T> operation = redisTemplate.opsForValue();
  76.         return operation.get(key);
  77.     }
  79.     /**
  80.      * 删除单个对象
  81.      *
  82.      * @param key
  83.      */
  84.     public boolean deleteObject(final String key)
  85.     {
  86.         return redisTemplate.delete(key);
  87.     }
  89.     /**
  90.      * 删除集合对象
  91.      *
  92.      * @param collection 多个对象
  93.      * @return
  94.      */
  95.     public long deleteObject(final Collection collection)
  96.     {
  97.         return redisTemplate.delete(collection);
  98.     }
  100.     /**
  101.      * 缓存List数据
  102.      *
  103.      * @param key 缓存的键值
  104.      * @param dataList 待缓存的List数据
  105.      * @return 缓存的对象
  106.      */
  107.     public <T> long setCacheList(final String key, final List<T> dataList)
  108.     {
  109.         Long count = redisTemplate.opsForList().rightPushAll(key, dataList);
  110.         return count == null ? 0 : count;
  111.     }
  113.     /**
  114.      * 获得缓存的list对象
  115.      *
  116.      * @param key 缓存的键值
  117.      * @return 缓存键值对应的数据
  118.      */
  119.     public <T> List<T> getCacheList(final String key)
  120.     {
  121.         return redisTemplate.opsForList().range(key, 0, -1);
  122.     }
  124.     /**
  125.      * 缓存Set
  126.      *
  127.      * @param key 缓存键值
  128.      * @param dataSet 缓存的数据
  129.      * @return 缓存数据的对象
  130.      */
  131.     public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet)
  132.     {
  133.         BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
  134.         Iterator<T> it = dataSet.iterator();
  135.         while (it.hasNext())
  136.         {
  137.             setOperation.add(it.next());
  138.         }
  139.         return setOperation;
  140.     }
  142.     /**
  143.      * 获得缓存的set
  144.      *
  145.      * @param key
  146.      * @return
  147.      */
  148.     public <T> Set<T> getCacheSet(final String key)
  149.     {
  150.         return redisTemplate.opsForSet().members(key);
  151.     }
  153.     /**
  154.      * 缓存Map
  155.      *
  156.      * @param key
  157.      * @param dataMap
  158.      */
  159.     public <T> void setCacheMap(final String key, final Map<String, T> dataMap)
  160.     {
  161.         if (dataMap != null) {
  162.             redisTemplate.opsForHash().putAll(key, dataMap);
  163.         }
  164.     }
  166.     /**
  167.      * 获得缓存的Map
  168.      *
  169.      * @param key
  170.      * @return
  171.      */
  172.     public <T> Map<String, T> getCacheMap(final String key)
  173.     {
  174.         return redisTemplate.opsForHash().entries(key);
  175.     }
  177.     /**
  178.      * 往Hash中存入数据
  179.      *
  180.      * @param key Redis键
  181.      * @param hKey Hash键
  182.      * @param value 值
  183.      */
  184.     public <T> void setCacheMapValue(final String key, final String hKey, final T value)
  185.     {
  186.         redisTemplate.opsForHash().put(key, hKey, value);
  187.     }
  189.     /**
  190.      * 获取Hash中的数据
  191.      *
  192.      * @param key Redis键
  193.      * @param hKey Hash键
  194.      * @return Hash中的对象
  195.      */
  196.     public <T> T getCacheMapValue(final String key, final String hKey)
  197.     {
  198.         HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();
  199.         return opsForHash.get(key, hKey);
  200.     }
  202.     /**
  203.      * 删除Hash中的数据
  204.      * 
  205.      * @param key
  206.      * @param hkey
  207.      */
  208.     public void delCacheMapValue(final String key, final String hkey)
  209.     {
  210.         HashOperations hashOperations = redisTemplate.opsForHash();
  211.         hashOperations.delete(key, hkey);
  212.     }
  214.     /**
  215.      * 获取多个Hash中的数据
  216.      *
  217.      * @param key Redis键
  218.      * @param hKeys Hash键集合
  219.      * @return Hash对象集合
  220.      */
  221.     public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys)
  222.     {
  223.         return redisTemplate.opsForHash().multiGet(key, hKeys);
  224.     }
  226.     /**
  227.      * 获得缓存的基本对象列表
  228.      *
  229.      * @param pattern 字符串前缀
  230.      * @return 对象列表
  231.      */
  232.     public Collection<String> keys(final String pattern)
  233.     {
  234.         return redisTemplate.keys(pattern);
  235.     }
  236. }