springboot单机版redis的连接并创建utils

1.jar包

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>

2.config 的配置文件

    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.CachingConfigurerSupport;
    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.connection.jedis.JedisConnectionFactory;
    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;

    @Configuration
    @EnableCaching
    public class RedisConfig extends CachingConfigurerSupport {

        private static String host="127.0.0.1";

        private static int port = 6379;

        private static int timeout=3000;
        @Bean
        public KeyGenerator wiselyKeyGenerator(){
            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 JedisConnectionFactory redisConnectionFactory() {
            JedisConnectionFactory factory = new JedisConnectionFactory();
            factory.setHostName(host);
            factory.setPort(port);
            factory.setTimeout(timeout); //设置连接超时时间
            return factory;
        }
        @Bean
        public CacheManager cacheManager(RedisTemplate redisTemplate) {
            RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
            // Number of seconds before expiration. Defaults to unlimited (0)
            cacheManager.setDefaultExpiration(10); //设置key-value超时时间
            return cacheManager;
        }
        @Bean
        public RedisTemplate<String, String> redisTemplate(RedisConnectionFactory factory) {
            StringRedisTemplate template = new StringRedisTemplate(factory);
            setSerializer(template); //设置序列化工具，这样ReportBean不需要实现Serializable接口
            template.afterPropertiesSet();
            return 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);
        }

    }

3.utils的书写

public class RedisUtils {

   private RedisTemplate redisTemplate;

public void setRedisTemplate(RedisTemplate redisTemplate) {
    this.redisTemplate = redisTemplate;
}

public  String  buildStringToken(String preString , String token){
    StringBuilder sb = new StringBuilder();
    sb.append(preString);
    sb.append(":");
    sb.append(token);
    return  sb.toString();
}

/**
 * 写入缓存
 * @param key
 * @param value
 * @return
 */
public boolean set(final String key, Object value) {
    boolean result = false;
    try {
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        operations.set(key, value);
        result = true;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return result;
}
/**
 * 写入缓存设置时效时间
 * @param key
 * @param value
 * @return
 */
public boolean set(final String key, Object value, Long expireTime ,TimeUnit timeUnit) {
    boolean result = false;
    try {
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        operations.set(key, value,5555L,TimeUnit.DAYS);
        redisTemplate.expire(key, expireTime, timeUnit);
        result = true;
    } catch (Exception e) {
        e.printStackTrace();
    }
    return result;
}
/**
 * 批量删除对应的value
 * @param keys
 */
public void remove(final String... keys) {
    for (String key : keys) {
        remove(key);
    }
}

/**
 * 批量删除key
 * @param pattern
 */
public void removePattern(final String pattern) {
    Set<Serializable> keys = redisTemplate.keys(pattern);
    if (keys.size() > 0){
        redisTemplate.delete(keys);
    }
}
/**
 * 删除对应的value
 * @param key
 */
public void remove(final String key) {
    if (exists(key)) {
        redisTemplate.delete(key);
    }
}
/**
 * 判断缓存中是否有对应的value
 * @param key
 * @return
 */
public boolean exists(final String key) {
    return redisTemplate.hasKey(key);
}
/**
 * 读取缓存
 * @param key
 * @return
 */
public Object get(final String key) {
    Object result = null;
    ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
    result = operations.get(key);
    return result;
}

/**
 * 哈希 添加
 * @param key
 * @param hashKey
 * @param value
 */
public void hmSet(String key, Object hashKey, Object value){
    HashOperations<String, Object, Object> hash = redisTemplate.opsForHash();
    hash.put(key,hashKey,value);
}

/**
 * 哈希获取数据
 * @param key
 * @param hashKey
 * @return
 */
public Object hmGet(String key, Object hashKey){
    HashOperations<String, Object, Object>  hash = redisTemplate.opsForHash();
    return hash.get(key,hashKey);
}

/**
 * 列表添加
 * @param k
 * @param v
 */
public void lPush(String k,Object v){
    ListOperations<String, Object> list = redisTemplate.opsForList();
    list.rightPush(k,v);
}

/**
 * 列表获取
 * @param k
 * @param l
 * @param l1
 * @return
 */
public List<Object> lRange(String k, long l, long l1){
    ListOperations<String, Object> list = redisTemplate.opsForList();
    return list.range(k,l,l1);
}

/**
 * 集合添加
 * @param key
 * @param value
 */
public void add(String key,Object value){
    SetOperations<String, Object> set = redisTemplate.opsForSet();
    set.add(key,value);
}

/**
 * 集合获取
 * @param key
 * @return
 */
public Set<Object> setMembers(String key){
    SetOperations<String, Object> set = redisTemplate.opsForSet();
    return set.members(key);
}

/**
 * 有序集合添加
 * @param key
 * @param value
 * @param scoure
 */
public void zAdd(String key,Object value,double scoure){
    ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
    zset.add(key,value,scoure);
}

/**
 * 有序集合获取
 * @param key
 * @param scoure
 * @param scoure1
 * @return
 */
    public Set<Object> rangeByScore(String key,double scoure,double scoure1){
        ZSetOperations<String, Object> zset = redisTemplate.opsForZSet();
        return zset.rangeByScore(key, scoure, scoure1);
    }
}