Spring Data Redis 在Java中操作Redis

目录

1. 添加依赖  

2. 配置连接信息

3. 配置 RedisConnectionFactory 和 RedisTemplate

4.在Java中操作Redis

4.1. String 类型操作

4.2 List 类型操作

4.3 Set 类型操作

4.4 Hash类型操作

4.5 sorted set类型操作

 


 

Spring Data Redis 是 Spring Data 项目的一部分,它为 Java 应用程序提供了在 Spring 环境中与 Redis 数据库进行交互的便捷方式。通过 Spring Data Redis,可以利用自动配置、模板类(RedisTemplate)、Repository 接口以及对 Redis 数据结构的支持来简化开发工作。

   1. 添加依赖  

在 Maven 或 Gradle 构建文件中添加 Spring Data Redis 依赖。

   
       org.springframework.boot
       spring-boot-starter-data-redis
   

2. 配置连接信息

   # application.yml
   spring:
     redis:
       host: localhost
       port: 6379

3. 配置 RedisConnectionFactory 和 RedisTemplate

Spring Boot 自动配置会创建一个 RedisConnectionFactory 实例和默认的 RedisTemplate。如果需要自定义序列化器或配置其他选项,可以自己配置:

   @Configuration
   public class RedisConfig {

       @Bean
       public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
           RedisTemplate template = new RedisTemplate<>();
           template.setConnectionFactory(factory);

           // 设置 key 和 value 的序列化器
           Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer<>(Object.class);
           ObjectMapper objectMapper = new ObjectMapper();
           objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
           objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
           serializer.setObjectMapper(objectMapper);

           StringRedisSerializer stringSerializer = new StringRedisSerializer();
           // key 采用 String 序列化
           template.setKeySerializer(stringSerializer);
           // hash 的 key 也采用 String 序列化
           template.setHashKeySerializer(stringSerializer);
           // value 采用 JSON 序列化
           template.setValueSerializer(serializer);
           // hash 的 value 采用 JSON 序列化
           template.setHashValueSerializer(serializer);

           return template;
       }
   } 
  

 

4.在Java中操作Redis

4.1. String 类型操作

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;

@Autowired
private StringRedisTemplate redisTemplate;

// 1. 设置(保存)字符串值
public void setStringValue(String key, String value) {
    ValueOperations operations = redisTemplate.opsForValue();
    operations.set(key, value);
}

// 2. 获取字符串值
public String getStringValue(String key) {
    ValueOperations operations = redisTemplate.opsForValue();
    return operations.get(key);
}

// 3. 自增操作(如果key不存在,则默认设置为0再进行自增)
public Long increment(String key) {
    return redisTemplate.opsForValue().increment(key);
}

// 4. 自减操作
public Long decrement(String key) {
    return redisTemplate.opsForValue().decrement(key);
}

// 5. 设置带过期时间的键值对
public void setExpiryKeyValue(String key, String value, long timeout, TimeUnit timeUnit) {
    redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
}

// 6. 获取字符串长度
public Long stringLength(String key) {
    return redisTemplate.opsForValue().size(key);
}

// 7. 追加字符串到已存在的key后
public Long appendToKey(String key, String value) {
    return redisTemplate.opsForValue().append(key, value);
}

4.2 List 类型操作

import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;

@Autowired
private RedisTemplate redisTemplate;

// 1. 将元素添加到列表的头部(左侧)
public void addToListHead(String key, Object value) {
    ListOperations listOps = redisTemplate.opsForList();
    listOps.leftPush(key, value);
}

// 2. 将元素添加到列表的尾部(右侧)
public void addToListTail(String key, Object value) {
    ListOperations listOps = redisTemplate.opsForList();
    listOps.rightPush(key, value);
}

// 3. 从列表头部弹出一个元素并返回
public Object popFromListHead(String key) {
    ListOperations listOps = redisTemplate.opsForList();
    return listOps.leftPop(key);
}

// 4. 从列表尾部弹出一个元素并返回
public Object popFromListTail(String key) {
    ListOperations listOps = redisTemplate.opsForList();
    return listOps.rightPop(key);
}

// 5. 获取列表指定范围内的元素(左闭右开区间 [start, end))
public List getRangeFromList(String key, long start, long end) {
    ListOperations listOps = redisTemplate.opsForList();
    return listOps.range(key, start, end);
}

// 6. 删除列表中与给定值相等的所有元素
public Long removeElementsByValueFromList(String key, Object value) {
    ListOperations listOps = redisTemplate.opsForList();
    return listOps.remove(key, 0, value); // 参数0表示删除所有匹配项
}

// 7. 在列表的某个索引位置插入元素
public void insertElementAtPosition(String key, int index, Object value) {
    ListOperations listOps = redisTemplate.opsForList();
    listOps.set(key, index, value);
}
 
  

4.3 Set 类型操作

import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.RedisTemplate;

@Autowired
private RedisTemplate redisTemplate;

// 1. 添加元素到集合中(如果元素已存在,则不添加)
public Long addToSet(String key, Object... values) {
    SetOperations setOps = redisTemplate.opsForSet();
    return setOps.add(key, values);
}

// 2. 从集合中移除指定元素
public Long removeFromSet(String key, Object... values) {
    SetOperations setOps = redisTemplate.opsForSet();
    return setOps.remove(key, values);
}

// 3. 判断元素是否存在于集合中
public Boolean isMemberOfSet(String key, Object value) {
    SetOperations setOps = redisTemplate.opsForSet();
    return setOps.isMember(key, value);
}

// 4. 获取集合中的所有元素
public Set getMembersFromSet(String key) {
    SetOperations setOps = redisTemplate.opsForSet();
    return setOps.members(key);
}

// 5. 计算两个集合的交集,并存储到新的key中
public Long intersectAndStoreSets(String destinationKey, String... keys) {
    SetOperations setOps = redisTemplate.opsForSet();
    return setOps.intersectAndStore(destinationKey, keys);
}

// 6. 计算两个集合的并集,并存储到新的key中
public Long unionAndStoreSets(String destinationKey, String... keys) {
    SetOperations setOps = redisTemplate.opsForSet();
    return setOps.unionAndStore(destinationKey, keys);
}

// 7. 计算两个集合的差集,并存储到新的key中
public Long differenceAndStoreSets(String destinationKey, String key1, String key2) {
    SetOperations setOps = redisTemplate.opsForSet();
    return setOps.differenceAndStore(destinationKey, Collections.singletonList(key1), Collections.singletonList(key2));
}
 
  

4.4 Hash类型操作

import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;

@Autowired
private RedisTemplate redisTemplate;

// 1. 设置Hash中的字段值
public void setHashField(String key, String field, Object value) {
    HashOperations hashOps = redisTemplate.opsForHash();
    hashOps.put(key, field, value);
}

// 2. 获取Hash中指定字段的值
public Object getHashFieldValue(String key, String field) {
    HashOperations hashOps = redisTemplate.opsForHash();
    return hashOps.get(key, field);
}

// 3. 获取整个Hash的所有字段和值
public Map getAllHashFields(String key) {
    HashOperations hashOps = redisTemplate.opsForHash();
    return hashOps.entries(key);
}

// 4. 删除Hash中一个或多个字段
public Long deleteHashFields(String key, Object... fields) {
    HashOperations hashOps = redisTemplate.opsForHash();
    return hashOps.delete(key, fields);
}

// 5. 判断Hash中是否存在某个字段
public Boolean hasHashField(String key, String field) {
    HashOperations hashOps = redisTemplate.opsForHash();
    return hashOps.hasKey(key, field);
}

// 6. 批量设置多个字段值
public void putAllInHash(String key, Map map) {
    HashOperations hashOps = redisTemplate.opsForHash();
    hashOps.putAll(key, map);
}

4.5 sorted set类型操作

import org.springframework.data.redis.core.ZSetOperations;
import org.springframework.data.redis.core.RedisTemplate;

@Autowired
private RedisTemplate redisTemplate;

// 1. 向有序集合添加成员并设置分数
public Long addToSortedSet(String key, Object value, double score) {
    ZSetOperations zSetOps = redisTemplate.opsForZSet();
    return zSetOps.add(key, value, score);
}

// 2. 根据分数范围获取有序集合中的成员
public Set getRangeFromSortedSetByScore(String key, double min, double max) {
    ZSetOperations zSetOps = redisTemplate.opsForZSet();
    return zSetOps.rangeByScore(key, min, max);
}

// 3. 获取有序集合中指定索引范围内的成员
public Set getRangeFromSortedSet(String key, long start, long end) {
    ZSetOperations zSetOps = redisTemplate.opsForZSet();
    return zSetOps.range(key, start, end);
}

// 4. 删除有序集合中的指定成员
public Long removeFromSortedSet(String key, Object... values) {
    ZSetOperations zSetOps = redisTemplate.opsForZSet();
    return zSetOps.remove(key, values);
}

// 5. 获取有序集合中成员的分数
public Double getScoreInSortedSet(String key, Object value) {
    ZSetOperations zSetOps = redisTemplate.opsForZSet();
    return zSetOps.score(key, value);
}

// 6. 更新有序集合中成员的分数
public Long updateScoreInSortedSet(String key, Object value, double newScore) {
    ZSetOperations zSetOps = redisTemplate.opsForZSet();
    return zSetOps.incrementScore(key, value, newScore - zSetOps.score(key, value)); // 增量更新,避免多次查询
}

// 7. 计算两个有序集合的交集,并存储到新的key中
public Long intersectAndStoreSortedSets(String destinationKey, String... keys) {
    ZSetOperations zSetOps = redisTemplate.opsForZSet();
    return zSetOps.intersectAndStore(destinationKey, Arrays.asList(keys));
}

// 8. 计算两个有序集合的并集,并存储到新的key中
public Long unionAndStoreSortedSets(String destinationKey, String... keys) {
    ZSetOperations zSetOps = redisTemplate.opsForZSet();
    return zSetOps.unionAndStore(destinationKey, Arrays.asList(keys));
}
 
  

 

你可能感兴趣的:(Redis,spring,redis,java)