AI专业者开发社区 1 号成员
  •  0 回帖  •  2 浏览  •  5 个月前
 

Spring Boot 整合Redis

Spring Boot 整合 Redis

导入依赖

<!-- springboot 整合 redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!--guawa 工具类 -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>27.0.1-jre</version>
</dependency>

配置文件

spring:
  redis:
    database: 0
    # Redis 服务器地址 写你的 ip
    host: 0.0.0.0
    # Redis 服务器连接端口
    port: 6379
    # Redis 服务器连接密码（默认为空）
    password: 
    # 连接池最大连接数（使用负值表示没有限制  类似于 mysql 的连接池
    jedis:
      pool:
        max-active: 200
        # 连接池最大阻塞等待时间（使用负值表示没有限制） 表示连接池的链接拿完了 现在去申请需要等待的时间
        max-wait: -1
        # 连接池中的最大空闲连接
        max-idle: 10
        # 连接池中的最小空闲连接
        min-idle: 0
  # 连接超时时间（毫秒） 去链接 redis 服务端
    timeout: 6000

配置 RedisTemplate

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate<String,Object> redisTemplate = new RedisTemplate<>();
        // 设置工厂链接
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 设置自定义序列化方式
        setSerializeConfig(redisTemplate, redisConnectionFactory);
        return redisTemplate;
    }

<span class="hljs-keyword">private</span> <span class="hljs-keyword">void</span> <span class="hljs-title function_">setSerializeConfig</span><span class="hljs-params">(RedisTemplate&lt;String, Object&gt; redisTemplate, RedisConnectionFactory redisConnectionFactory)</span> {
    <span class="hljs-comment">//对字符串采取普通的序列化方式 适用于key 因为我们一般采取简单字符串作为key</span>
    <span class="hljs-type">StringRedisSerializer</span> <span class="hljs-variable">stringRedisSerializer</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">StringRedisSerializer</span>();
    <span class="hljs-comment">//普通的string类型的key采用 普通序列化方式</span>
    redisTemplate.setKeySerializer(stringRedisSerializer);
    <span class="hljs-comment">//普通hash类型的key也使用 普通序列化方式</span>
    redisTemplate.setHashKeySerializer(stringRedisSerializer);
    <span class="hljs-comment">//解决查询缓存转换异常的问题  大家不能理解就直接用就可以了 这是springboot自带的jackson序列化类，但是会有一定问题</span>
    <span class="hljs-type">Jackson2JsonRedisSerializer</span> <span class="hljs-variable">jackson2JsonRedisSerializer</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">Jackson2JsonRedisSerializer</span>(Object.class);
    <span class="hljs-type">ObjectMapper</span> <span class="hljs-variable">om</span> <span class="hljs-operator">=</span> <span class="hljs-keyword">new</span> <span class="hljs-title class_">ObjectMapper</span>();
    om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
    om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
    jackson2JsonRedisSerializer.setObjectMapper(om);
    <span class="hljs-comment">//普通的值采用jackson方式自动序列化</span>
    redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
    <span class="hljs-comment">//hash类型的值也采用jackson方式序列化</span>
    redisTemplate.setHashValueSerializer(jackson2JsonRedisSerializer);
    <span class="hljs-comment">//属性设置完成afterPropertiesSet就会被调用，可以对设置不成功的做一些默认处理</span>
    redisTemplate.afterPropertiesSet();
}



}

Redis 工具类

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;

import java.util.*;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;


@Component
@Slf4j
public class RedisUtils {


<span class="hljs-meta">@Autowired</span>
<span class="hljs-keyword">private</span> RedisTemplate&lt;String,Object&gt; redisTemplate;

<span class="hljs-comment">/**
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@return</span> 获得值
 * redis有五种数据类型 opsForValue表示是操作字符串类型
 */</span>
<span class="hljs-keyword">public</span> Object <span class="hljs-title function_">get</span><span class="hljs-params">(String key)</span>{
    <span class="hljs-type">return</span>  <span class="hljs-variable">key</span> <span class="hljs-operator">=</span>= <span class="hljs-literal">null</span> ? <span class="hljs-literal">null</span> : redisTemplate.opsForValue().get(key);
}
<span class="hljs-comment">//本来只可以放入string类型，但是我们配置了自动序列化所以这儿可以传入object</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">set</span><span class="hljs-params">(String key,Object value)</span>{
    <span class="hljs-keyword">try</span>{
        redisTemplate.opsForValue().set(key,value);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
    }<span class="hljs-keyword">catch</span> (Exception e){
        log.error(<span class="hljs-string">"redis set value exception:{}"</span>,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
}

<span class="hljs-comment">/**
 * 原子操作
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> value
 * <span class="hljs-doctag">@param</span> expire 过期时间 秒
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">setex</span><span class="hljs-params">(String key,Object value,<span class="hljs-type">long</span> expire)</span>{
    <span class="hljs-keyword">try</span>{<span class="hljs-comment">//TimeUnit.SECONDS指定类型为秒</span>
        redisTemplate.opsForValue().set(key,value,expire, TimeUnit.SECONDS);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
    }<span class="hljs-keyword">catch</span> (Exception e){
        log.error(<span class="hljs-string">"redis set value and expire exception:{}"</span>,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
}

<span class="hljs-comment">/**
 * 非原子操作
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> expire
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">expire</span><span class="hljs-params">(String key,<span class="hljs-type">long</span> expire)</span>{
    <span class="hljs-keyword">try</span>{<span class="hljs-comment">//这儿没有ops什么的是因为每种数据类型都能设置过期时间</span>
        redisTemplate.expire(key,expire,TimeUnit.SECONDS);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
    }<span class="hljs-keyword">catch</span> (Exception e){
        log.error(<span class="hljs-string">"redis set key expire exception:{}"</span>,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
}

<span class="hljs-comment">/**
 *
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@return</span> 获取key的过期时间
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">long</span> <span class="hljs-title function_">ttl</span><span class="hljs-params">(String key)</span>{
    <span class="hljs-keyword">return</span> redisTemplate.getExpire(key);
}

<span class="hljs-comment">/**
 *
 * <span class="hljs-doctag">@param</span> keys 删除key 可变参数
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title function_">del</span><span class="hljs-params">(String ...keys)</span>{
    <span class="hljs-keyword">if</span>(keys!=<span class="hljs-literal">null</span>&amp;&amp;keys.length&gt;<span class="hljs-number">0</span>) {
        redisTemplate.delete((Collection&lt;String&gt;) CollectionUtils.arrayToList(keys));
    }
}

<span class="hljs-comment">/**
 *
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> step  传入正数 就是加多少 传入负数就是减多少
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">long</span> <span class="hljs-title function_">incrBy</span><span class="hljs-params">(String key,<span class="hljs-type">long</span> step)</span>{
    <span class="hljs-keyword">return</span> redisTemplate.opsForValue().increment(key,step);
}

<span class="hljs-comment">/**
 *
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> value
 * <span class="hljs-doctag">@return</span>  如果该key存在就返回false 设置不成功 key不存在就返回ture设置成功
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">setnx</span><span class="hljs-params">(String key,Object value)</span>{
    <span class="hljs-keyword">return</span> redisTemplate.opsForValue().setIfAbsent(key,value);
}

<span class="hljs-comment">/**
 *  原子操作
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> value
 * <span class="hljs-doctag">@param</span> expire  在上面方法加上过期时间设置
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">setnxAndExpire</span><span class="hljs-params">(String key,Object value,<span class="hljs-type">long</span> expire)</span>{
    <span class="hljs-keyword">return</span> redisTemplate.opsForValue().setIfAbsent(key,value,expire,TimeUnit.SECONDS);
}

<span class="hljs-comment">/**
 *
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> value
 * <span class="hljs-doctag">@return</span>  如果该key存在就返回之前的value  不存在就返回null
 */</span>
<span class="hljs-keyword">public</span> Object <span class="hljs-title function_">getAndSet</span><span class="hljs-params">(String key,Object value)</span>{
    <span class="hljs-keyword">return</span> redisTemplate.opsForValue().getAndSet(key,value);
}

<span class="hljs-comment">/**
 *
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@return</span> 判断key是否存在
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">hasKey</span><span class="hljs-params">(String key)</span>{
    <span class="hljs-keyword">return</span> redisTemplate.hasKey(key);
}

<span class="hljs-comment">/***list的长度**/</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">long</span> <span class="hljs-title function_">llen</span><span class="hljs-params">(String key)</span>{
    <span class="hljs-keyword">return</span> redisTemplate.opsForList().size(key);
}

<span class="hljs-comment">/**
 * 获取key中index位置的值，负数就反过来数，-1为最后一个
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> index
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> Object <span class="hljs-title function_">lgetByIndex</span><span class="hljs-params">(String key,<span class="hljs-type">long</span> index)</span>{
    <span class="hljs-keyword">try</span> {
        <span class="hljs-keyword">return</span> redisTemplate.opsForList().index(key, index);
    } <span class="hljs-keyword">catch</span> (Exception e) {
        log.error(<span class="hljs-string">"redis lgetByIndex error,key:{},index:{}exception:{}"</span>,key,index,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
    }
}
<span class="hljs-comment">/**
 * 将list放入缓存
 * <span class="hljs-doctag">@param</span> key 键
 * <span class="hljs-doctag">@param</span> value 值
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">lrpush</span><span class="hljs-params">(String key, Object value)</span> {
    <span class="hljs-keyword">try</span> {
        redisTemplate.opsForList().rightPush(key, value);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
    } <span class="hljs-keyword">catch</span> (Exception e) {
        log.error(<span class="hljs-string">"redis lrpush error,key:{},value:{}exception:{}"</span>,key,value,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
}
<span class="hljs-comment">/**
 * 将list放入缓存
 * <span class="hljs-doctag">@param</span> key 键
 * <span class="hljs-doctag">@param</span> value 值
 * <span class="hljs-doctag">@param</span> time 时间(秒)
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">lrpush</span><span class="hljs-params">(String key, Object value, <span class="hljs-type">long</span> time)</span> {
    <span class="hljs-keyword">try</span> {
        redisTemplate.opsForList().rightPush(key, value);
        <span class="hljs-keyword">if</span> (time &gt; <span class="hljs-number">0</span>)
            expire(key, time);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
    } <span class="hljs-keyword">catch</span> (Exception e) {
        log.error(<span class="hljs-string">"redis lrpush error,key:{},value:{},timeL{},exception:{}"</span>,key,value,time,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
}
<span class="hljs-comment">/**
 * 将list放入缓存
 * <span class="hljs-doctag">@param</span> key 键
 * <span class="hljs-doctag">@param</span> value 值
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">lrpush</span><span class="hljs-params">(String key, List&lt;Object&gt; value)</span> {
    <span class="hljs-keyword">try</span> {
        redisTemplate.opsForList().rightPushAll(key, value);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
    } <span class="hljs-keyword">catch</span> (Exception e) {
        log.error(<span class="hljs-string">"redis lrpush error,key:{},value:{},exception:{}"</span>,key,value,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
}
<span class="hljs-comment">/**
 * 将list放入缓存
 *
 * <span class="hljs-doctag">@param</span> key 键
 * <span class="hljs-doctag">@param</span> value 值
 * <span class="hljs-doctag">@param</span> time 时间(秒)
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">lrpush</span><span class="hljs-params">(String key, List&lt;Object&gt; value, <span class="hljs-type">long</span> time)</span> {
    <span class="hljs-keyword">try</span> {
        redisTemplate.opsForList().rightPushAll(key, value);
        <span class="hljs-keyword">if</span> (time &gt; <span class="hljs-number">0</span>)
            expire(key, time);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
    } <span class="hljs-keyword">catch</span> (Exception e) {
        log.error(<span class="hljs-string">"redis lrpush error,key:{},value:{},time:{},exception:{}"</span>,key,value,time,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
}
<span class="hljs-comment">/**
 * 根据索引修改list中的某条数据
 * <span class="hljs-doctag">@param</span> key 键
 * <span class="hljs-doctag">@param</span> index 索引
 * <span class="hljs-doctag">@param</span> value 值
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">lUpdateByIndex</span><span class="hljs-params">(String key, <span class="hljs-type">long</span> index, Object value)</span> {
    <span class="hljs-keyword">try</span> {
        redisTemplate.opsForList().set(key, index, value);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
    } <span class="hljs-keyword">catch</span> (Exception e) {
        log.error(<span class="hljs-string">"redis lUpdateByIndex error,key:{},index:{},value:{},exception:{}"</span>,key,index,value,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
}
<span class="hljs-comment">/**
 * 移除N个值为value
 * <span class="hljs-doctag">@param</span> key 键
 * <span class="hljs-doctag">@param</span> count 移除多少个
 * <span class="hljs-doctag">@param</span> value 值
 * <span class="hljs-doctag">@return</span> 移除的个数
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">long</span> <span class="hljs-title function_">lrem</span><span class="hljs-params">(String key, <span class="hljs-type">long</span> count, Object value)</span> {
    <span class="hljs-keyword">try</span> {
        <span class="hljs-type">Long</span> <span class="hljs-variable">remove</span> <span class="hljs-operator">=</span> redisTemplate.opsForList().remove(key, count, value);
        <span class="hljs-keyword">return</span> remove;
    } <span class="hljs-keyword">catch</span> (Exception e) {
        log.error(<span class="hljs-string">"redis lrem error,key:{},count:{},value:{},exception:{}"</span>,key,count,value,e);
        <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;
    }
}
<span class="hljs-comment">/*****hash数据类型方法   opsForHash表示是操作字符串类型*****/</span>

<span class="hljs-comment">/**
 * <span class="hljs-doctag">@param</span> key 健
 * <span class="hljs-doctag">@param</span> field 属性
 * <span class="hljs-doctag">@param</span> value 值
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">hset</span><span class="hljs-params">(String key, String field, Object value)</span> {
    <span class="hljs-keyword">try</span> {
        redisTemplate.opsForHash().put(key, field, value);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
    }<span class="hljs-keyword">catch</span> (Exception e){
        log.error(<span class="hljs-string">"redis hset eror,key:{},field:{},value:{}"</span>,key,field,value);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
}

<span class="hljs-comment">/**
 *
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> field
 * <span class="hljs-doctag">@param</span> value
 * <span class="hljs-doctag">@param</span> seconds(秒) 过期时间
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">hset</span><span class="hljs-params">(String key, String field, Object value,<span class="hljs-type">long</span> seconds)</span> {
    <span class="hljs-keyword">try</span> {
        redisTemplate.opsForHash().put(key, field, value);
        expire(key,seconds);<span class="hljs-comment">//调用通用方法设置过期时间</span>
        <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
    }<span class="hljs-keyword">catch</span> (Exception e){
        log.error(<span class="hljs-string">"redis hset and expire eror,key:{},field:{},value:{},exception:{}"</span>,key,field,value,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
}

<span class="hljs-comment">/**
 * 获取key中field属性的值
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> field
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> Object <span class="hljs-title function_">hget</span><span class="hljs-params">(String key,String field)</span>{
    <span class="hljs-keyword">return</span> redisTemplate.opsForHash().get(key,field);
}

<span class="hljs-comment">/**
 * 获取key中多个属性的键值对，这儿使用map来接收
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> fields
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> Map&lt;String,Object&gt; <span class="hljs-title function_">hmget</span><span class="hljs-params">(String key, String...fields)</span>{
    Map&lt;String,Object&gt; map =  <span class="hljs-keyword">new</span> <span class="hljs-title class_">HashMap</span>&lt;&gt;();
    <span class="hljs-keyword">for</span> (String field :fields){
        map.put(field,hget(key,field));
    }
    <span class="hljs-keyword">return</span> map;
}

<span class="hljs-comment">/**
 * <span class="hljs-doctag">@param</span> key 获得该key下的所有键值对
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> Map&lt;Object, Object&gt; <span class="hljs-title function_">hmget</span><span class="hljs-params">(String key)</span>{
    <span class="hljs-keyword">return</span> redisTemplate.opsForHash().entries(key);
}

<span class="hljs-comment">/**
 * <span class="hljs-doctag">@param</span> key 获得该key下的所有键值对
 * <span class="hljs-doctag">@return</span>
 */</span>



@Autowired
private JacksonUtil jacksonUtil;
//map----json 字符串 ----> 对象
public <T>T hmgetObject(String key,Class<T> tClass){
Map<Object, Object> hmget = hmget(key);
if(CollectionUtils.isEmpty(hmget)) return null;
// 查询到了 先把数据转成 json 字符串
String s = jacksonUtil.writeAsString(hmget);
// 再把 json 字符串转回对象
return  jacksonUtil.readValue(s,tClass);
}


<span class="hljs-comment">/**
 * <span class="hljs-doctag">@param</span> key 键
 * <span class="hljs-doctag">@param</span> map 对应多个键值
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">hmset</span><span class="hljs-params">(String key,Map&lt;Object,Object&gt; map)</span>{
    <span class="hljs-keyword">try</span> {
        redisTemplate.opsForHash().putAll(key, map);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
    }<span class="hljs-keyword">catch</span> (Exception e){
        log.error(<span class="hljs-string">"redis hmset eror,key:{},value:{},exception:{}"</span>,key,map,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
}
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">hmset</span><span class="hljs-params">(String key,Object object)</span>{
    <span class="hljs-keyword">try</span> {
        <span class="hljs-type">String</span> <span class="hljs-variable">s</span> <span class="hljs-operator">=</span> jacksonUtil.writeAsString(object);
        Map&lt;String, String&gt; map = jacksonUtil.readValueMap(s);
        redisTemplate.opsForHash().putAll(key, map);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
    }<span class="hljs-keyword">catch</span> (Exception e){
        log.error(<span class="hljs-string">"redis hmset eror,key:{},object:{},exception:{}"</span>,key,object,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
}
<span class="hljs-comment">/**
 * <span class="hljs-doctag">@param</span> key 键
 * <span class="hljs-doctag">@param</span> map 对应多个键值
 *  <span class="hljs-doctag">@param</span> seconds 过期时间(秒)
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">hmset</span><span class="hljs-params">(String key,Map&lt;String,Object&gt; map,<span class="hljs-type">long</span> seconds)</span>{
    <span class="hljs-keyword">try</span> {
        redisTemplate.opsForHash().putAll(key, map);
        expire(key,seconds);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">true</span>;
    }<span class="hljs-keyword">catch</span> (Exception e){
        log.error(<span class="hljs-string">"redis hmset eror,key:{},value:{},expireTime,exception:{}"</span>,key,map,seconds,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
}

<span class="hljs-comment">/**
 *删除key中的属性
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> fields
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title function_">hdel</span><span class="hljs-params">(String key,Object...fields)</span>{
    redisTemplate.opsForHash().delete(key,fields);
}

<span class="hljs-comment">/**
 * 判断key中是否存在某属性
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> field
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">hHashKey</span><span class="hljs-params">(String key,String field)</span>{
    <span class="hljs-keyword">return</span> redisTemplate.opsForHash().hasKey(key,field);
}

<span class="hljs-comment">/**
 * 对key中filed的value增加多少 如果是减少就传入负数
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> field
 * <span class="hljs-doctag">@param</span> step 正数增加，负数减少
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">double</span> <span class="hljs-title function_">hincr</span><span class="hljs-params">(String key,String field,<span class="hljs-type">double</span> step)</span>{
    <span class="hljs-keyword">return</span> redisTemplate.opsForHash().increment(key,field,step);
}

<span class="hljs-comment">/**
 * key中多少个
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">long</span> <span class="hljs-title function_">hlen</span><span class="hljs-params">(String key)</span>{
    <span class="hljs-keyword">return</span> redisTemplate.opsForHash().size(key);
}
<span class="hljs-comment">/******其他方法用到在增加********/</span>

<span class="hljs-comment">/***set集合***/</span>
<span class="hljs-comment">/**
 * 获取key中所有元素
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> Set&lt;Object&gt; <span class="hljs-title function_">sgetAll</span><span class="hljs-params">(String key)</span>{
    <span class="hljs-keyword">try</span> {
        <span class="hljs-keyword">return</span> redisTemplate.opsForSet().members(key);
    }<span class="hljs-keyword">catch</span> (Exception e){
        log.error(<span class="hljs-string">"redis sgetAll error,key:{},exception:{}"</span>,key,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
    }
}

<span class="hljs-comment">/**
 * 判断value是否在key中
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> value
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">boolean</span> <span class="hljs-title function_">sexists</span><span class="hljs-params">(String key,Object value)</span>{
    <span class="hljs-keyword">try</span> {
        <span class="hljs-keyword">return</span> redisTemplate.opsForSet().isMember(key,value);
    }<span class="hljs-keyword">catch</span> (Exception e){
        log.error(<span class="hljs-string">"redis sexists error,key:{},value:{},exception:{}"</span>,key,value,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
}

<span class="hljs-comment">/**
 * 插入多个元素
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> values
 * <span class="hljs-doctag">@return</span>  成功的个数
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">long</span> <span class="hljs-title function_">sset</span><span class="hljs-params">(String key ,Object...values)</span>{
    <span class="hljs-keyword">try</span> {
        <span class="hljs-keyword">return</span> redisTemplate.opsForSet().add(key,values);
    }<span class="hljs-keyword">catch</span> (Exception e){
        log.error(<span class="hljs-string">"redis sset error,key:{},value:{},values:{},exception:{}"</span>,key,values,e);
        <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;
    }
}

<span class="hljs-comment">/**
 * 添加元素并设置过期时间  （非原子操作）
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> time
 * <span class="hljs-doctag">@param</span> values
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">long</span> <span class="hljs-title function_">sset</span><span class="hljs-params">(String key ,<span class="hljs-type">long</span> time,Object...values)</span>{
    <span class="hljs-keyword">try</span> {
        <span class="hljs-type">long</span> <span class="hljs-variable">count</span> <span class="hljs-operator">=</span> redisTemplate.opsForSet().add(key,values);
        expire(key,time);
        <span class="hljs-keyword">return</span> count;
    }<span class="hljs-keyword">catch</span> (Exception e){
        log.error(<span class="hljs-string">"redis sset error,key:{},value:{},values:{},exception:{}"</span>,key,values,e);
        <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;
    }
}

<span class="hljs-comment">/**
 * 获取set的长度
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">long</span> <span class="hljs-title function_">sgetSize</span><span class="hljs-params">(String key)</span>{
    <span class="hljs-keyword">try</span> {
        <span class="hljs-keyword">return</span> redisTemplate.opsForSet().size(key);
    }<span class="hljs-keyword">catch</span> (Exception e){
        log.error(<span class="hljs-string">"redis sgetSize error,key:{},exception:{}"</span>,key,e);
        <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;
    }
}
<span class="hljs-comment">/**
 * 移除值为value的
 * <span class="hljs-doctag">@param</span> key 键
 * <span class="hljs-doctag">@param</span> values 值 可以是多个
 * <span class="hljs-doctag">@return</span> 移除的个数
 */</span>
<span class="hljs-keyword">public</span> <span class="hljs-type">long</span> <span class="hljs-title function_">sRemove</span><span class="hljs-params">(String key, Object... values)</span> {
    <span class="hljs-keyword">try</span> {
        <span class="hljs-type">Long</span> <span class="hljs-variable">count</span> <span class="hljs-operator">=</span> redisTemplate.opsForSet().remove(key, values);
        <span class="hljs-keyword">return</span> count;
    } <span class="hljs-keyword">catch</span> (Exception e) {
        log.error(<span class="hljs-string">"redis sRemove error,key:{},values:{},exception:{}"</span>,key,values,e);
        <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;
    }
}

<span class="hljs-comment">/**
 * 随机取count个元素  count为正数就取不重复的  负数就有可能重复
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> count
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span> List&lt;Object&gt; <span class="hljs-title function_">sRandom</span><span class="hljs-params">(String key,<span class="hljs-type">long</span> count)</span> {
    <span class="hljs-keyword">try</span> {
        <span class="hljs-keyword">return</span>  redisTemplate.opsForSet().randomMembers(key,count);
    } <span class="hljs-keyword">catch</span> (Exception e) {
        log.error(<span class="hljs-string">"redis sRandom error,key:{},count:{},exception:{}"</span>,key,count,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
    }
}
<span class="hljs-comment">/****zset工具类***/</span>
<span class="hljs-comment">/**
 * 添加元素
 * <span class="hljs-doctag">@param</span> key
 * <span class="hljs-doctag">@param</span> member
 * <span class="hljs-doctag">@param</span> score
 * <span class="hljs-doctag">@return</span>
 */</span>
<span class="hljs-keyword">public</span>  <span class="hljs-type">boolean</span> <span class="hljs-title function_">zadd</span><span class="hljs-params">(String key,Object member,<span class="hljs-type">double</span> score)</span>{
    <span class="hljs-keyword">try</span> {
        <span class="hljs-keyword">return</span>  redisTemplate.opsForZSet().add(key,member,score);
    } <span class="hljs-keyword">catch</span> (Exception e) {
        log.error(<span class="hljs-string">"redis zadd error,key:{},value:{},score:{},exception:{}"</span>,key,member,score,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">false</span>;
    }
}
<span class="hljs-keyword">public</span>  Set&lt;String&gt; <span class="hljs-title function_">zrange</span><span class="hljs-params">(String key,<span class="hljs-type">int</span> start,<span class="hljs-type">int</span> end)</span>{

    <span class="hljs-keyword">try</span> {
        Set&lt;Object&gt; range = redisTemplate.opsForZSet().
                range(key, start, end);
        <span class="hljs-keyword">if</span>(range==<span class="hljs-literal">null</span>||range.size()==<span class="hljs-number">0</span>) <span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
        <span class="hljs-keyword">return</span>   range.stream().
                map(o-&gt;(String)o).collect(Collectors.toSet());
    } <span class="hljs-keyword">catch</span> (Exception e) {
        log.error(<span class="hljs-string">"redis zrange error,key:{},start:{},end:{},exception:{}"</span>,
                key,start,end,e);
        <span class="hljs-keyword">return</span> <span class="hljs-literal">null</span>;
    }
}



/*** 这个有点多，就不一一写了 大家用到什么去补全剩下的 API


    

  • Set< V > range(K key, long start, long end); 下标范围取
    • 

  • Long remove(K key, Object… values); 删除元素
    *Double incrementScore(K key, V value, double delta); 增加分数
    • 

  • Long rank(K key, Object o); 当前元素的位置
    *Long reverseRank(K key, Object o); 反过来的位置
    *Set< TypedTuple< V >> rangeWithScores(K key, long start, long end); 下标取出来带分数
    • 

  • Set< V > rangeByScore(K key, double min, double max); 根据分数取
    • 

  • Set< TypedTuple< V >> rangeByScoreWithScores(K key, double min, double max); 根据分数取 并携带分数
    • 

  • Set< TypedTuple< V >> rangeByScoreWithScores(K key, double min, double max, long offset, long count); 翻页
    *Long count(K key, double min, double max); 统计分数段的个数
    *Long size(K key); 个数  底层就是 card
    • 

  • Long zCard(K key); 个数
    • 

  • Double score(K key, Object o); 查看某个元素的分数
    • 

  • Long removeRange(K key, long start, long end); 根据下标删除某个范围
    • 

  • Long removeRangeByScore(K key, double min, double max); 删除某个分数段
    • 

  • 等等
    • 

  • **/
    }