Java连接Redis和SpringBoot整合Redis

🕗 发布于 2024-07-26 14:08 java redis spring boot

1. Java连接Redis

思考：我们之前操作redis都是通过命令行的客户端来操作。在开发时都是通过java项目操作redis

java提高连接redis的方式为jedis。我们需要遵循jedis协议。
java提供连接mysql的方式为jdbc。

1.1 单机模式

引入依赖

<!--引入java连接redis的驱动-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.3.1</version>
        </dependency>

若使用3.8.1的依赖，jedis中的setex方法会被划去

<dependency>
 <groupId>repMaven.redis.clients</groupId>
 <artifactId>jedis</artifactId>
 <version>3.8.0</version>
</dependency>

编写代码

package com.zmq;

import redis.clients.jedis.Jedis;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @program: redis1
 * @description: java连接redis
 * @author: zmq
 **/
public class Test01 {
    public static void main(String[] args) {
        //连接redis的信息，默认连接本地的redis端口 端口号6379,所有关于redis操作的功能都在Jedis类中
        Jedis jedis=new Jedis("172.16.7.112",6379);
        //关于key的命令
        //获取所有key值
        Set<String> keys = jedis.keys("*");
        System.out.println("获取所有的keys："+keys);
        //删除key的个数
        Long del = jedis.del("ll", "l1");
        System.out.println("删除key的个数"+del);
        //判定指定的key是否存在
        Boolean k4 = jedis.exists("k4");
        System.out.println("判断指定的k4是否存在"+k4);
        //给key指定过期时间
        jedis.expire("lll",100);


        //string类型
        //添加数据
        String set = jedis.set("k1", "v1");
        System.out.println("存入k1的值"+set);
        //获取指定的值
        String s = jedis.get("k1");
        System.out.println("获取指定k1的值"+s);
        //判断指定的值是否存在，若不存在，就创建
        Long k2 = jedis.setnx("k2", "v2");
        System.out.println("如果k2不存在，则设置k2的值："+k2);
        jedis.setnx("k3","110");
        //值递增
        Long k3 = jedis.incr("k3");
        System.out.println("k3的值加1"+k3);
        //值递减
        Long k31 = jedis.decr("k3");
        System.out.println("k3的值减1"+k31);
        //创建key并指定过期时间
        String setex = jedis.setex("k4", 100, "v3");
        System.out.println(setex);
        //关于hash的命令
        //存值
        long hset = jedis.hset("h1", "name", "lay");
        System.out.println("存入h1的键值对："+hset);
        //设置一个map
        Map<String,String> map=new HashMap<>();
        map.put("name","章三");
        map.put("age","18");
        long h2 = jedis.hset("h2", map);
        System.out.println("存入h2的键值对"+h2);
        //取值
        String hget = jedis.hget("h2", "name");
        System.out.println("获取h2中name的值"+hget);
        //获取key中的素有键值对的值
        Map<String, String> h21 = jedis.hgetAll("h2");
        System.out.println("获取h2中所有键值对的值"+h21);
        //获取所有哈希表中的值
        List<String> h22 = jedis.hvals("h2");
        System.out.println(h22);
        //获取所有哈希表中所有的字段
        Set<String> h23 = jedis.hkeys("h2");
        System.out.println(h23);
    }
}

关于连接redis的信息

连接redis的信息，默认连接本地的redis端口端口号6379

所有关于redis操作的功能都在Jedis类中
Jedis jedis=new Jedis("172.16.8.110",6379);

关于key的命令

获取所有key值——keys~~~~keys

 //获取所有key值
        Set<String> keys = jedis.keys("*");
        System.out.println("获取所有的keys："+keys);

删除key的个数——del~~~~del

 //删除key的个数
        Long del = jedis.del("ll", "l1");
        System.out.println("删除key的个数"+del);

判定指定的可以是否存在——exists~~~~exists

   //判定指定的key是否存在
        Boolean k4 = jedis.exists("k4");
        System.out.println("判断指定的k4是否存在"+k4);

创建key并给key指定过期时间——expire~~~~expire

        //给key指定过期时间
        jedis.expire("lll",100);

关于字符串String的命令

添加数据——set~~~~set

//添加数据
        String set = jedis.set("k1", "v1");
        System.out.println("存入k1的值"+set);

获取指定的值——get~~~~get

//获取指定的值
        String s = jedis.get("k1");
        System.out.println("获取指定k1的值"+s);

判断指定的值是否存在，若不存在，就创建——setnx~~~~setnx

        //判断指定的值是否存在，若不存在，就创建
        Long k2 = jedis.setnx("k2", "v2");
        System.out.println("如果k2不存在，则设置k2的值："+k2);

值递增，每次加1——incr~~~~incr

        jedis.setnx("k3","110");
        //值递增
        Long k3 = jedis.incr("k3");
        System.out.println("k3的值加1"+k3);

值递减，每次减1——decr~~~~decr

        //值递减
        Long k31 = jedis.decr("k3");
        System.out.println("k3的值减1"+k31);

创建key并指定过期时间——setex~~~~setex

        //创建key并指定过期时间
        String setex = jedis.setex("k4", 100, "v3");
        System.out.println(setex);

关于hash的命令

存值1——hset~~~~hset

//存值
        long hset = jedis.hset("h1", "name", "lay");
        System.out.println("存入h1的键值对："+hset);

存值2，存入map——hset~~~~hset

        //设置一个map
        Map<String,String> map=new HashMap<>();
        map.put("name","章三");
        map.put("age","18");
        long h2 = jedis.hset("h2", map);
        System.out.println("存入h2的键值对"+h2);

存值2，存入map
获取指定的key中指定的键值对的value值——hget~~~~hget

        //取值
        String hget = jedis.hget("h2", "name");
        System.out.println("获取h2中name的值"+hget);

获取key中所有键值对的值——hgetAll~~~~hgetAll

        //获取key中的素有键值对的值
        Map<String, String> h21 = jedis.hgetAll("h2");
        System.out.println("获取h2中所有键值对的值"+h21);

获取哈希表中所有的值——hvals~~~~hvals

        //获取所有哈希表中的值
        List<String> h22 = jedis.hvals("h2");
        System.out.println(h22);

获取哈希表中所有的字段——hkeys~~~~hkeys

        //获取所有哈希表中所有的字段
        Set<String> h23 = jedis.hkeys("h2");
        System.out.println(h23);

1.2 集群模式

连接redis的信息

 public static void main(String[] args) {
        Set<HostAndPort> nodes=new HashSet<>();
        nodes.add(new HostAndPort("# 1. Java连接Redis

> 思考：我们之前操作redis都是通过命令行的客户端来操作。在开发时都是通过java项目操作redis

java提高连接redis的方式jedis。我们需要遵循jedis协议。

****

## 1.1 单机模式

**引入依赖**

```xml
<!--引入java连接redis的驱动-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.3.1</version>
        </dependency>

若使用3.8.1的依赖，jedis中的setex方法会被划去

<dependency>
 <groupId>repMaven.redis.clients</groupId>
 <artifactId>jedis</artifactId>
 <version>3.8.0</version>
</dependency>

编写代码

package com.zmq;

import redis.clients.jedis.Jedis;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * @program: redis1
 * @description: java连接redis
 * @author: zmq
 **/
public class Test01 {
    public static void main(String[] args) {
        //连接redis的信息，默认连接本地的redis端口 端口号6379,所有关于redis操作的功能都在Jedis类中
        Jedis jedis=new Jedis("172.16.7.112",6379);
        //关于key的命令
        //获取所有key值
        Set<String> keys = jedis.keys("*");
        System.out.println("获取所有的keys："+keys);
        //删除key的个数
        Long del = jedis.del("ll", "l1");
        System.out.println("删除key的个数"+del);
        //判定指定的key是否存在
        Boolean k4 = jedis.exists("k4");
        System.out.println("判断指定的k4是否存在"+k4);
        //给key指定过期时间
        jedis.expire("lll",100);


        //string类型
        //添加数据
        String set = jedis.set("k1", "v1");
        System.out.println("存入k1的值"+set);
        //获取指定的值
        String s = jedis.get("k1");
        System.out.println("获取指定k1的值"+s);
        //判断指定的值是否存在，若不存在，就创建
        Long k2 = jedis.setnx("k2", "v2");
        System.out.println("如果k2不存在，则设置k2的值："+k2);
        jedis.setnx("k3","110");
        //值递增
        Long k3 = jedis.incr("k3");
        System.out.println("k3的值加1"+k3);
        //值递减
        Long k31 = jedis.decr("k3");
        System.out.println("k3的值减1"+k31);
        //创建key并指定过期时间
        String setex = jedis.setex("k4", 100, "v3");
        System.out.println(setex);
        //关于hash的命令
        //存值
        long hset = jedis.hset("h1", "name", "lay");
        System.out.println("存入h1的键值对："+hset);
        //设置一个map
        Map<String,String> map=new HashMap<>();
        map.put("name","章三");
        map.put("age","18");
        long h2 = jedis.hset("h2", map);
        System.out.println("存入h2的键值对"+h2);
        //取值
        String hget = jedis.hget("h2", "name");
        System.out.println("获取h2中name的值"+hget);
        //获取key中的素有键值对的值
        Map<String, String> h21 = jedis.hgetAll("h2");
        System.out.println("获取h2中所有键值对的值"+h21);
        //获取所有哈希表中的值
        List<String> h22 = jedis.hvals("h2");
        System.out.println(h22);
        //获取所有哈希表中所有的字段
        Set<String> h23 = jedis.hkeys("h2");
        System.out.println(h23);
    }
}

关于连接redis的信息

连接redis的信息，默认连接本地的redis端口端口号6379

所有关于redis操作的功能都在Jedis类中
Jedis jedis=new Jedis("172.16.8.110",6379);

关于key的命令

获取所有key值——keys~~~~keys

 //获取所有key值
        Set<String> keys = jedis.keys("*");
        System.out.println("获取所有的keys："+keys);

删除key的个数——del~~~~del

 //删除key的个数
        Long del = jedis.del("ll", "l1");
        System.out.println("删除key的个数"+del);

判定指定的可以是否存在——exists~~~~exists

   //判定指定的key是否存在
        Boolean k4 = jedis.exists("k4");
        System.out.println("判断指定的k4是否存在"+k4);

创建key并给key指定过期时间——expire~~~~expire

        //给key指定过期时间
        jedis.expire("lll",100);

关于字符串String的命令

添加数据——set~~~~set

//添加数据
        String set = jedis.set("k1", "v1");
        System.out.println("存入k1的值"+set);

获取指定的值——get~~~~get

//获取指定的值
        String s = jedis.get("k1");
        System.out.println("获取指定k1的值"+s);

判断指定的值是否存在，若不存在，就创建——setnx~~~~setnx

        //判断指定的值是否存在，若不存在，就创建
        Long k2 = jedis.setnx("k2", "v2");
        System.out.println("如果k2不存在，则设置k2的值："+k2);

值递增，每次加1——incr~~~~incr

        jedis.setnx("k3","110");
        //值递增
        Long k3 = jedis.incr("k3");
        System.out.println("k3的值加1"+k3);

值递减，每次减1——decr~~~~decr

        //值递减
        Long k31 = jedis.decr("k3");
        System.out.println("k3的值减1"+k31);

创建key并指定过期时间——setex~~~~setex

        //创建key并指定过期时间
        String setex = jedis.setex("k4", 100, "v3");
        System.out.println(setex);

关于hash的命令

存值1——hset~~~~hset

//存值
        long hset = jedis.hset("h1", "name", "lay");
        System.out.println("存入h1的键值对："+hset);

存值2，存入map——hset~~~~hset

        //设置一个map
        Map<String,String> map=new HashMap<>();
        map.put("name","章三");
        map.put("age","18");
        long h2 = jedis.hset("h2", map);
        System.out.println("存入h2的键值对"+h2);

存值2，存入map
获取指定的key中指定的键值对的value值——hget~~~~hget

        //取值
        String hget = jedis.hget("h2", "name");
        System.out.println("获取h2中name的值"+hget);

获取key中所有键值对的值——hgetAll~~~~hgetAll

        //获取key中的素有键值对的值
        Map<String, String> h21 = jedis.hgetAll("h2");
        System.out.println("获取h2中所有键值对的值"+h21);

获取哈希表中所有的值——hvals~~~~hvals

        //获取所有哈希表中的值
        List<String> h22 = jedis.hvals("h2");
        System.out.println(h22);

获取哈希表中所有的字段——hkeys~~~~hkeys

        //获取所有哈希表中所有的字段
        Set<String> h23 = jedis.hkeys("h2");
        System.out.println(h23);

1.2 集群模式

连接redis的信息

 public static void main(String[] args) {
        Set<HostAndPort> nodes=new HashSet<>();
        nodes.add(new HostAndPort("192.168.112.189",7001));
        nodes.add(new HostAndPort("192.168.112.189",7002));
        nodes.add(new HostAndPort("192.168.112.189",7003));
        nodes.add(new HostAndPort("192.168.112.189",7004));
        nodes.add(new HostAndPort("192.168.112.189",7005));
        nodes.add(new HostAndPort("192.168.112.189",7006));
        JedisCluster jedisCluster=new JedisCluster(nodes);
        jedisCluster.set("k5","666");
        System.out.println(jedisCluster.get("k5"));
    }

适合ssm项目

2. springboot整合redis

starter启动依赖——包含自动装配类，完成相应的装配功能

在这里插入图片描述

有关依赖——spring-boot-starter-data-redis

<!--引入了redis整合springboot 的依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

修改配置文件

#单机模式的配置
#Redis服务器连接端口
spring.redis.port=6379
#Redis服务器地址
spring.redis.host=IP地址
#Redis数据库索引(默认为0)
spring.redis.database=1
#连接池最大连接数(使用负值表示没有限制)
#spring.redis.jedis.pool.max-active=100
#连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=10
#连接池最大阻塞等待时间(使用负值表示没有限制)
spring.redis.jedis.pool.max-wait=10000ms

使用

springboot整合redis时封装了两个工具类：StringRedisTemplate和RedisTemplate——springboot中用于操作redsi的类

StringRedisTemplate它是RedisTemplate的子类。StringRedisTemplate里面只能存放字符串的内容

2.1 StringRedisTemplate

在测试类中进行相关方法的测试

首先需要自动注入StringRedisTemplate类

StringRedisTemplate类：是RedisTemplate的子类，key和value均为字符串

RedisTemplate中定义了5中数据结构操作

stringRedisTemplate.opsForValue();//操作字符串
     stringRedisTemplate.opsForHash();//操作hash
     stringRedisTemplate.opsForList();//操作列表
     stringRedisTemplate.opsForSet();//操作无序集合
     stringRedisTemplate.opsForZSet();//操作有序集合——有序是score的有序

关于key的操作

获取所有的key——keys

//获取所有的key
        Set<String> keys = stringRedisTemplate.keys("*");
        System.out.println("所有的key:"+keys);

返回值为Set集合，因为key唯一

是否删除指定的key，返回值为boolean——delete——释放锁

        //删除指定的key——返回值为boolean
        Boolean k1 = stringRedisTemplate.delete("k1");
        System.out.println("是否删除指定的k1:"+k1);

返回值为boolean

是否存在指定key——haskey

        //判断指定的key是否存在——返回值为boolean
        Boolean k11 = stringRedisTemplate.hasKey("k1");
        System.out.println("是否存在k1:"+k11);

返回值为boolean

是否设置过期时间——expire

        //设置过期时间——返回值为boolean
        Boolean k12 = stringRedisTemplate.expire("k1", 10, TimeUnit.HOURS);
        System.out.println("是否设置过期时间:"+k12);

返回值为boolean

根据key获取过期时间——getExpire

//根据key获取过期时间  
 
stringRedisTemplate.getExpire("test");

根据key获取过期时间并换算成指定的单位——getExpire

//根据key获取过期时间并换算成指定单位 
 
stringRedisTemplate.getExpire("test",TimeUnit.SECONDS);

getExpire(“test”,TimeUnit.SECONDS)

//关于key的操作
    @Test
    void testKeys() {
        //获取所有的key
        Set<String> keys = stringRedisTemplate.keys("*");
        System.out.println("所有的key:"+keys);
        //删除指定的key——返回值为boolean
        Boolean k1 = stringRedisTemplate.delete("k1");
        System.out.println("是否删除指定的k1:"+k1);
        //判断指定的key是否存在——返回值为boolean
        Boolean k11 = stringRedisTemplate.hasKey("k1");
        System.out.println("是否存在k1:"+k11);
        //设置过期时间——返回值为boolean
        Boolean k12 = stringRedisTemplate.expire("k1", 10, TimeUnit.HOURS);
        System.out.println("是否设置过期时间:"+k12);
    }

关于String的操作

得到操作字符串的类对象——opsForValue

//得到操作字符串的类对象
        ValueOperations<String, String> opsForValue = stringRedisTemplate.opsForValue();

存放数据——set

        //存放数据---set(k,v)
        opsForValue.set("k1","v1");

存放数据，含有过期时间——set

 //存放数据--setex(k,second,v)
        opsForValue.set("k2","20",2,TimeUnit.MINUTES);

存放数据，先判断是否已存在——setIfAbsent——分布式锁

//存放数据--setnx(k,v)
        Boolean aBoolean = opsForValue.setIfAbsent("k3", "v3", 2, TimeUnit.MINUTES);
        System.out.println("是否设置成功:"+aBoolean);

根据key获取val——get

//获取指定的元素
        String k1 = opsForValue.get("k1");
        System.out.println("获取指定的元素:"+k1);

自增——incream

//自增
        Long k21 = opsForValue.increment("k2");
        System.out.println("自增1："+k21);

自增指定长度——incream

        //自增指定长度
        Long k2 = opsForValue.increment("k2", 10);
        System.out.println("获取指定的元素:"+k2);

自减指定长度——incream,数值为负数即可

        //自减
        Long k22 = opsForValue.increment("k2", -1);
        System.out.println("获取指定的元素："+k22);

重新赋值——getAndSet

        //重新赋值
        String andSet = opsForValue.getAndSet("k1", "vvvv");
        System.out.println("重新赋值："+andSet);

 //关于String的操作: 在封装的StringRedisTemplate类对应每种数据类型的操作 对应相应的类来完成
    @Test
    void testString() {
        //得到操作字符串的类对象
        ValueOperations<String, String> opsForValue = stringRedisTemplate.opsForValue();
        //存放数据---set(k,v)
        opsForValue.set("k1","v1");
        //存放数据--setex(k,second,v)
        opsForValue.set("k2","20",2,TimeUnit.MINUTES);

        //存放数据--setnx(k,v)
        Boolean aBoolean = opsForValue.setIfAbsent("k3", "v3", 2, TimeUnit.MINUTES);
        System.out.println("是否设置成功:"+aBoolean);

        //获取指定的元素
        String k1 = opsForValue.get("k1");
        System.out.println("获取指定的元素:"+k1);

        //自增
        Long k21 = opsForValue.increment("k2");
        System.out.println("自增1："+k21);
        //自增指定长度
        Long k2 = opsForValue.increment("k2", 10);
        System.out.println("获取指定的元素:"+k2);
        //自减
        Long k22 = opsForValue.increment("k2", -1);
        System.out.println("获取指定的元素："+k22);
        //重新赋值
        String andSet = opsForValue.getAndSet("k1", "vvvv");
        System.out.println("重新赋值："+andSet);
    }

关于Hash的操作——适合存放对象，操作属性方便

获取操作字符串的类对象——opsForHash

//获取操作字符串的类对象
        HashOperations<String, Object, Object> forHash = stringRedisTemplate.opsForHash();

存放数据——put

        //存放数据  hset(key,field,value)
        forHash.put("user","name","ykq");

存放map集合——putAll

        //存放map
        Map<String,String> map=new HashMap<>();
        map.put("age","18");
        map.put("adrress","北京");
        forHash.putAll("user",map);

获取指定的元素——get

        //获取指定的元素  hget(key,field)
        Object o = forHash.get("user", "name");
        System.out.println("获取指定的元素:"+o);

获取所有的元素——entries

        Map<Object, Object> user = forHash.entries("user");
        System.out.println("获取所有的元素:"+user);

获取所有的key——keys

        Set<Object> user1 = forHash.keys("user");
        System.out.println("获取所有的key:"+user1);

获取所有的value——values

        List<Object> user2 = forHash.values("user");
        System.out.println("获取所有的value:"+user2);

 //关于Hash的操作
    @Test
    public void testHash(){
        //获取操作字符串的类对象
        HashOperations<String, Object, Object> forHash = stringRedisTemplate.opsForHash();
        //存放数据  hset(key,field,value)
        forHash.put("user","name","ykq");
        //存放map
        Map<String,String> map=new HashMap<>();
        map.put("age","18");
        map.put("adrress","北京");
        forHash.putAll("user",map);
        //获取指定的元素  hget(key,field)
        Object o = forHash.get("user", "name");
        System.out.println("获取指定的元素:"+o);
        Map<Object, Object> user = forHash.entries("user");
        System.out.println("获取所有的元素:"+user);
        Set<Object> user1 = forHash.keys("user");
        System.out.println("获取所有的key:"+user1);
        List<Object> user2 = forHash.values("user");
        System.out.println("获取所有的value:"+user2);
    }

2.2 RedisTemplate

它属于StringRedisTemplate的父类，它的泛型默认都是Object。它可以直接存储任意类型的key和value

序列化

//自动注入StringRedisTemplate模板
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void test1(){
        ValueOperations valueOperations = redisTemplate.opsForValue();
        //第一次存值
        valueOperations.set("k111","v11");//此时出现乱码，且在RedisPlus图形化工具中，并不能点击该key，显示该key不存在
        System.out.println(valueOperations.get("k111"));

        //org.springframework.data.redis.serializer.SerializationException: 会出现序列化异常，需要实体类User实现序列化接口
        //第二次存值
        valueOperations.set("k12",new User("zxy",18));//把内存中的数据存入磁盘---序列化过程

    }

上述代码显示的问题：

第一次存值，可以成功运行，但出现乱码，且在RedisPlus图形化工具中，并不能点击该key，显示该key不存在
第二次存值，报错：序列化异常，需要实体类User实现序列化接口

分析key出现乱码：

key值为乱码：所以key需要序列化，而key默认的序列化方式为JDK序列化，为二进制

StringRedisTemplate类并没有出现乱码——因为他有自己的序列化方式，没有实现JDK序列化

解决：设置key的序列化方式
//设置key的序列化方式
        redisTemplate.setKeySerializer(new StringRedisSerializer());
此时，解决key的乱码问题，图形化界面的key可以点击查看，发现value值为乱码：

value值为乱码：value默认的序列化方式也为JDK序列化，JDK序列化方式需要实现序列化接口

StringRedisTemplate类并没有出现乱码——因为他有自己的序列化方式，没有实现JDK序列化

解决：设置value的序列化方式
        //2. 设置value的序列化方式
        redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<Object>(Object.class));
使用Jackson2JsonRedisSerializer序列化的时候,如果实体类上没有set方法反序列化会报错。

若使用FastJsonRedisSerializer序列化方式，需要引入fastjson依赖
<dependency>
           <groupId>com.alibaba</groupId>
           <artifactId>fastjson</artifactId>
           <version>1.2.83</version>
       </dependency>

如果使用RedisTemplate，每次都需要人为指定key和value的序列化，所以抽象出指定key和value序列化的工具类

配置文件

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
        template.setConnectionFactory(redisConnectionFactory);
        template.setKeySerializer(jackson2JsonRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

2.3 集群模式

修改配置文件即可

#集群模式
spring.redis.cluster.nodes=192.168.112.189:7006,192.168.112.189:7001,192.168.112.189:7002,192.168.112.189:7003,192.168.112.189:7004,192.168.112.189:7005

2.4 二者区别

StringRedisTemplate和RedisTemplate的区别

前者集成后者
数据不共通的。即StringRedisTemplate只能管理StringRedisTemplate里面的数据，RedisTemplate只能管理RedisTemplate中的数据
SDR默认采用的序列化有两种。一种是String的序列化策略，一种是JDK的序列化策略；
StringRedisTemplate默认采用的是String 的序列化策略，保存的key和value都是采用的该策略序列化并保存的
RedisTemplate默认采用的是JDK的序列化策略，保存的 key和value都是采用此策略序列化并保存的

原文地址：https://blog.csdn.net/qq_59099003/article/details/140698619

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：小红书广告跳转跳转微信可以实现吗？跳转获客助手如何实现
下一篇：CSS（九）——CSS 轮廓（outline）

linux线程cp模型，posix信号量，线程池，线程封装，单例模型，懒汉饿汉实现方式，自旋锁，读者写者模型
前面的同步，我们并没有一个很好的场景来模拟同步，只是简单的将有序的现象输出出来；现在我们来讲解一个比较合理且常见的模型——生产者消费者模型；
阅读更多2024-09-07
Qt/C++开源项目 TCP服务器调试助手（源码分享+发布链接下载）
该TCP服务器调试助手是用于测试和监控基于TCP协议的网络通信工具，能够帮助开发者便捷地进行网络通信调试。通过简洁的界面设计，用户可以轻松配置、管理TCP端口的连接，收发消息并进行数据监控分析。123
阅读更多2024-09-07
vue3整合antv x6实现图编辑器快速入门
例如：在上面节点基础上，我们有一个新的需求：给节点加上右键菜单。X6 支持使用 SVG、HTML 来渲染节点内容，在此基础上，我们还可以使用 React、Vue 组件来渲染节点，这样在开发过程中会非常
阅读更多2024-09-07
linux使用samba共享目录，其他虚拟机和windows都可以访问
linux使用samba共享目录，其他虚拟机和windows都可以访问
阅读更多2024-09-07
Linux系统编程实现ls -l | wc -l指令
由于该指令是通过管道的形式实现的，所以我们要使用系统函数pipe。ls -l |wc -l的作用就是统计当前目录有多少文件。由于父子间通过管道实现，所以存在读写阻塞问题，不用担心僵尸进程的产生，所以可
阅读更多2024-09-07
MySQL表操作及约束
MySQL表操作及约束
阅读更多2024-09-07
1.2CubeMAX创建FREERTOS入门示例
内核参数设置，用户根据自己的实际应用来裁剪定制。：相关宏的定义，可以自建一些常量在工程中使用。User Constants（用户常量）：定时器和信号量的创建。：用于查看堆使用情况。：任务与队列
阅读更多2024-09-07
YOLOv9改进策略【注意力机制篇】| PSA极化自我关注：实现高质量像素回归
本文记录的是基于PSA注意力模块的YOLOv9目标检测方法研究。PSA模块。本文将其应用到YOLOv9的检测任务中，使模型能够更好地捕捉图像中的细节信息，以实现目标检测任务中准确识别和定位。
阅读更多2024-09-07
爆改YOLOv8|利用yolov10的SCDown改进yolov8-下采样
yolov8改进，yolov10, 下采样SCDown, 即插即用
阅读更多2024-09-07
PDF样本图册转换为一个链接，随时打开无需印刷
想象一下，您手中有一本厚重的样本图册，里面包含了丰富多样的内容，如产品介绍、项目方案、学术论文等。在过去，您需要逐一翻阅、筛选，甚至为了便于查看，不得不将其印刷出来。如今，借助先进的数字化技术，还能实
阅读更多2024-09-07

Java连接Redis和SpringBoot整合Redis

1. Java连接Redis

1.1 单机模式

1.2 集群模式

1.2 集群模式

2. springboot整合redis

2.1 StringRedisTemplate

2.2 RedisTemplate

2.3 集群模式

2.4 二者区别

相关文章