Spring Boot整合redis

1. 在pom.xml中添加依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2. 配置yml文件

spring:
  redis:
    database: 0
    port: 6379               # Redis服务器连接端口
    host: localhost          # Redis服务器地址
    password:                # Redis服务器连接密码（默认为空）

3. 配置RedisConfig

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
public class RedisConfig {
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(factory);
        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);
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

4. 配置Redis工具类RedisUtil

import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil {

    @Resource
    @Qualifier("redisTemplate")
    private RedisTemplate redisTemplate;

    /**
     * 普通缓存放入
     *
     * @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将设置无限期
     * @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;
        }
    }

    /**
     * 如果该 key 已经存在，则不改变其值，不存在则将该 key 放入缓存
     *
     * @param key   键
     * @param value 值
     * @return 如果该 key 存在就返回 false,如果该 key不存在就返回 ture
     */
    public boolean setIfAbsent(String key, Object value) {
        return redisTemplate.opsForValue().setIfAbsent(key, value);
    }

    /**
     * 如果该 key 已经存在，则不改变其值，不存在则将该 key 放入缓存并设置过期时间
     *
     * @param key    键
     * @param value  值
     * @param expire 过期时间
     * @return 如果该 key 存在就返回 false,如果该 key不存在就返回 ture
     */
    public boolean setIfAbsentExpire(String key, Object value, long expire) {
        return redisTemplate.opsForValue().setIfAbsent(key, value, expire, TimeUnit.SECONDS);
    }

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 判断 key 是否存在
     *
     * @param key 键
     * @return true 存在 false 不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 获取 Key 的类型
     *
     * @param key 键
     * @return Key 的类型
     */
    public String type(String key) {
        DataType dataType = redisTemplate.type(key);
        assert dataType != null;
        return dataType.code();
    }

    /**
     * 设置缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return 是否设置成功, 如果该 key 不存在，不会自动将该 key 放入缓存，但仍然返回 true
     */
    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 时间(秒) 返回-1为永久有效,-2表示不存在该 key
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 删除 key
     *
     * @param key 键
     * @return 被删除的 key 的数量,不包括本来就不存在的 key
     */
    public Long delete(String... key) {
        if (key == null || key.length < 1) {
            return 0L;
        }
        return redisTemplate.delete(Arrays.asList(key));
    }

    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几
     * @return 增加后的 key 的值
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几
     * @return 减少后的 key 的值
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    /**
     * 获取所有的 key
     *
     * @return 所有的 key
     */
    public Set<String> keys() {
        return redisTemplate.keys("*");
    }

    /**
     * 获取所有的 String 类型的 key 及他们对应的value
     *
     * @return 所有的 String 类型的 key 及他们对应的value
     */
    public Set<Map<Object, Object>> getKeysAndValue() {
        Set<String> keys = keys();
        Set<Map<Object, Object>> set = new HashSet<>();
        for (String s : keys) {
            Map<Object, Object> hashMap = new HashMap<>();
            hashMap.put(s, get(s));
            set.add(hashMap);
        }
        return set;
    }

    /**
     * hash类型缓存放入
     *
     * @param key     键
     * @param hashKey 哈希键
     * @param value   值
     * @return true 成功 false 失败
     */
    public boolean hashSet(String key, Object hashKey, Object value) {
        try {
            redisTemplate.opsForHash().put(key, hashKey, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 如果该 hashKey 已经存在，则不改变其值，不存在则将该 hashKey 放入缓存
     *
     * @param key     键
     * @param hashKey 哈希键
     * @param value   值
     * @return 如果该 hashKey 存在就返回 false,如果该 hashKey 不存在就返回ture
     */
    public boolean hashSetIfAbsent(String key, Object hashKey, Object value) {
        return redisTemplate.opsForHash().putIfAbsent(key, hashKey, value);
    }

    /**
     * hash类型缓存获取 hashKey
     *
     * @param key     键
     * @param hashKey 哈希键
     * @return 值
     */
    public Object hashGet(String key, Object hashKey) {
        return key == null ? null : redisTemplate.opsForHash().get(key, hashKey);
    }

    /**
     * 获取该 key 对应的所有的 hashKey
     *
     * @param key 键
     * @return 该 key 对应的所有的 hashKey
     */
    public Set<String> hashKeys(String key) {
        return redisTemplate.opsForHash().keys(key);
    }

    /**
     * hash类型缓存获取该 key 对应的所有的 hashKey-value 对
     *
     * @param key 键
     * @return 该 key 对应的所有的 hashKey-value 对
     */
    public Map<Object, Object> hashGetAll(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 判断 hashKey 是否存在
     *
     * @param key     键
     * @param hashKey 哈希键
     * @return true 存在 false 不存在
     */
    public boolean hashExists(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }


    /**
     * 删除 hashKey
     *
     * @param key     键
     * @param hashKey 哈希键
     * @return 被删除的 hashKey 的数量,不包括本来就不存在的 hashKey
     */
    public Long hashDelete(String key, Object... hashKey) {
        return redisTemplate.opsForHash().delete(key, hashKey);
    }

    /**
     * 递增
     *
     * @param key     键
     * @param hashKey 哈希键
     * @param delta   要增加几
     * @return 增加后的 hashKey 的值
     */
    public long hashIncr(String key, Object hashKey, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForHash().increment(key, hashKey, delta);
    }

    /**
     * 递减
     *
     * @param key     键
     * @param hashKey 哈希键
     * @param delta   要减少几
     * @return 减少后的 hashKey 的值
     */
    public long hashDecr(String key, Object hashKey, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForHash().increment(key, hashKey, -delta);
    }
}