SpringBoot+单机redis

Posted 凡尘炼心

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了SpringBoot+单机redis相关的知识,希望对你有一定的参考价值。

 

  • spring boot-redis集成
    • 看教程来的,看起来很简单,但是集成后发现启动失败?
WARN 2556 --- [  restartedMain] ationConfigEmbeddedWebApplicationContext :

Exception encountered during context initialization - cancelling refresh attempt: org.springframework.beans.factory.UnsatisfiedDependencyException:

Error creating bean with name ‘redisTemplate‘ defined in class path resource [org/springframework/boot/autoconfigure/data/redis/RedisAutoConfiguration$RedisConfiguration.class]:

  Unsatisfied dependency expressed through method ‘redisTemplate‘ parameter 0;

  nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException:

  No qualifying bean of type ‘org.springframework.data.redis.connection.RedisConnectionFactory‘ available:

   expected at least 1 bean which qualifies as autowire candidate. Dependency annotations: {}
  • 几经磨难最后的结果贴一下:

  • yml配置

    •  spring:
        redis:
          host: 127.0.0.1
          port: 6379
          timeout: 10000
          pool:
            max-active: 8
            max-wait: -1
            max-idle: 8
            min-idle: 0
          password: root
      
  • pom
    •   <dependency>
                  <groupId>org.springframework.boot</groupId>
                  <artifactId>spring-boot-starter-data-redis</artifactId>
                  <exclusions>
                      <exclusion>
                          <groupId>io.lettuce</groupId>
                          <artifactId>lettuce-core</artifactId>
                      </exclusion>
                  </exclusions>
              </dependency>
              <dependency>
                  <groupId>org.springframework.data</groupId>
                  <artifactId>spring-data-commons</artifactId>
              </dependency>
      
               <dependency>
                  <groupId>redis.clients</groupId>
                  <artifactId>jedis</artifactId>
        </dependency>
      

        

  • redisConfig

    • package com.inyu.conf.redis;
      
      import com.fasterxml.jackson.annotation.JsonAutoDetect;
      import com.fasterxml.jackson.annotation.PropertyAccessor;
      import com.fasterxml.jackson.databind.ObjectMapper;
      import org.springframework.cache.CacheManager;
      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.core.RedisTemplate;
      import org.springframework.data.redis.core.StringRedisTemplate;
      import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
      
      import java.lang.reflect.Method;
      
      /**
       * redis config
       */
      @Configuration
      @EnableCaching//启用缓存,这个注解很重要
      //继承CachingConfigurerSupport,为了自定义生成KEY的策略。可以不继承。
      public class RedisConfig {
      
          //缓存管理器
          @Bean
          public CacheManager cacheManager(RedisTemplate redisTemplate) {
              RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
              return cacheManager;
          }
      
          /**
           *  redisTemplate
           * @param factory
           * @return
           */
          @Bean
          public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
              StringRedisTemplate template = new StringRedisTemplate(factory);
              setSerializer(template);//设置序列化工具
              template.afterPropertiesSet();
              return template;
          }
          /**
           * 序列化
            * @param template
           */
          private void setSerializer(StringRedisTemplate template) {
              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);
          }
          /**
           * 生成key的策略
           * @return
           */
          @Bean
          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();
                  }
              };
          }
      }
  • redisUtil
    • package com.inyu.conf.redis;
      
      import org.springframework.beans.factory.annotation.Autowired;
      import org.springframework.data.redis.core.RedisTemplate;
      import org.springframework.stereotype.Component;
      import org.springframework.stereotype.Service;
      import org.springframework.util.CollectionUtils;
      
      import java.util.List;
      import java.util.Map;
      import java.util.Set;
      import java.util.concurrent.TimeUnit;
      
      /**
       * @version V1.0
       * @Description: TODO
       * @date Date : 2018/12/28 0028 22:46
       */
      @Component
      public class RedisService {
      
          @Autowired
          private RedisTemplate redisTemplate;
      
          /**
           * 指定缓存失效时间
           *
           * @param key  键
           * @param time 时间(秒)
           * @return
           */
          public boolean expire(String key, long time) {
              try {
                  if (time > 0) {
                      redisTemplate.expire(key, time, TimeUnit.SECONDS);
                  }
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * 根据key 获取过期时间
           *
           * @param key 键 不能为null
           * @return 时间(秒) 返回0代表为永久有效
           */
          public long getExpire(String key) {
              return redisTemplate.getExpire(key, TimeUnit.SECONDS);
          }
      
          /**
           * 判断key是否存在
           *
           * @param key 键
           * @return true 存在 false不存在
           */
          public boolean hasKey(String key) {
              try {
                  return redisTemplate.hasKey(key);
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * 删除缓存
           *
           * @param key 可以传一个值 或多个
           */
          @SuppressWarnings("unchecked")
          public void del(String... key) {
              if (key != null && key.length > 0) {
                  if (key.length == 1) {
                      redisTemplate.delete(key[0]);
                  } else {
                      redisTemplate.delete(CollectionUtils.arrayToList(key));
                  }
              }
          }
      
          //============================String=============================
      
          /**
           * 普通缓存获取
           *
           * @param key 键
           * @return 值
           */
          public Object get(String key) {
              return key == null ? null : redisTemplate.opsForValue().get(key);
          }
      
          /**
           * 普通缓存放入
           *
           * @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 值
           * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
           * @return true成功 false 失败
           */
          public boolean set(String key, Object value, long time) {
              try {
                  if (time > 0) {
                      redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
                  } else {
                      set(key, value);
                  }
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * 递增
           *
           * @param key 键
           * @param delta  要增加几(大于0)
           * @return
           */
          public long incr(String key, long delta) {
              if (delta < 0) {
                  throw new RuntimeException("递增因子必须大于0");
              }
              return redisTemplate.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 redisTemplate.opsForValue().increment(key, -delta);
          }
      
          //================================Map=================================
      
          /**
           * HashGet
           *
           * @param key  键 不能为null
           * @param item 项 不能为null
           * @return 值
           */
          public Object hget(String key, String item) {
              return redisTemplate.opsForHash().get(key, item);
          }
      
          /**
           * 获取hashKey对应的所有键值
           *
           * @param key 键
           * @return 对应的多个键值
           */
          public Map<Object, Object> hmget(String key) {
              return redisTemplate.opsForHash().entries(key);
          }
      
          /**
           * HashSet
           *
           * @param key 键
           * @param map 对应多个键值
           * @return true 成功 false 失败
           */
          public boolean hmset(String key, Map<String, Object> map) {
              try {
                  redisTemplate.opsForHash().putAll(key, map);
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * HashSet 并设置时间
           *
           * @param key  键
           * @param map  对应多个键值
           * @param time 时间(秒)
           * @return true成功 false失败
           */
          public boolean hmset(String key, Map<String, Object> map, long time) {
              try {
                  redisTemplate.opsForHash().putAll(key, map);
                  if (time > 0) {
                      expire(key, time);
                  }
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * 向一张hash表中放入数据,如果不存在将创建
           *
           * @param key   键
           * @param item  项
           * @param value 值
           * @return true 成功 false失败
           */
          public boolean hset(String key, String item, Object value) {
              try {
                  redisTemplate.opsForHash().put(key, item, value);
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * 向一张hash表中放入数据,如果不存在将创建
           *
           * @param key   键
           * @param item  项
           * @param value 值
           * @param time  时间(秒)  注意:如果已存在的hash表有时间,这里将会替换原有的时间
           * @return true 成功 false失败
           */
          public boolean hset(String key, String item, Object value, long time) {
              try {
                  redisTemplate.opsForHash().put(key, item, value);
                  if (time > 0) {
                      expire(key, time);
                  }
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * 删除hash表中的值
           *
           * @param key  键 不能为null
           * @param item 项 可以使多个 不能为null
           */
          public void hdel(String key, Object... item) {
              redisTemplate.opsForHash().delete(key, item);
          }
      
          /**
           * 判断hash表中是否有该项的值
           *
           * @param key  键 不能为null
           * @param item 项 不能为null
           * @return true 存在 false不存在
           */
          public boolean hHasKey(String key, String item) {
              return redisTemplate.opsForHash().hasKey(key, item);
          }
      
          /**
           * hash递增 如果不存在,就会创建一个 并把新增后的值返回
           *
           * @param key  键
           * @param item 项
           * @param by   要增加几(大于0)
           * @return
           */
          public double hincr(String key, String item, double by) {
              return redisTemplate.opsForHash().increment(key, item, by);
          }
      
          /**
           * hash递减
           *
           * @param key  键
           * @param item 项
           * @param by   要减少记(小于0)
           * @return
           */
          public double hdecr(String key, String item, double by) {
              return redisTemplate.opsForHash().increment(key, item, -by);
          }
      
          //============================set=============================
      
          /**
           * 根据key获取Set中的所有值
           *
           * @param key 键
           * @return
           */
          public Set<Object> sGet(String key) {
              try {
                  return redisTemplate.opsForSet().members(key);
              } catch (Exception e) {
                  e.printStackTrace();
                  return null;
              }
          }
      
          /**
           * 根据value从一个set中查询,是否存在
           *
           * @param key   键
           * @param value 值
           * @return true 存在 false不存在
           */
          public boolean sHasKey(String key, Object value) {
              try {
                  return redisTemplate.opsForSet().isMember(key, value);
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * 将数据放入set缓存
           *
           * @param key    键
           * @param values 值 可以是多个
           * @return 成功个数
           */
          public long sSet(String key, Object... values) {
              try {
                  return redisTemplate.opsForSet().add(key, values);
              } catch (Exception e) {
                  e.printStackTrace();
                  return 0;
              }
          }
      
          /**
           * 将set数据放入缓存
           *
           * @param key    键
           * @param time   时间(秒)
           * @param values 值 可以是多个
           * @return 成功个数
           */
          public long sSetAndTime(String key, long time, Object... values) {
              try {
                  Long count = redisTemplate.opsForSet().add(key, values);
                  if (time > 0) expire(key, time);
                  return count;
              } catch (Exception e) {
                  e.printStackTrace();
                  return 0;
              }
          }
      
          /**
           * 获取set缓存的长度
           *
           * @param key 键
           * @return
           */
          public long sGetSetSize(String key) {
              try {
                  return redisTemplate.opsForSet().size(key);
              } catch (Exception e) {
                  e.printStackTrace();
                  return 0;
              }
          }
      
          /**
           * 移除值为value的
           *
           * @param key    键
           * @param values 值 可以是多个
           * @return 移除的个数
           */
          public long setRemove(String key, Object... values) {
              try {
                  Long count = redisTemplate.opsForSet().remove(key, values);
                  return count;
              } catch (Exception e) {
                  e.printStackTrace();
                  return 0;
              }
          }
          //===============================list=================================
      
          /**
           * 获取list缓存的内容
           *
           * @param key   键
           * @param start 开始
           * @param end   结束  0 到 -1代表所有值
           * @return
           */
          public List<Object> lGet(String key, long start, long end) {
              try {
                  return redisTemplate.opsForList().range(key, start, end);
              } catch (Exception e) {
                  e.printStackTrace();
                  return null;
              }
          }
      
          /**
           * 获取list缓存的长度
           *
           * @param key 键
           * @return
           */
          public long lGetListSize(String key) {
              try {
                  return redisTemplate.opsForList().size(key);
              } catch (Exception e) {
                  e.printStackTrace();
                  return 0;
              }
          }
      
          /**
           * 通过索引 获取list中的值
           *
           * @param key   键
           * @param index 索引  index>=0时, 0 表头,1 第二个元素,依次类推;index<0时,-1,表尾,-2倒数第二个元素,依次类推
           * @return
           */
          public Object lGetIndex(String key, long index) {
              try {
                  return redisTemplate.opsForList().index(key, index);
              } catch (Exception e) {
                  e.printStackTrace();
                  return null;
              }
          }
      
          /**
           * 将list放入缓存
           *
           * @param key   键
           * @param value 值
           * @return
           */
          public boolean lSet(String key, Object value) {
              try {
                  redisTemplate.opsForList().rightPush(key, value);
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * 将list放入缓存
           *
           * @param key   键
           * @param value 值
           * @param time  时间(秒)
           * @return
           */
          public boolean lSet(String key, Object value, long time) {
              try {
                  redisTemplate.opsForList().rightPush(key, value);
                  if (time > 0) expire(key, time);
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * 将list放入缓存
           *
           * @param key   键
           * @param value 值
           * @return
           */
          public boolean lSet(String key, List<Object> value) {
              try {
                  redisTemplate.opsForList().rightPushAll(key, value);
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * 将list放入缓存
           *
           * @param key   键
           * @param value 值
           * @param time  时间(秒)
           * @return
           */
          public boolean lSet(String key, List<Object> value, long time) {
              try {
                  redisTemplate.opsForList().rightPushAll(key, value);
                  if (time > 0) expire(key, time);
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * 根据索引修改list中的某条数据
           *
           * @param key   键
           * @param index 索引
           * @param value 值
           * @return
           */
          public boolean lUpdateIndex(String key, long index, Object value) {
              try {
                  redisTemplate.opsForList().set(key, index, value);
                  return true;
              } catch (Exception e) {
                  e.printStackTrace();
                  return false;
              }
          }
      
          /**
           * 移除N个值为value
           *
           * @param key   键
           * @param count 移除多少个
           * @param value 值
           * @return 移除的个数
           */
          public long lRemove(String key, long count, Object value) {
              try {
                  Long remove = redisTemplate.opsForList().remove(key, count, value);
                  return remove;
              } catch (Exception e) {
                  e.printStackTrace();
                  return 0;
              }
          }
      
      }
      

        






以上是关于SpringBoot+单机redis的主要内容,如果未能解决你的问题,请参考以下文章

SpringBoot+单机redis

SpringBoot缓存 --Redis单机缓存

springboot2.x版本整合redis(单机/集群)(使用lettuce)

Redis_02_Redis单机版搭建和SpringBoot的使用(实践开发类)

springboot 中单机 redis 实现分布式锁

SpringBoot系列教程之Redis集群环境配置