springboot3使用redis 最新详细方法示例详解

目录

• 1.Spring Data Redis
• 初始准备
• 1.1首先配置Pom依赖
• 1.2 在yml中配置redis相关信息
• 1.3 设置redis的序列化
• 使用redis
• 2.1 存取string
• 2.2 存取Object
• 2.3 存取list
• 2.5 存取ZSet
• 2.6 存取Hash
• 2.7存取Bitmap

1.Spring Data Redis

这是Spring框架提供的一个用于简化Redis操作的模块。：

初始准备

1.1首先配置Pom依赖

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

1.2 在yml中配置redis相关信息

由于spring.redis.host 这种配置已经被弃用，在新版的springboot中，需要在spring.data.redis.host 进行配置

spring:
  data:
    redis:
    # 改为自己的地址和密码
      host: 10.69.37.213
      port: 6379
      password: Jolly
      # 连接超时时间,单位ms
      connect-timeout: 50000
      # 选择第几个数据库，默认为0,最大值15
      database: 0
      lettuce:
        pool:
          # 最大的活跃连接数，不会超过这个数，根据项目预期并发量调整
          max-active: 50
          # max-idle 指定了连接池中的最大空闲连接数。
          # 空闲连接是指那些没有被使用，但是已经创建并且保持在连接池中的连接
          # 这个值应该与max-active相匹配或者稍微低一些，
          # 以保持连接池中有足够的空闲连接来处理突发请求。
          # 设置得太高可能会导致资源浪费，因为空闲连接会占用内存和其他资源。
          max-idle: 30
          #这个配置指定了连接池中的最小空闲连接数。
          #这个设置可以确保连接池始终保持一定数量的空闲连接，以便在请求到来时可以立即使用，而不需要等待连接的创建。
          # 这个值应该根据你的应用程序的基线负载来设置
          min-idle: 10
          # 当连接池达到最大活跃连接数时，客户端等待可用连接的最大时间（以毫秒为单位）。-1 表示无限等待
          # 如果设置为一个正数，那么在等待时间超过这个值后，会抛出一个异常。
          max-wait: -1

1.3 设置redis的序列化

为了防止存入到redis的数据出现乱码的情况，进行序列化的设置

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;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
@Configuration
public class redisConfig {
	@ConditionalOnMissingBean(name = "redisTemplate")
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory) {
        RedisTemplate<Object, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        // 默认为utf-8,可以进行修改
        template.setKeySerializer(new StringRedisSerializer());
        // 原版默认使用jdk的序列化方式JdkSerializationRedisSerializer
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);
        template.setValueSerializer(serializer);
        // 设置Hash的序列化化方式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(serializer);
        // 设置属性
        template.afterPropertiesSet();
        return template;
    }
}

使用redis

2.1 存取string

import jakarta.annotation.Resource;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.pythonbind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
@RestController
@RequestMapping("/test")
public class test {
    @Resource
    private RedisTemplate<String,String> redisTemplate;
    @GetMapping(value="/setString")
    public String setString() {
        String key = "test";
        // 插入一个字符串
        redisTemplate.opsForValue().set(key,"123");
        // 再从redis读取这个key值对应的value
        String s = redisTemplate.opsForValue().get(key);
        System.out.println(s);
        // 再次设置值，会进行覆盖
        // redisTemplate.opsForValue().set(key,"456");
        // s = redisTemplate.opsForValue().get(key);
        return s;
    }
    @GetMapping(value="/append")
    public void append() {
        str.opsForValue().set("jolly", "hello");
        String xiaolong = str.opsForValue().get("jolly");
        // 追加字符串
        str.opsForValue().append("jolly", "哈哈");
        // 获取长度
        Long size = str.opsForValue().size("jolly");
    }
}

2.2 存取Object

存储对象其实和string本质上是一样的，也就是将对象序列化为json字符串，在取的时候再将字符串转为对象

首先创建一个对象

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import Java.io.Serializable;
@NoArgsConstructor
@AllArgsConstructor
@Data
public class user implements Serializable{
    private int id;
    private String name;
    private int age;
    private String email;
}

@RestController
@RequestMapping("/test")
public class test {
    @Resource
    // 这要需要修改
    private RedisTemplate<String,Object> redisTemplate;
    @GetMapping(value="/setObject")
    public String setObject() {
        String key = "obj";
        user user = new user(1,"jolly",22,"1589112546@qq.com");
        redisTemplate.opsForValue().set(key,user);
        Object o = redisTemplate.opsForValue().get(key);
        System.out.println(o);
        return "s";
    }
}

2.3 存取list

redis中list的左右都可以进出，可以理解为双端队列,还可以使用redis中的list作为消息队列

    @GetMapping(value = "/list")
    public String list() {
        redisTemplate.opsForList().leftPush("list","1");
        redisTemplate.opsForList().leftPush("list","2");
        redisTemplate.opsForList().rightPush("list","3");
        // 获取第一个
        // redisTemplate.opsForList().getFirst("list");
        // redisTemplate.opsForList().leftPop("list");
        redisTemplate.opsForList().rightPush("list","4");
        List<String> s = redisTemplate.opsForList().range("list",0,4);
        // s = [2, 1, 3, 4]
        return s.toString();
    }

2.4 存取Set中的元素

Set中的元素是无序且唯一的，并且Redis中Set中的元素都是字符串类型。所以存取对象需要序列化为字符串类型。并且Redis的Set集合中还提供了两个集合求并集和交集的功能。

 @Resource
 private RedisTemplate<String,String> redisTemplate;
 @GetMapping("/Set")
    public void set(){
        String key = "set1";
        String key2= "set2";
        redisTemplate.opsForSet().add(key, "1","1","2","3");
        redisTemplate.opsForSet().add(key2, "1","5","2","4");
        Set<String> members = redisTemplate.opsForSet().members(key);
        //输出 [2, 1, 3]
        System.out.println(members);
        Boolean member = redisTemplate.opsForSet().isMember(key, "1");
        //判断是否存在
        System.out.println(member);
        //获取Set集合中元素的个数
        Long size = redisTemplate.opsForSet().size(key);
        System.out.println(size);
        // 删除指定元素
        // redisTemplate.opsForSet().remove(key,"1");
        // 集合求并集
        Set<String> union = redisTemplate.opsForSet().union(key, key2);
        System.out.println(union);
        //求交集,比如可以求共同好友
        Set<String> intersect = redisTemplate.opsForSet().intersect(key, key2);
        System.out.println(intersect);
    }

2.5 存取ZSet

在Redis中，ZSet（有序集合）是一种数据结构，用于存储唯一、不重复的字符串元素，同时每个元素都会关联一个浮点数分数（score），这个分数用于按照从低到高排序元素。ZSet因此也是Redis中最复杂的数据结构之一。

以下是ZSet与普通Set（集合）的主要区别：

1.排序：

• ZSet：元素根据分数（score）进行排序，可以获取指定分数范围内的元素。
• Set：Set中的元素是无序的，因为它们是基于哈希表实现的，所以不能对元素进行排序。

2.分数（Score）：

• ZSet：每个元素都与一个分数相关联，这个分数是排序的依据。
• Set：Set中的元素没有与之关联的分数，因此不能根据任何值进行排序。

3.操作：

• ZSet：除了添加、删除和检查成员等基本操作外，还可以根据分数范围进行查询、获取元素的排名等。
• Set：提供基本的集合操作，如添加、删除、判断元素是否存在、计算集合的交集和并集等。

4.使用场景：

• ZSet：适用于需要排序的场景，如排行榜、时间序列数据等。
• Set：适用于需要确保元素唯一性的集合操作，而不关心元素的顺序。

@GetMapping("/ZSet")
    public void zSet() {
        String key = "ZSet" ;
        // 排序手机的销量情况
        redisTemplate.opsForZSet().add(key,"小米",100);
        redisTemplate.opsForZSet().add(key,"华为",120);
        redisTemplate.opsForZSet().add(key,"Apple",200);
        redisTemplate.opsForZSet().add(key,"Oppo",99);
        // 统计范围中的个数,包含100，和200
        Long count = redisTemplate.opsForZSet().count(key, 100, 200);
        // 输出3
        System.out.println(count);http://www.devze.com
        // 输出[Oppo, 小米, 华为, Apple]，默认从小到大
        Set<String> range = redisTemplate.opsForZSet().range(key, 0, -1);
        System.out.println(range);
        // 从大到小使用
        // Set<String> revpythonerseRange = redisTemplate.opsForZSet().reverseRange(key, 0, -1);
        // 获取前2个最大值，得到全部数据[[score=200.0, value=Apple], [score=120.0, value=华为]]
        Set<ZSetOperations.TypedTuple<String>> l = redisTemplate.opsForZSet().reverseRangeWithScores(key, 0, 1);
        System.out.println(l);
    }

2.6 存取Hash

常见使用场景：

1. 对象存储：Hash经常用来存储对象，其中field对应对象的属性，value对应属性的值。
2. 数据库行：可以将Hash用作轻量级的数据库行，field对应列名，value对应列的值。
3. 缓存：可以用来缓存具有多个字段的记录，比如用户信息、配置信息等。

@GetMapping("/hash")
    public void hash() {
        String key = "hash1";
        redisTemplate.opsForHash().put(key, "1", "world");
        redisTemplate.opsForHash().put(key, "2", "world2");
        redisTemplate.opsForHash().put(key, "3", "world3");
//        user user = new user(1,"jolly",22,"1589112546@qq.com");
//        redisTemplate.opsForHash().put(key, "4", user);
        Object o = redisTemplate.opsForHash().get(key, "1");
        System.out.println(o);
        // 获取hash中所有的key
        Set<Object> keys = redisTemplate.opsForHash().keys(key);
        System.out.printf(keys.toString编程客栈());
        // 获取所有的value
        List<Object> values = redisTemplate.opsForHash().values(key);
        System.out.printf(values.toString());
    }

2.7存取Bitmap

Bitmap实际上是对字符串的抽象，但它将字符串看作是一个由二进制位组成的数组。

应用场景

1.用户活跃度统计：

可以使用Bitmap来记录用户每天的登录情况，每个用户对应一个key，每天的日期对应一个offset，如果用户在那天登录，则将对应的位设置为1。

2.布隆过滤器（Bloom Filter）：

Bitmap可以用来实现布隆过滤器，用于快速判断一个元素是否在一个集合中，虽然有一定的误判率，但非常节省空间。

3.简单的布尔值存储：

当需要存储大量布尔值时，Bitmap可以非常节省空间，比如记录用户的性别、订阅状态等。

4.事件计数：

可以使用Bitmap来记录事件的发生，比如记录用户点击广告的情况，每个广告点击事件对应一个位。

Bitmap的最大offset为2^32 - 1，即可以处理的最大字符串长度为512MB。

redisTemplate 没有快捷的调用bitcount命令,有点离谱

@GetMapping("/Bitmap")
    public void bitmap(){
        // 用户id
        String id = "admiuad@ad#al.";
        redisTemplate.opsForValue().setBit(id,0,true);
        redisTemplate.opsForValue().setBit(id,99,true);
        redisTemplate.opsForValue().setBit(id,100,true);
        redisTemplate.opsForValue().setBit(id,200,true);
        // 获取当天的登录情况
        @GetMapping("/Bitmap")
    public void bitmap(){
        // 用户id
        String id = "admiuad@ad#al.";
        redisTemplate.opsForValue().setBit(id,0,true);
        redisTemplate.opsForValue().setBit(id,www.devze.com99,true);
        redisTemplate.opsForValue().setBit(id,100,true);
        redisTemplate.opsForValue().setBit(id,200,true);
        redisTemplate.opsForValue().setBit(id,300,true);
        redisTemplate.opsForValue().setBit(id,365,true);
        // 获取当天的登录情况
        Boolean bit = redisTemplate.opsForValue().getBit(id, 0);
        System.out.println(bit);
        System.out.println(bitCount(id,0,365));
    }
    public Long bitCount(String key, int start, int end) {
        return redisTemplate.execute((RedisCallback<Long>) con -> con.bitCount(key.getBytes(), start, end));
    }

到此这篇关于springboot3使用redis 最新详细方法的文章就介绍到这了,更多相关springboot3使用redis内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！