springboot集成redis

springboot集成redis 为了方便今后自己做项目的时候好用所有随手记录一下
注:springboot2.x以后,原理底层使用的jedis替换成了lettuce
因为lettuce效率更高
jedis：采用直连,多个线程的话,是不安全的,如果想要避免不安全的,使用jedis pool连接池!更新BIO模式

lettuce:底层采用netty,实列可以再多个线程中共享,不存在线程不安全的情况,可以减少线程数据,更新NIO模式
第一步:
导入jar包

还需要在yml配置文件里配置redis ip 和端口 如果有密码也需要配上
第二步
接着我们去写一个redis配置类因为覆盖springboot提供的redisTemplate因为它原来的这个redis模板他对对象和中文存储没有序列化所有我们需要自己覆盖重新写一下
//这是一个redis配置的固定模板

@Configuration
public class RedisConfig {
@Bean
  public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
    RedisTemplate<String,Object> template = new RedisTemplate<>();
    template.setConnectionFactory(redisConnectionFactory);
    //Json序列化配置 首先我们要用我们的json去解析我们的任意对象
    Jackson2JsonRedisSerializer<Object> objectJackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
    //对json序列化的时候我们要用我们的ObjectMapper对我们的json进行一波转义
    ObjectMapper om = new ObjectMapper();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    //enableDefaultTyping已经过期 我们使用 activateDefaultTyping
    om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
   // om.activateDefaultTyping(ObjectMapper.DefaultTyping.OBJECT_AND_NON_CONCRETE);
    //转完之后我们就可以使用了
    objectJackson2JsonRedisSerializer.setObjectMapper(om);
    //String的序列化
    StringRedisSerializer serializer = new StringRedisSerializer();
    //给我们的数据格式配置序列化
    //所有key采用string序列化方式
    template.setKeySerializer(serializer);
    //hash的key也采用string的序列化方式
    template.setHashKeySerializer(serializer);
    //value序列化方式采用jsckson
    template.setValueSerializer(objectJackson2JsonRedisSerializer);
    //hash的value也采用jackson
    template.setHashValueSerializer(objectJackson2JsonRedisSerializer);
    //将我们配置的序列化设置
    template.afterPropertiesSet();
    return  template;
}
}

我们配置完redisTemplate，如果在项目中使用的时候注入redisTemplate的时候还是用的springboot给我们提供的,
那么我们需要在此redisTemplate上加注解
![在这里插入图片描述](https://img-blog.csdnimg.cn/20200723015102682.png#pic_center)

**第三步**
配置redisUtils工具类
以下是我简单配置的几个操作接口,如果有不足的 需自己补充就可以用

```java
@Component
public class RedisUtils {
//注入我们自己写的redisTemplate
    @Autowired
    @Qualifier("redisTemplate")
    private  RedisTemplate redisTemplate;
    /**
     * 指定缓存失效时间
     * key键
     * time 时间(秒)
     */
    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 键 不能为null
     * 时间(秒) 返回0代表永久有效
     */
    public long getExpire(String key){
      return    redisTemplate.getExpire(key,TimeUnit.SECONDS);
    }
    /**
     * 判断key是否存在
     * key键
     * true表示存在
     * false表示不存在
     */
    public boolean haskey(String key){
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return  false;
        }
    }
    /**
     * 删除key 可以删除多个或一个
     */
    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----------------------------
    /**
     * 普通缓存获取 string数据格式
     */
    public Object get(String key){
    return  key==null ? null :redisTemplate.opsForValue().get(key);
    }
    /**
     * 普通缓存存入
     * key 键
     * value
     * true 成功 false 失败
     */
    public boolean   set(String key,Object value){
        try {
            redisTemplate.opsForValue().set(key,value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
    /**
     * 普通缓存放入设置过期时间
     * key 键
     * value 值
     * time 时间(秒)
     */
    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;
        }
    }
    /**
     * 递增
     * key  键
     * delta 要增加及(必须大于0)
     */
    public  long incr(String key,long delta){
        if (delta<0){
            throw new RuntimeException("递增因子必须大于0");
        }else {
            return redisTemplate.opsForValue().increment(key,delta);
        }
    }
    /**
     * 递减
     *  key  键
     delta 要增加及(必须大于0)
     */
    public  long decr(String key,long delta){
        if (delta<0){
            throw new RuntimeException("递减因子必须大于0");
        }else {
            return redisTemplate.opsForValue().increment(key,-delta);
        }
    }
//--------------------map------------------------------
    /**
     * hashGet
     * key 不能为空
     * item (小key) 不能为空
     * （根据大key和小key获取指定的值）
     */
    public Object hget(String key,String item){
        return  redisTemplate.opsForHash().get(key,item);
    }
    /**
     * 根据大key获所有的值
     * key 键
     */
    public Map<Object,Object> hmget(String key){
        return redisTemplate.opsForHash().entries(key);
    }
    /**
     * hashset
     * key 键
     * map 对应多个值
     */
    public boolean hmset(String key,Map<Object,Object> map){
        try {
              redisTemplate.opsForHash().putAll(key,map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return  false;
        }
    }
    /**
     * hashget 设置过期时间
     * key 键
     * map 对应多个键值
     * 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;
        }
    }
    /**
     * 向同一张表中放入数据,如果不存在则创建
     * key键
     * item
     *  项
     *  value 值
     *  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表放入数据
     * key 键
     * item 项
     * value 值
     * time 时间(秒) 注意 这里:如果存在hash表有时间,这里将会替代原有的时间
     * 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;
        }
    }
}

最后测试