转载

Redis 在SpringBoot 中的使用

Redis 支持多种 java 客户端，支持列表参考官网

Jedis 是redis官方推荐的java客户端

在SpringBoot 中使用 Redis 简单分为三步

引入依赖
配置 redis
使用 redis

引入依赖

springboot 2.0.0.RELEASE 之前，data-redis 底层客户端为 jedis

从springboot 2.0.0.RELEASE 开始底层区分两个不同的实现， jedis及lettuce ，默认采用 lettuce

<!-- redis依赖 -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
复制代码

配置

底层 redis 客户端的变更，影响到了上次配置的改变，redis 因此也分为两种

springboot 2.0.0.RELEASE 之前配置

spring.redis.database=0
spring.redis.host=192.168.99.100
spring.redis.port=6379
# redis服务器的登录密码 没有可以不配置
#spring.redis.password= 
spring.redis.pool.max-active=8
spring.redis.pool.max-idle=8
spring.redis.pool.max-wait=-1
spring.redis.pool.min-idle=0
# redis 服务名称
#spring.redis.sentinel.master=
# 主机列表，格式为 host:port， 多个用逗号分隔  
#spring.redis.sentinel.nodes= 
spring.redis.timeout=10
复制代码

springboot 2.0.0.RELEASE 之后配置

spring.redis.database=0
spring.redis.host=192.168.99.100
spring.redis.port=6379
# redis服务器的登录密码 没有可以不配置
#spring.redis.password= 
spring.redis.lettuce.pool.max-active=8
spring.redis.lettuce.pool.max-idle=8
spring.redis.lettuce.pool.max-wait=-1ms
spring.redis.lettuce.pool.min-idle=0
# redis 服务名称
#spring.redis.sentinel.master= 
# 主机列表，格式为 host:port， 多个用逗号分隔  
#spring.redis.sentinel.nodes= 
spring.redis.timeout=100ms
复制代码

主要变动

springboot 2.0.0.RELEASE 之后 pool 改为 lettuce.pool

公共配置 spring.redis.timeout 的参数改为 Duration 类型，需要增加 时间单位参数 如毫秒ms 秒s

使用

redis 中一般有两种数据类型使用最多 String 和 hash，下面以这两种数据类型为例简单实例 redis 在 Springboot 中的使用

string数据类型

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Service
public class RedisServiceImpl {

    @Autowired
    private RedisTemplate redisTemplate;

    /**
     * 添加 Redis术语中 string 类型的数据
     *
     * @param key   String类型
     * @param value 任意类型，但必须实现序列化接口
     * @return
     */
    public boolean set(final String key, Object value) {
        boolean result = false;
        try {
            // 创建对简单值(Redis术语中的string类型)执行操作的对象
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 添加 Redis术语中 string 类型的数据,并设置超时
     *
     * @param key        String类型
     * @param value      任意类型，但必须实现序列化接口
     * @param expireTime 单位分钟
     * @return
     */
    public boolean set(final String key, Object value, Long expireTime) {
        boolean result = false;
        try {
            // 创建对简单值(Redis术语中的string类型)执行操作的对象
            ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value);
            redisTemplate.expire(key, expireTime, TimeUnit.MINUTES);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 判断 key 是否存在
     *
     * @param key
     * @return
     */
    public boolean existsKey(final String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * 根据( Redis 术语中 string 类型的) key 获取值,如果出现异常则返回null
     *
     * @param key
     * @param type
     * @param <T>  存入 redis 时的类型
     * @return
     */
    public <T> T getValue(final String key, Class<T> type) {
        Object result = null;
        ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();
        try {
            result = operations.get(key);
            if (result == null) {
                return null;
            }
            // 将 Object 类型强转成 type 对应的类型
            return type.cast(result);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 删除对应的value
     *
     * @param key
     */
    public void removeKey(final String key) {
        // 检查 key 是否存在
        if (existsKey(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 批量删除对应的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            removeKey(key);
        }
    }

    /**
     * 批量删除key
     *
     * @param pattern
     */
    public void removePattern(final String pattern) {
        // 获取所有匹配的键
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys != null && keys.size() > 0) {
            redisTemplate.delete(keys);
        }
    }
}
复制代码

hash 数据类型

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.io.Serializable;
import java.util.Set;

@Service
public class RedisServiceImpl {

    @Autowired
    private RedisTemplate redisTemplate;


    /**
     * 添加 Redis 术语中 hash 类型的数据
     *
     * @param key
     * @param hashKey string 类型
     * @param value   任意类型，但必须实现序列化接口
     * @return
     */
    public boolean setHash(String key, String hashKey, Object value) {
        boolean result = false;
        try {
            // 创建对 hash 值(Redis术语中的 hash 类型)执行操作的对象
            HashOperations<String, String, Object> hashOperations = redisTemplate.opsForHash();
            hashOperations.put(key, hashKey, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }


    /**
     * 判断redis key中是否有hashKey对应的value
     *
     * @param key
     * @return
     */
    public boolean existsHashKey(String key, String hashKey) {
        return redisTemplate.opsForHash().hasKey(key, hashKey);
    }


    /**
     * 根据key，hashKey读取value
     *
     * @param key
     * @return
     */
    public Object getHashValue(final String key, final String hashKey) {
        // 创建对 hash 值(Redis术语中的 hash 类型)执行操作的对象
        HashOperations<String, String, Object> hashOperations = redisTemplate.opsForHash();
        try {
            return hashOperations.get(key, hashKey);
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 判断 key 是否存在
     *
     * @param key
     * @return
     */
    public boolean existsKey(final String key) {
        return redisTemplate.hasKey(key);
    }
    
    /**
     * 删除对应的value
     *
     * @param key
     */
    public void removeKey(final String key) {
        // 检查 key 是否存在
        if (existsKey(key)) {
            redisTemplate.delete(key);
        }
    }

    /**
     * 批量删除对应的value
     *
     * @param keys
     */
    public void remove(final String... keys) {
        for (String key : keys) {
            removeKey(key);
        }
    }

    /**
     * 批量删除key
     *
     * @param pattern
     */
    public void removePattern(final String pattern) {
        // 获取所有匹配的键
        Set<Serializable> keys = redisTemplate.keys(pattern);
        if (keys != null && keys.size() > 0) {
            redisTemplate.delete(keys);
        }
    }


    /**
     * 删除对应的key的指定hashKey
     *
     * @param key
     */
    public void removeHashKey(final String key, final String hashKey) {
        if (existsHashKey(key, hashKey)) {
            redisTemplate.opsForHash().delete(key, hashKey);
            ;
        }
    }

}
复制代码

原文 https://juejin.im/post/5d6739505188250a98580dbf

正文到此结束