Java和SpringBoot操作redis

已于 2022-04-15 22:35:02 修改
阅读量2.5k 收藏 4
点赞数 1
分类专栏： Redis 文章标签： java 后端 springboot redis 数据库
于 2022-04-14 22:47:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50313418/article/details/124183960
版权

2. java操作Redis

2.1 环境准备

  1. 引入依赖
<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>2.9.0</version>
</dependency>

jedis这个名字是java和redis名字的结合，意为java操作redis

  1. 创建 Jedis 对象
 public static void main(String[] args) {
   //1. 创建jedis对象
   //1.redis服务必须关闭防火墙  2.redis服务必须开启远程连接
   Jedis jedis = new Jedis("192.168.72.129", 7000);
   //选择操作的库
   // 如果不传参数的话表示默认连接的是本机的Redis，端口号为6379
   jedis.select(0);
   
   //2. 执行相关操作
   //....
   
   //3. 释放资源
   jedis.close();
 }
  1. 其他配置

如果想要操作使用java操作redis，我们还需要做如下配置：

  • redis服务器是否开放了指定端口
  • 修改配置文件（关闭保护模式，注释掉 bind）
  • 关闭防火墙

查看redis服务器是否开放了这个端口，这里以 7000 端口为例

- 查看是否打开端口号“7000”
firewall-cmd --query-port=7000/tcp  

- 如果返回值为“no”，则输入此命令，开启该“7000”端口
firewall-cmd --add-port=7000/tcp

修改配置文件：关闭保护模式，注释掉 bind 127.0.0.1

在这里插入图片描述

查看防火墙状态，如果防火墙开启要关闭防火墙

Centos7默认安装了firewalld，如果没有安装的话，可以使用 yum install firewalld firewalld-config进行安装。

yum install firewalld firewalld-config  # 默认安装了防火墙，如果没有安装，使用这个命令安装
firewall-cmd --state  	# 查看防火墙的状态
systemctl stop firewalld  # 关闭防火墙
systemctl start firewalld.service  # 开启防火墙

之后重启redis就可以了

2.2 相关操作

java操作redis的api很多都是和redis的指令一一对应的，很方便，所以下面的api没有写的太详细，很多api基本都是和redis指令是一样的格式

1. 操作库相关的

// 操作库相关的
public class TestRedis {

    public static void main(String[] args) {
        // 创建Jedis对象连接Redis，传入两个参数，分别是Redis服务器的主机地址以及端口号
        // 如果不传参数的话表示默认连接的是本机的Redis，端口号为6379
        Jedis jedis = new Jedis("192.168.72.129", 7000);

        // 选择使用的库，如果不写的话默认使用的是0号库
        jedis.select(0);

        // 获取redis中当前库所有key信息
        Set<String> keys = jedis.keys("*");

        keys.forEach(key -> System.out.println("key = " + key));

        // 操作库相关的
        jedis.flushDB();    // 清空当前库
        jedis.flushAll();   // 清空所有库



        // 释放资源
        jedis.close();
    }
}

在这里插入图片描述

2. 操作key相关的

// 一下api没有写，其实java操作redis中的api和redis都是一一对应的，很好写的
public class TestKey {

    private Jedis jedis;
    @Before
    public void before(){
        jedis = new Jedis("192.168.72.129", 7000);
        jedis.select(0);
    }

    // 测试key相关的
    @Test
    public void testKeys(){
        // 删除一个key
        jedis.del("name");
        // 删除多个key
        jedis.del("name", "age");
        
        // 判断一个key是否存在
        Boolean age = jedis.exists("age");
        System.out.println(age);

        // 设置一个key的超时时间
        Long expire = jedis.expire("name", 100);
        System.out.println(expire);

        // 获取一个key的超时时间
        Long ttl = jedis.ttl("name");
        System.out.println(ttl);

        // 随机获取一个key
        String s = jedis.randomKey();
        System.out.println(s);

        // 修改一个key的名字
        jedis.rename("name", "newName");

        // 查看key对应的value的类型
        String s1 = jedis.type("maps");
        System.out.println(s1);

    }

    @After
    public void after(){
        jedis.close();
    }
}

在这里插入图片描述

3. 操作String相关的

// java操作redis的api很多都是和redis的指令一一对应的，很方便，所以这里不过多赘述
public class TestString {

    private Jedis jedis;
    @Before
    public void before(){
        jedis = new Jedis("192.168.72.129", 7000);
        jedis.select(0);
    }

    // 测试String相关的
    @Test
    public void testString(){
        // set
        jedis.set("name", "小陈");
        // get
        String s = jedis.get("name");
        System.out.println(s);
        // mset
        jedis.mset("content", "好人", "address", "海淀区");
        // mget
        List<String> mget = jedis.mget("content", "address");
        mget.forEach(v -> System.out.println("v = " + v));
        // getset
        String set = jedis.getSet("name", "小明");
        System.out.println(set);
        
        // ....
    }

    @After
    public void after(){
        jedis.close();
    }
}

在这里插入图片描述

4. 操作List相关的

// java操作redis的api很多都是和redis的指令一一对应的，很方便，所以这里不过多赘述
public class TestList {

    private Jedis jedis;
    @Before
    public void before(){
        jedis = new Jedis("192.168.72.129", 7000);
        jedis.select(0);
    }

    // 测试List相关的
    @Test
    public void testList(){
        // lpush
        jedis.lpush("names", "张三", "李四", "王五", "赵六", "win7");

        // rpush
        jedis.rpush("names", "xiaomingming");

        // lrange
        List<String> names = jedis.lrange("names", 0, -1);
        names.forEach(name -> System.out.println("name = " + name));

        // lpop rpop
        String names1 = jedis.lpop("names");
        System.out.println(names1);

        // llen
        jedis.llen("names");

        // linsert 在一个集合中某个元素的之前或之后插入元素
        // BinaryClient.LIST_POSITION.BEFORE 之前插入元素
        // BinaryClient.LIST_POSITION.AFTER 之后插入元素
        jedis.linsert("names", BinaryClient.LIST_POSITION.AFTER, "xiaohei", "xiaobai");

        // ...

    }

    @After
    public void after(){
        jedis.close();
    }
}

在这里插入图片描述

5. 测试Set相关的

// java操作redis的api很多都是和redis的指令一一对应的，很方便，所以这里不过多赘述
public class TestSet {

    private Jedis jedis;
    @Before
    public void before(){
        jedis = new Jedis("192.168.72.129", 7000);
        jedis.select(0);
    }

    // 测试Set相关的
    @Test
    public void testSet(){
        // sadd
        jedis.sadd("sets", "张三", "李四", "王五", "赵六");

        // smembers
        jedis.smembers("sets");

        // sismember
        jedis.sismember("names", "张三");

        // ...

    }

    @After
    public void after(){
        jedis.close();
    }
}

在这里插入图片描述

6. 测试ZSet相关的

// java操作redis的api很多都是和redis的指令一一对应的，很方便，所以这里不过多赘述
public class TestZSet {

    private Jedis jedis;
    @Before
    public void before(){
        jedis = new Jedis("192.168.72.129", 7000);
        jedis.select(0);
    }

    // 测试ZSet相关的
    @Test
    public void testZSet(){

        // zadd
        jedis.zadd("zsets", 10, "张三");

        // zrange
        jedis.zrange("zsets", 0, -1);

        // zcard
        jedis.zcard("zsets");

        // zrangeByScore
       jedis.zrangeByScore("name", "0", "100", 0, 5);

       // ...
    }

    @After
    public void after(){
        jedis.close();
    }
}

在这里插入图片描述

7. 测试Hash相关的

// java操作redis的api很多都是和redis的指令一一对应的，很方便，所以这里不过多赘述
public class TestHash {

    private Jedis jedis;
    @Before
    public void before(){
        jedis = new Jedis("192.168.72.129", 7000);
        jedis.select(0);
    }

    // 测试Hash相关的
    @Test
    public void testHash(){
        // hget
        jedis.hget("maps", "name");
        // hgetall
        jedis.hgetAll("maps");
        // hkeys
        jedis.hkeys("maps");
        // hvals
        jedis.hvals("maps");
        //...
    }

    @After
    public void after(){
        jedis.close();
    }
}

在这里插入图片描述

3. SpringBoot整合Redis

Spring Data(数据) 为Redis 提供了RedisTemplate和StringRedisTemplate，其中StringRedisTemplate是RedisTemplate的子类，两个方法基本一致，不同之处主要体现在操作的数据类型不同,**RedisTemplate中的两个泛型都是Object，意味着存储的key和value都可以是一个对象,而StringRedisTemplate的两个泛型都是String，意味着StringRedisTemplate的key和value都只能是字符串。**接下来我们来看看在SpringBoot中如何使用StringRedisTemplate和RedisTemplate这两个对象吧。

StringRedisTemplate在操作的时候key和value都是String类型，当然我们在使用的时候是不用写泛型的
StringRedisTemplate<String,String>

RedisTemplate在操作的时候key和value都是Object类型，当然我们在使用的时候是不用写泛型的
RedisTemplate<Object,Object>

注意: 使用RedisTemplate默认是将对象序列化到Redis中,所以放入的对象必须实现对象序列化接口

3.1 环境准备

使用快速构建方式构建一个SpringBoot模块

在这里插入图片描述

在这里插入图片描述

注：使用SpringBoot版本为2.2.5.RELEASE，模块构建完后之后记得修改一下

在这里插入图片描述

1. 引入依赖

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

2. 编写配置文件application.properties

# SpringBoot应用默认端口是8989，这里修改一下SpringBoot应用的端口为8989
server.port=8989

# 配置操作redis相关的(redis服务器的主机ip和端口和使用哪个库)
spring.redis.host=192.168.72.129
spring.redis.port=7000
spring.redis.database=0

在redis中还要开启远程连接

在这里插入图片描述

因为redis服务器上redis使用的是7000端口，所以我们还要检查 7000 端口是否开启，如果没有开启，我们要开启 7000端口

firewall-cmd --query-port=7000/tcp  # 查看是否打开端口号“7000”,如果返回值为“no”，则输入下面命令
firewall-cmd --add-port=7000/tcp    # 开启“7000”端口

3.2 使用StringRedisTemplate和RedisTemplate

因为很多都是和redis指令是对应的，所以下面测试的时候并没有写太多的api，在使用的时候根据提示望文生义使用或者查找即可，都是很好理解的。

使用 StringRedisTemplate 操作redis

StringRedisTemplate 在操作redis时传入的参数必须是String类型的，不能传入对象

import java.util.*;
import java.util.concurrent.TimeUnit;

// 下面两个注解相当于启动SpringBoot应用
@SpringBootTest(classes = RedisDay2Application.class)   // 让SpringBoot启动起来，并指向入口类
@RunWith(SpringRunner.class)
public class TestStringRedisTemplate {

    // 注入StringRedisTemplate
    @Autowired
    private StringRedisTemplate stringRedisTemplate;  // key和value都是字符串
    // StringRedisTemplate 只是传入的参数key和value都是字符串，并不代表它只能操作Redis中的String类型，它还可以操作List、Set等类型

    // 操作redis中key相关的
    @Test
    public void testKey(){
        //stringRedisTemplate.delete("name"); // 删除指定key
        Boolean hasKey = stringRedisTemplate.hasKey("name");// 判断指定key是否存在
        System.out.println(hasKey);
        DataType dataType = stringRedisTemplate.type("name");// 判断key所对应value的类型
        System.out.println(dataType);
        Set<String> keys = stringRedisTemplate.keys("*");   // 获取redis中所有key
        keys.forEach(key -> System.out.println("key = " + key));
        Long expire = stringRedisTemplate.getExpire("name");    // 获取key的超时时间 -1 永不超时 -2 key不存在
        System.out.println(expire);
        String s = stringRedisTemplate.randomKey(); // 在redis中随机获取一个key
        System.out.println(s);
        //stringRedisTemplate.rename("age", "age1");  // 修改key的名字，要求key必须存在，不存在会报错
        stringRedisTemplate.renameIfAbsent("name", "name1"); // 判断key是否存在，修改key的名字
        stringRedisTemplate.move("name1", 1);   // 移动key到指定库
    }

    // 操作redis中的字符串  opsForValue  实际就是操作redis中的String
    @Test
    public void testString(){
        stringRedisTemplate.opsForValue().set("name", "小陈");  // 代表操作的类型是String类型，用来设置一个key-value对
        String value = stringRedisTemplate.opsForValue().get("name"); // 代表操作的类型是String类型，用来获取一个key对应的value
        System.out.println("value = " + value);
        stringRedisTemplate.opsForValue().set("code", "2357", 120, TimeUnit.SECONDS);   // 设置一个key的超时时间
        stringRedisTemplate.opsForValue().append("name", "他是一个好人，单纯的少年");
        //stringRedisTemplate.opsForList();   // 代表操作的类型是List类型，要操作List的话，在之后写.相应的方法即可
        //stringRedisTemplate.opsForSet();    // 代表操作的是Set类型
        //stringRedisTemplate.opsForZSet();   // 代表操作的是ZSet类型
        //stringRedisTemplate.opsForHash();   // 代表操作的是Hash类型
    }

    // 操作redis中List类型  opsForList  实际就是操作redis中的List类型
    @Test
    public void testList(){
        stringRedisTemplate.opsForList().leftPush("names", "小陈");   // 创建一个列表，并放入一个元素
        stringRedisTemplate.opsForList().leftPushAll("names", "小张", "小王", "小明"); // 创建一个列表，放入多个元素
        List<String> names = new ArrayList<>();
        names.add("小明");
        names.add("小王");
        stringRedisTemplate.opsForList().leftPushAll("names", names);   // 创建一个列表并放入一个String类型的集合

        List<String> stringList = stringRedisTemplate.opsForList().range("names", 0, -1);   // 遍历List
        stringList.forEach(value -> System.out.println("value = " + value));
        stringRedisTemplate.opsForList().trim("names", 0, 2); // 使这个key所对应的value只保留这个区间内的元素，其他元素截断
    }
    // 操作redis中Set类型  opsForSet 实际就是操作redis中的Set类型
    @Test
    public void testSet(){
        stringRedisTemplate.opsForSet().add("sets", "小明", "小明", "小陈", "小王");

        Set<String> sets = stringRedisTemplate.opsForSet().members("sets");
        sets.forEach(value -> System.out.println("value = " + value));

        Long size = stringRedisTemplate.opsForSet().size("sets");   // 获取set集合的元素个数
        System.out.println("size = " + size);
    }
    // 操作redis中ZSet类型  opsForZSet 实际就是操作redis中的ZSet类型
    @Test
    public void testZSet(){
        stringRedisTemplate.opsForZSet().add("zsets", "小陈", 100); // 创建一个ZSet并放入一个元素和相应的得分
        stringRedisTemplate.opsForZSet().add("zsets", "小黑", 20);

        Set<String> zsets = stringRedisTemplate.opsForZSet().range("zsets", 0, -1); // 遍历ZSet
        zsets.forEach(value -> System.out.println("value = " + value));

        // 获取指定Zset集合中指定范围的元素以及分数
        Set<ZSetOperations.TypedTuple<String>> zsets1 = stringRedisTemplate.opsForZSet().rangeByScoreWithScores("zsets", 0, 1000);
        zsets1.forEach(typedTuple -> {
            System.out.println(typedTuple.getScore());
            System.out.println(typedTuple.getValue());
        });
    }
    // 操作redis中Hash类型  opsForHash 实际就是操作redis中的Hash类型
    @Test
    public void testHash(){
        stringRedisTemplate.opsForHash().put("maps", "name", "张三"); // 创建一个Hash类型，并放入一个value为键值对类型的键值对
        Map<String, String> map = new HashMap<>();
        map.put("age", "18");
        map.put("bit", "2012-12-12");
        // 一次放入一个map集合，但要注意这个map集合的key和value都是String类型的
        stringRedisTemplate.opsForHash().putAll("maps", map);
        stringRedisTemplate.opsForHash().multiGet("maps", Arrays.asList("name", "age", "bir")); // 获取多个key，但注意要将多个key封装成Collection
        String values = (String) stringRedisTemplate.opsForHash().get("maps", "name");// 获取value中某个key的值
        Set<Object> maps = stringRedisTemplate.opsForHash().keys("maps");// 获取key对应的value中所有的键
        List<Object> maps1 = stringRedisTemplate.opsForHash().values("maps");// 获取key对应的value中所有的值


    }
}

在这里插入图片描述

使用 RedisTemplate 操作redis

RedisTemplate 在操作redis时传入的参数可以传入对象其实RedisTemplate 操作redis和StringRedisTemplate操作redis的api很像，只是传入的参数类型不同，RedisTemplate 可以传入对象，StringRedisTemplate只能传入字符串

在使用RedisTemplate 传入参数为对象的时候，必须将对象序列化，对象存储到redis之中的应该是对象序列化的结果，取出来的时候要展现也要进行反序列化。(对象没有办法存储到redis，但是对象序列化之后是可以存储的redis的，所以默认存储到redis中的key和value都是进行序列化的，如果是自定义的类，还要实现Serializable接口)

使用RedisTemplate 往redis里面存值的时候key和value都应该序列化之后再存进去，之后取value的时候应该根据key序列化之后从redis取，相同的key序列化的结果相同，存key的时候存的是key序列化的，如果取key的时候用的是key没有序列化去取，是取不到的。

对于String、Integet、Double、等等类型是默认进行了序列化的，对于自定义的类，我们要实现Serializable接口。

注意：由于在redis中的key都是String类型，所以 RedisTemplate 在实际操作的时候key都是String类型

# 关于 RedisTemplate  中的序列化机制

在RedisTemplate中默认 key 和 value默认都是 JdkSerializationRedisSerializer 序列化方案
但是我们说，这种方式存在局限性：我们在终端无法操作JdkSerializationRedisSerializerxuliehuadekey
在业务操作中，一般都是：
      key   为 String
      value 为 Object
所以我们要修改key的序列化方案为：StringRedisSerializer 即字符串的方式， value的序列化方案不用修改

# 修改key的序列化机制和Hash类型中value内部key的序列化机制为String序列化机制

// 修改key序列化方案  为String序列化
redisTemplate.setKeySerializer(new StringRedisSerializer());
// 修改Hash类型中value中key的序列化为String序列化
redisTemplate.setHashKeySerializer(new StringRedisSerializer());

在这里插入图片描述

用到的User类

// 下面这两个注解的作用是创建get、set方法，使用了下面的这两个注解就不需要写get、set方法了，会自动创建
@Data
@Accessors(chain = true)
public class User implements Serializable { // 在使用RedisTemplate操作redis的时候对象必须序列化
    private String id;
    private String name;
    private Integer age;
    private Date bir;
}

使用RedisTemplate

// 下面两个注解相当于启动SpringBoot应用
@SpringBootTest(classes = RedisDay2Application.class)   // 让SpringBoot启动起来，并指向入口类
@RunWith(SpringRunner.class)
public class TestRedisTemplate {

    @Autowired
    private RedisTemplate redisTemplate;

    // String、List、Set、ZSet、Hash

    @Test
    public void testRedisTemplate(){
        /*
          在RedisTemplate中默认 key 和 value默认都是 JdkSerializationRedisSerializer 序列化方案
          但是我们说，这种方式存在局限性：我们在中断无法操作JdkSerializationRedisSerializerxuliehuadekey
          在业务操作中，一般都是：
                   key   为 String
                   value 为 Object
          所以我们要修改key的序列化方案为：StringRedisSerializer 即字符串的方式
          value的序列化方案不用修改
         */
        // 如果我们把key也序列化存进去，那我们在终端操作的时候就无法操作key了，因为redis
        // 中存储的是key序列化的结果，我们在终端操作的时候有没有序列化、反序列化的操作，这种方式存储使得我们只可以
        // 使用RedisTemplate操作，存在局限性
        // 修改key序列化方案  为String序列化
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        // 修改Hash类型中value中key的序列化为String序列化
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        User user = new User();
        user.setId(UUID.randomUUID().toString()).setName("小陈").setAge(23).setBir(new Date());
        // String默认实现了序列化反序列化而对于自定义的对象我们必须实现Serializable接口
        redisTemplate.opsForValue().set("user", user);

        // 在使用redisTemplate取的时候虽然我们直接传入了key，但是实际是先把key序列化之后再从redis中取的(默认)
        // 在取值的时候虽然我们存value的时候也是序列化之后存的，会默认把value反序列化回来
        System.out.println(redisTemplate.opsForValue().get("user"));

        redisTemplate.opsForList().leftPush("list", user);
        redisTemplate.opsForSet().add("set", user);
        redisTemplate.opsForZSet().add("zset", user, 100);
        redisTemplate.opsForHash().put("map", "name", user);



    }
}

在这里插入图片描述

补充：关于 Bound API 的使用

当我们对于同一个key多次操作时，为了简便，提供了bound api，即对key进行绑定操作，StringRedisTemplate和RedisTemplate都可以使用Bound API

// 下面两个注解相当于启动SpringBoot应用
@SpringBootTest(classes = RedisDay2Application.class)   // 让SpringBoot启动起来，并指向入口类
@RunWith(SpringRunner.class)
public class TestBoundAPI {

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    // spring data 为了方便我们对redis进行更友好的操作 因此又提供了 bound api 简化操作
    @Test
    public void testBound(){
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        // 对同一个key的多次操作进行绑定， 对key绑定
        stringRedisTemplate.opsForValue().set("name", "zhangsan");
        stringRedisTemplate.opsForValue().set("name", "是一个好人");
        String s = stringRedisTemplate.opsForValue().get("name");
        System.out.println(s);

        // 对字符串类型key进行绑定 后续所有操作都是基于这个key的操作
        BoundValueOperations<String, String> nameValueOperations = stringRedisTemplate.boundValueOps("name");
        nameValueOperations.set("zhangsan");
        nameValueOperations.set("是一个好人");
        String s1 = nameValueOperations.get();
        System.out.println(s1);

        // 对List的绑定操作
        BoundListOperations<String, String> listOperations = stringRedisTemplate.boundListOps("lists");
        listOperations.leftPushAll("张三", "李四", "小陈");
        List<String> list = listOperations.range(0, -1);
        list.forEach(value -> System.out.println("value = " + value));

        // 对Set的绑定操作
        BoundSetOperations<String, String> setOperations = stringRedisTemplate.boundSetOps("sets");

        // 对ZSet的绑定操作
        BoundZSetOperations<String, String> zsetOperations = stringRedisTemplate.boundZSetOps("zsets");

        // 对Hash的绑定操作
        BoundHashOperations<String, Object, Object> hashOperations = stringRedisTemplate.boundHashOps("map");


        BoundValueOperations name = redisTemplate.boundValueOps("name");
        BoundListOperations lists = redisTemplate.boundListOps("lists");
        BoundSetOperations sets = redisTemplate.boundSetOps("sets");
        BoundZSetOperations zsets = redisTemplate.boundZSetOps("zsets");
        BoundHashOperations map = redisTemplate.boundHashOps("map");
    }
}

在这里插入图片描述

总结

  1. 针对于日后处理key value 都是String 使用StringRedi sTemplate
  2. 针对于日后的key value 存在对象使用Redi sTemplate
  3. 针对于同一个key多次操作可以使用boundXXxOps ()的api简化书写（bound api）
嘿，鱼骨头^O^
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RedisTemplate常用方法总结
feeling good
04-10 10万+
很多公司都将redisTemplate进行了封装，封装成业务所需要的RedisUtil工具类方便进行调用，本篇文章总结了redisTemplate常用的一些工具类。 Redis最为常用的数据类型： String Hash List Set zSet Sorted set String ...
SpringBoot集成redis
weixin_47578421的博客
03-18 125
启动redis 进入redis安装文件夹执行: redis-server.exe redis.windows.conf 创建spring Boot工程引入pom文件 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter
Springboot 中RedisTemplate使用scan来获取所有的key底层做了哪些事情
最新发布
yh4494的博客
04-24 1567
每次迭代next()都要判断是否数据集中还有数据，没有的话去redis中通过游标取下次一的数据集（2条）。然后将获取到数据集迭代器替换到游标中，上一个数据集回收（防止内存过大），使迭代器可以正常流转。
java连接redis及springboot连接redis
m0_73809543的博客
04-27 699
springboot在整合reids时提供两个模板类，StringRedisTemplate和RedisTemplate，以后对redis的操作都在该模板类中。是StringRedisTemplate的父类，类可以存储任意数据类型，但是任意类型必须序列化，默认采用的是jdk的序列化方式。有请求先查询缓存是否缓存命中 如果命中直接返回响应 如果未命中查询数据库 拿到结果后把查到数据存入缓存中并把数据返回响应。第一种：jedis --- 传统的项目 --- ssm。--- 提高系统的性能。
SpringBoot使用redisTemplate存入Redis中Key会出现乱码
Itmei的博客
03-12 814
存入redis后通过桌面端可视化软件查看key,会出现key乱码问题。导致我们没法直接查看数据信息。但是不影响程序的获取。桌面端可视化软件查看key，没有出现key乱码我们也可以直接查看数据内容，问题解决。把key数据存入Redis,然后通过key取出UserMapper 对象。
spring boot 使用redisTemplate连接redis，获取键值信息
weixin_44220858的博客
11-24 2507
连接redis
基于springboot和redis实现单点登录
08-25
基于SpringBoot和Redis实现单点登录 单点登录（Single Sign-On，SSO）是指用户只需要登录一次，即可访问所有相关的应用系统，而不需要再次登录的机制。基于SpringBoot和Redis实现单点登录是当前热门的技术栈之一，...
springboot分布式自增id_javaredis_源码
10-01
标题中的“springboot分布式自增id_javaredis_源码”表明我们关注的是一个使用Spring Boot实现的分布式系统中的自增ID生成方案，其中利用了Java Redis客户端库。在分布式环境中，确保全局唯一且顺序递增的ID是常见的...
SpringBoot集成Redis
02-26
配置完成后，SpringBoot会自动创建RedisTemplate和StringRedisTemplate实例，它们提供了基本的Redis操作接口。我们可以通过@Autowired来注入这两个模板，进行数据的存取。例如，使用StringRedisTemplate保存键值对：...
springboot整合redis集群（三种方式）源码
04-01
springboot整合redis集群（三种方式）源码
最最最简单的SpringBoot+Redis
03-04
为了集成Redis，我们需要在`pom.xml`文件中添加Spring Data Redis和Spring Boot的Redis starter依赖。例如： ```xml <groupId>org.springframework.boot <artifactId>spring-boot-starter-data-redis ``` ...
springboot自定义redisTemplate
kobe_IT的博客
04-08 1708
springboot自定义redisTemplate
redistemplate指定缓存某个数据库
weixin_45406882的博客
07-25 2972
我用的是springboot 自己配置了一个Redistempate的实现 @Configuration public class Qi7RedisConfig { @Bean public RedisTemplate<String , Integer> codeRedisTemplate(){ //自定义factory 主要是这三句话 var factory = new LettuceConnectionFactory(); fac
redisTemplate操作指定库
evelynnJava的博客
03-23 6488
背景 与后台端或金二联调时，他们的redis缓存不一定是写在 db0库。而项目中默认的RedistTemplate只能读取db0。可考虑如下解决方式： 适用于缓存提供方不方便调整db的情况，最好还是让提供方直接写到平台默认缓存库   解决方案 1.引入maven依赖 <!--jedis--> <dependency> <groupId>redis.clients</groupId>
Springboot + redis操作多种实现（以及Jedis,Redisson,Lettuce的区别比较）
热门推荐
诗和远方，任重道远
10-16 1万+
Springboot + redis 操作多种实现一、Jedis,Redisson,Lettuce三者的区别二、Jedis三、RedisTemplate3.1、使用配置3.2、使用示例3.3、扩展3.3.1、spring-boot-starter-data-redis的依赖包3.3.2、stringRedisTemplate API（部分展示）3.3.3 StringRedisTemplate默认...
redis快速入门手册
布道
12-13 3361
Redis是一个开源的使用ANSIC语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。从2010年3月15日起，Redis的开发工作由VMware主持。它在企业级应用中被广泛的使用，已经成为web开发者必须具备的技能之一。 目录 1.概述 1.1介绍 1.2 优缺点 1.3应用场景 1.4 Raft协议 1.5安装 2. ...
redis存储目录key目录乱码导致获取key的时候一直为null
stone的博客
04-26 1817
通过redis连接工具连接redis，获取key值的时候一直拿不到，后来才发现我保存在redis的key是目录结构的，保存的时候目录乱码了导致get key的时候一直为null 添加如下配置即可 package com.zyjc.base.message.config; import com.alibaba.fastjson.JSON; import com.alibaba.fastjson.serializer.SerializerFeature; import com.fasterxml.jacks
redis中以目录形式存储和读取数据
lizhengyu891231的博客
01-08 7445
叙述 项目中需要往Redis中写入和读取数据时，要以目录形式进行。 解决方案 key设置，可以参考以下： /** * redis key 接口参数 * key:key值 * expiredate:过期时间 */ public interface RedisKey { long START = 0L; long END = -1L; String TOK...
springboot操作redis
08-27
Spring Boot 是一个流行的 Java Web 开发框架，它提供了很多集成的方式来方便地操作 Redis。 要使用 Spring Boot 操作 Redis，你需要先在 `pom.xml` 文件中添加 Redis 相关的依赖： ```xml <groupId>org.spring...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值