• 2022最新版Redis入门到精通(云课堂视频学习笔记)

    学习视频：

    2022最新版Redis入门到精通 - 网易云课堂

     

     

     学习笔记：

    目录

    一、初识Redis-认识NoSQL

    1.认识NoSQL

    2.认识Redis

    3.安装Redis

    二、Redis常见命令

    2.1 Redis数据结构介绍

    2.2 通用命令

    2.3 不同数据结构的操作命令

    2.3.1 String类型（值是String字符串）

    2.3.2 Hash类型（值是Hash表）

    2.3.3 List类型(值是List集合)

    问题：如何利用List结构模拟一个阻塞队列？

    2.3.4 Set类型（底层是Hash表）

    2.3.5 SortedSet类型（可排序的集合，底层是一个跳表（SkipList）加hash表）

    三、Redis的Java客户端Clients | Redis

    3.1 Radis的Java客户端-Jedis客户端

    3.1.1Jedis客户端快速入门

    3.1.2Jedis客户端-Jedis的连接池

     3.2 Radis的Java客户端-SpringDataRedis客户端

    3.2.1认识SpringDataRedis

    3.2.1SpringDataRedis快速入门

     3.2.2Redis的Java客户端-Redis Template的RedisSerializer序列化方式

    3.3 Radis的Java客户端-StringRedisTemplate

    总结：

    3.4 Radis的Java客户端-RedisTemplate操作Hash类型

    一、初识Redis-认识NoSQL

    1.认识NoSQL

    SQL语言，是结构化查询语言(Structured Query Language)的简称。

    结构化不建议去修改，最好在表建立之初，就建立好，不然后续如果要修改可能会在成锁表。

    关系型数据库，就是表和表之间是有联系的：

    #2关联的（Relational）：                    无关联的#2：通过json文档的嵌套的一种形式去记录数据：

                     

     #3SQL查询：无论什么SQL数据库（MySQL、Orecal），查询的语法是固定的，都能用一种语法查询。   

    非SQL#3：查询语法是不固定的，不统一的。如下（Redis：命令、MongoDB：函数、elasticsearch：http请求），优点就是简单、没有复杂的语法需要学习。缺点：不统一，各不相同。

     

     #4事务ACID：所有的关系型数据库都是满足A、C、I、D。ACID为原子性（Atomicity）、一致性(Consistency)、隔离性（Isolation)、持久性（Durability)的总称。（对安全性要求较高，就应该优先选择SQL关系型数据库。）

    SQL数据库的ACID特性

    事务BASE#4：BASE：基本可用（BA)、软状态（S）、最终一致性（E）。NoSQL中的“BASE”特性

    总结：

    2.认识Redis

    Redis6.0仅仅针对网络请求处理这一部分是多线程的，其他核心的命令的执行部分依然是单线程的。

    Redis是基于C语言编写的，所以具备良好的编码。

    速度快、性能高的核心的原因是基于内存，所以速度快。

    基于内存的缺点是，一旦断电，数据无法保存。所以加了数据持久化，一段时间保存一次数据。

    3.安装Redis

    先安装虚拟机：

    (43条消息) 虚拟机安装：“VMware-workstation-full-16.2.4”和“镜像”下载安装_时时师师的博客-CSDN博客

    再安装Redis：

    (53条消息) Redis安装说明_时时师师的博客-CSDN博客

    二、Redis常见命令

    2.1 Redis数据结构介绍

    先学会怎么用这些数据类型，然后学习什么时候使用这些数据类型。

    要学习命令行，肯定要先学习帮助文档。（学习的时候不是死记硬背，而是参考文档来学习。边学，边查询。）

    在官网https://redis.io/commands可以查看到不同的命令。可以看到在redis中的这些命令都是分组去学习的。一组一组的来，就能看到了。

     除了在官方网站去看，在虚拟机的终端上用命令行（没有文档介绍的详细。最好不用），也能看到这些帮助文档。

    #查看通用的命令

    192.168.122.1:6379> help @generic

    #分组单独查询

    192.168.122.1:6379> help @String

    192.168.122.1:6379> help @List

    等

    2.2 通用命令

    通用命令是任何数据类型都可以使用的命令，常见的有：

    到官方文档去查看，通用的是放在Generic。

     也可以通过命令行：#查看通用的命令192.168.122.1:6379> help @generic

    常用的几个命令：

     （虚拟机的终端上）写到一半的时候按Tab键是可以自动补全的。

    • KEYS：Find all keys matching the given pattern（查看符合模版的所有key）。不建议在生产环境设备上使用。

    （模糊查询：*代表多个字符位或所有。精准查询：？代表一个字符位。）

    •  DEL：删除一个指定的key。（Delete a key）（或者批量删除。）

    返回值代表的是删除的key的数量，因为已经删除过看k1、k2了，所以不存在，删除0个返回值就是0。

    MSET 批量插入键值。

    •  EXISTS：判断一个key是否存在。（确定，查明Determine if a key exists）

     

    •  EXPIRE：给一个key设置有效期，有效期到期时该key会被自动删除。单位是秒。

    （Set a key's time to live in seconds）（默认key的有效期是永久有效。）

    （建议存储数据时，都设置有效期。）

    （到期自动删除，基于内存存储的redis就可以节省redis的有效空间，例如验证码，只有效60s，就可以删除。）

    •  TTL：查看一个KEY的剩余有效期。单位是秒。（Get the time to live for a key in seconds）

    （当一个key的有效期变成-2的时候，代表这个key已经被移除了。）

    （当一个key的有效期变成-1的时候，代表这个key永久有效。）

    即直接存储，一个key和值，有效期就是-1。永久有效。

    2.3 不同数据结构的操作命令

    redis是键值型的数据库，只不过它的值的类型五花八门。最简单的一种数据类型String。

    2.3.1 String类型（值是String字符串）

    String类型的常见命令：

    增、查、批量增加、批量查找；

    自增、步长自增、浮点步长自增；

    新增、新增指定有效期。

    • DECRBY：自减并指定步长。 

     执行结果：

    192.168.1.107:6379> set name ai
    OK
    192.168.1.107:6379> get name
    "ai"
    192.168.1.107:6379> set name ci
    OK
    192.168.1.107:6379> get name 
    "ci"
    192.168.1.107:6379> MSET k1 v1 k2 v2 k3 v3
    OK
    192.168.1.107:6379> MGET name age k1 k2 k3 
    1) "ci"
    2) "20"
    3) "v1"
    4) "v2"
    5) "v3"
    192.168.1.107:6379> INCR age
    (integer) 21
    192.168.1.107:6379> get age
    "21"
    192.168.1.107:6379> INCRBY age 3
    (integer) 24
    192.168.1.107:6379> get age
    "24"
    192.168.1.107:6379> INCRBY age -2
    (integer) 22
    192.168.1.107:6379> INCRBY age -2
    (integer) 20
    192.168.1.107:6379> DECRBY age 3
    (integer) 17
    192.168.1.107:6379> set score 10.1
    OK
    192.168.1.107:6379> INCRBYFLOAT score 2.6
    "12.7"
    192.168.1.107:6379> help setnx

      SETNX key value
      summary: Set the value of a key, only if the key does not exist
      since: 1.0.0
      group: string

    192.168.1.107:6379> key *
    (error) ERR unknown command 'key', with args beginning with: '*' 
    192.168.1.107:6379> keys *
    1) "k3"
    2) "age"
    3) "k2"
    4) "k1"
    5) "name"
    6) "score"
    192.168.1.107:6379> setnx name lisi
    (integer) 0
    192.168.1.107:6379> get name
    "ci"
    192.168.1.107:6379> setnx name2 lisi
    (integer) 1
    192.168.1.107:6379> get name2
    "lisi"
    192.168.1.107:6379> setex name 10 jack
    OK
    192.168.1.107:6379> get name
    "jack"
    192.168.1.107:6379> ttl name
    (integer) -2
    192.168.1.107:6379> setex name3 sam 10
    (error) ERR value is not an integer or out of range
    192.168.1.107:6379> setex name3 10 sam
    OK
    192.168.1.107:6379> ttl name3
    (integer) 4
    192.168.1.107:6379> 
     

     问题：

     key的结构:层级结构！！用“：”隔开。

     执行结果：

    192.168.1.107:6379> set heima:user:1 '{"id":1,"name":"Jack","age":21}'
    OK
    192.168.1.107:6379> set heima:user:2 '{"id":2,"name":"Rose","age":18}'

    192.168.1.107:6379> set heima:product:1 '{"id":1,"name":"小米11","price":4999}'
    OK

    192.168.1.107:6379> set heima:product:2 '{"id":2,"name":"荣耀6","price":2999}'
    OK

    192.168.1.107:6379> keys *
     1) "k3"
     2) "heima:product:1"
     3) "score"
     4) "heima:user:2"
     5) "name2"
     6) "heima:user:1"
     7) "age"
     8) "k2"
     9) "k1"
    10) "heima:product:2"
    192.168.1.107:6379> 

    图形化界面的客户端里：

     

    2.3.2 Hash类型（值是Hash表）

     

     执行结果：

     

     

     user:3没有sex这个属性，所以可以使用HSETNX 添加sex。

    2.3.3 List类型(值是List集合)

     

     执行结果：

     LPOP、RPOP：左侧、 右侧取得并移除：

     BLPOP、BRPOP等待指定时间，获取后删除：

    问题：如何利用List结构模拟一个阻塞队列？

    栈：先进后出。（既是入口也是出口<-框子——》框底）

    队列：先进先出。（入口<-框子——>出口）

    2.3.4 Set类型（底层是Hash表）

    执行结果：

    案例练习：                                                            执行结果：

    2.3.5 SortedSet类型（可排序的集合，底层是一个跳表（SkipList）加hash表）

     多了一个score元素。

     还有很多命令，可以去官网看看：

     去控制台看看：help @sorted-set 或help @Sorted-Set

    案例：

    执行结果：ZADD stus 85 Jack 89 Lucy 82 Rose 95 Tom 78 Jerry 92 Amy 76 Miles 

    默认升序： 

     

     

    三、Redis的Java客户端Clients | Redis

    在Redis官网中提供了各种语言的客户端， 下图中的地址作废，变成Clients | Redis

     

     官网上面的文字说推荐我们使用带红心💖和⚡的客户端。

     简洁介绍：

    虽然SpringDataRedis客户端会整合Jedis和lettuce，但是有一些企业依然喜欢分开用，所以，我们也要分开学Jedis和lettuce，然后也要学SpringDataRedis客户端。

    3.1 Radis的Java客户端-Jedis客户端

    3.1.1Jedis客户端快速入门

    Jedis的官网地址：https://github.com/redis/jedis,我们先来个快速入门：

    创建一个maven工程：

    3.1.1.1引入依赖

    2.     <dependency>
    3.       <groupId>redis.clientsgroupId>
    4.       <artifactId>jedisartifactId>
    5.       <version>4.3.1version>
    6.     dependency>
    7.  
    8.     <dependency>
    9.       <groupId>junitgroupId>
    10.       <artifactId>junitartifactId>
    11.       <version>4.13.2version>
    12.       <scope>testscope>
    13.     dependency>
    15.     <dependency>
    16.       <groupId>org.junit.jupitergroupId>
    17.       <artifactId>junit-jupiterartifactId>
    18.       <version>5.9.0version>
    19.       <scope>testscope>
    20.     dependency>

    3.1.1.2创建Jedis对象，建立连接

    3.1.1.3使用Jedis，方法名名与redis命令名称一致！！！！）

    3.1.1.4释放资源

    1. package com.jedis.test;
    2.  
    3. import org.junit.jupiter.api.AfterEach;
    4. import org.junit.jupiter.api.BeforeEach;
    5. import org.junit.jupiter.api.Test;
    6. import redis.clients.jedis.Jedis;
    7.  
    8. public class JedisTest {
    9.     private Jedis jedis;
    10.     @BeforeEach
    11.     void setUP(){
    12.         //建立链接
    13.         jedis =new Jedis("192.168.1.107",6379);
    14.         //设置密码
    15.         jedis.auth("123456");
    16.         //选择库
    17.         jedis.select(0);
    18.     }
    19.     @Test
    20.     void testString(){
    21.         //存入数据,方法名名称就是redis命令名称！！！！
    22.         String result =jedis.set("name","望湖");
    23.         System.out.println("result = "+result);
    24.         //获取数据
    25.         String name =jedis.get("name");
    26.         System.out.println("name = "+name);
    27.     }
    28.     @AfterEach
    29.     void tearDown(){
    30.         //释放资源
    31.         if(jedis != null){
    32.             jedis.close();
    33.         }
    34.     }
    35. }

     值得注意的是：释放资源这里的close（）也已经不是关闭了，而是归还。

    执行结果：

    那么查询Hash类型的呢？

    1.     @Test
    2.     void testHash(){
    3.         //插入hash数据
    4.         jedis.hset("user:1","name","Jack");
    5.         jedis.hset("user:1","age","23");
    6.         //获取
    7.          Map map = jedis.hgetAll("user:1");
    8.          System.out.println("map = "+map);
    9.     }

    3.1.2Jedis客户端-Jedis的连接池

    Jedis本身是线程不安全的，如果说在多线程的环境下并发的使用Jedis是有可能出现问题的。

    并且频繁的创建和销毁Jedis对象会有性能损耗。

    因此我们推荐大家使用Jedis连接池代替Jedis的直连方式。

    具体如下：

    建立Jedis工具类JedisConnectionFactory、新建Jedis的静态成员变量JedisPool、编写静态代码块（配置参数、新建JedisPool对象）、编写静态方法（从JedisPool资源中获取Jedis对象）。

    1. package com.jedis.until;
    2.  
    3. import redis.clients.jedis.Jedis;
    4. import redis.clients.jedis.JedisPool;
    5. import redis.clients.jedis.JedisPoolConfig;
    6.  
    7. import java.time.Duration;
    8.  
    9. public class JedisConnectionFactory {
    10.     private static final JedisPool jedisPool;
    11.  
    12.     static {
    13.         //配置连接池
    14.         JedisPoolConfig poolConfig = new JedisPoolConfig();
    15.         //最大连接数 （连接池里最多允许创建八个连接）
    16.         poolConfig.setMaxTotal(8);
    17.         //最大空闲连接(没有人来访问，也会预备8个连接)
    18.         poolConfig.setMaxIdle(8);
    19.         //最小空闲连接 (如果一直没人访问，这些连接就会被释放)
    20.         poolConfig.setMinIdle(0);
    21.          //等待时长（等待一段时间这些连接才会被释放）
    22.         //poolConfig.setMaxWaitMillis(1000);
    23.         poolConfig.setMaxWait(Duration.ofMillis(1000));
    24.         //poolConfig.setMaxWait(Duration.ofDays(1000));
    25.         //poolConfig.setMaxWait(Duration.ofHours(1000));
    26.         //创建连接对象 timeout代表传输时间
    27.         jedisPool = new JedisPool(poolConfig,
    28.                 "192.168.1.107",6379,1000,"123456");
    29.     }
    30.     public static Jedis getJedis(){
    31.         return jedisPool.getResource();
    32.     }
    33.  
    34. }

     poolConfig.setMaxWaitMillis(1000);过时了，他的底层代码：

    所以，改成poolConfig.setMaxWait(Duration.ofMillis(1000));仔细查看，可以发现，现在可以写：秒、小时、天数等。

    修改：

     

    其他内容不变。执行结果也不变，是正确的。

    值得注意的是：释放资源这里的close（）也已经不是关闭了，而是归还。

     
    3.2 Radis的Java客户端-SpringDataRedis客户端

    3.2.1认识SpringDataRedis

    Spring Data Redis https://spring.io/projects/spring-data-redis

    3.2.1SpringDataRedis快速入门

    SpringBoot已经提供了对SpringDataRedis的支持，使用非常简单：

    3.2.1.1创建一个SpringBoot新项目：

     3.2.1.2引入依赖

    1.         
    2.         <dependency>
    3.             <groupId>org.springframework.bootgroupId>
    4.             <artifactId>spring-boot-starter-data-redisartifactId>
    5.             <version>2.7.4version>
    6.         dependency>
    7.         
    8.         <dependency>
    9.             <groupId>org.apache.commonsgroupId>
    10.             <artifactId>commons-pool2artifactId>
    11.             <version>2.11.1version>
    12.         dependency>

    3.2.1.3编写配置文件，配置redis。

    1. spring:
    2.   redis:
    3.     host: 192.168.1.107
    4.     port: 6379
    5.     password: 123456
    6.     lettuce: #这里可以选择lettuce也可以选择Jedis，但是spring默认使用lettuce。要使用Jedis需要额外引入依赖并配置。
    7.       pool:
    8.         max-active: 8 #最大连接
    9.         max-idle: 8 #最大空闲连接
    10.         min-idle: 0 #最小空闲连接
    11.         max-wait: 100 #连接等待时间

    3.2.1.4注入RedisTemplate

    @Autowired
private RedisTemplate redisTemplate;

    3.2.1.5编写测试

    1. package com.redis;
    2. import org.junit.jupiter.api.Test;
    3. import org.springframework.beans.factory.annotation.Autowired;
    4. import org.springframework.boot.test.context.SpringBootTest;
    5. import org.springframework.data.redis.core.RedisTemplate;
    6. @SpringBootTest
    7. class RedisDemoApplicationTests {
    8.     @Autowired
    9.     private RedisTemplate redisTemplate;
    10.     @Test
    11.     void testString() {
    12.         //插入一条string类型的数据
    13.         redisTemplate.opsForValue().set("name","李四");
    14.         //读取一条string类型的数据
    15.         Object name = redisTemplate.opsForValue().get("name");
    16.         System.out.println("name = "+ name);
    17.         //插入一条string类型的数据
    18.         redisTemplate.opsForValue().set("nameS","李小四");
    19.         //读取一条string类型的数据
    20.         Object nameS = redisTemplate.opsForValue().get("nameS");
    21.         System.out.println("nameS = "+ nameS);
    22.     }
    23. }

    3.2.1.6执行结果： 

     

    不知道为什么到Redis客户端里面变成这样了！！

    这是因为，在redisTemplate.opsForValue().set("name","李四");这个方法中，接收的参数并不是字符串，而是Object。SpringDataRedis的特殊功能，它可以接收任何类型的对象，然后帮我们转成redis可以处理的字节。所以我们存进去的"name"、"李四"都被当成了Java对象，而Redis Template底层，默认对这些对象的处理方式就是利用JDK的序列化工具ObjectOutputStream,把redis对象转成字节。

    从下面可以看出以上论断：

     可以看到上面的序列化器都没有定义，而是等于null。这时候，就会启动默认的序列化器this.defaultSerializer：

    1.  if (this.valueSerializer == null) {
    2.             this.valueSerializer = this.defaultSerializer;
    3.             defaultUsed = true;
    4.         }

     具体代码：

    public void afterPropertiesSet() {
    super.afterPropertiesSet();
    boolean defaultUsed = false;
    if (this.defaultSerializer == null) {
        this.defaultSerializer = new JdkSerializationRedisSerializer(this.classLoader != null ? this.classLoader : this.getClass().getClassLoader());
    }

    if (this.enableDefaultSerializer) {
        if (this.keySerializer == null) {
            this.keySerializer = this.defaultSerializer;
            defaultUsed = true;
        }

        if (this.valueSerializer == null) {
            this.valueSerializer = this.defaultSerializer;
            defaultUsed = true;
        }

        if (this.hashKeySerializer == null) {
            this.hashKeySerializer = this.defaultSerializer;
            defaultUsed = true;
        }

        if (this.hashValueSerializer == null) {
            this.hashValueSerializer = this.defaultSerializer;
            defaultUsed = true;
        }
    }

    if (this.enableDefaultSerializer && defaultUsed) {
        Assert.notNull(this.defaultSerializer, "default serializer null and not all serializers initialized");
    }

    if (this.scriptExecutor == null) {
        this.scriptExecutor = new DefaultScriptExecutor(this);
    }

    this.initialized = true;
}

    还可以更清晰地看，追本溯源：

     3.2.2Redis的Java客户端-Redis Template的RedisSerializer序列化方式

    Redis Template可以接收任意Object作为值写入Redis，只不过写入前会把Object序列化为字节形式，默认采用JDK序列化，得到的结果是：

     缺点：

    • 可读性差。（识别不出name=“李四”是那么长一串字符。）
    • 内存占用较大。（name变得那么长作为key。）

    通过上面可知使用默认的序列化，就会变成这样的字节形式，所以我们换一种方式：

    我们不希望使用JdkSerializationRedisSerializer(classLoader);，可以看到下面还有好多序列化方式：

     其中StringRedisSerializer.UTF_8;是专门用来处理字符串的，底层是getBytes(this.charset);。所以处理key值（字符串）一般用这个。

    那么vlaue值有可能是对象，那么建议使用GenericJackson2JsonRedisSerializer();转json字符串的序列化。

    那我们产生一个猜想，是不是把这里的null修改成一个确定的值就可以了呢？

    我们可以自定义RedisTemplate的序列化方式，代码如下：

    创建一个新的类RedisConfig.class：

     定义泛型RedisTemplate。key永远都是String，Value则是Object。

    1. package com.redis.config;
    2.  
    3. import org.springframework.context.annotation.Bean;
    4. import org.springframework.context.annotation.Configuration;
    5. import org.springframework.data.redis.connection.RedisConnectionFactory;
    6. import org.springframework.data.redis.core.RedisTemplate;
    7. import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    8. import org.springframework.data.redis.serializer.RedisSerializer;
    9.  
    10. import java.net.UnknownHostException;
    11.  
    12. @Configuration
    13. public class RedisConfig {
    14.     @Bean
    15.     public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory)
    16.             throws UnknownHostException {
    17.         //创建RedisTemplate对象
    18.         RedisTemplate redisTemplate = new RedisTemplate<>();
    19.         //创建连接工厂
    20.         redisTemplate.setConnectionFactory(redisConnectionFactory);
    21.         //创建JSON序列化工具
    22.         GenericJackson2JsonRedisSerializer jsonRedisSerializer
    23.                 = new GenericJackson2JsonRedisSerializer();
    24.         //key和HashKey采用String序列化
    25.         redisTemplate.setKeySerializer(RedisSerializer.string());
    26.         redisTemplate.setHashKeySerializer(RedisSerializer.string());
    27.         //value和HashValue采用JSON序列化
    28.         redisTemplate.setValueSerializer(jsonRedisSerializer);
    29.         redisTemplate.setHashValueSerializer(jsonRedisSerializer);
    30.         return redisTemplate;
    31.     }
    32. }

     修改测试类：里面的RedisTemplate为RedisTemplate。

    @Autowired
private RedisTemplate redisTemplate;

    执行测试类：报错“类没有被找到”，缺少JACKSON的依赖：Caused by: java.lang.NoClassDefFoundError: com/fasterxml/jackson/databind/jsontype/impl/StdTypeResolverBuilder
        at com.redis.config.RedisConfig.redisTemplate(RedisConfig.java:22)

    引入依赖：

    1.         
    2.         <dependency>
    3.             <groupId>com.fasterxml.jackson.coregroupId>
    4.             <artifactId>jackson-databindartifactId>
    5.             <version>2.13.4.2version>
    6.         dependency>

    重新运行程序，执行结果正常了： 

    再尝试一下，添加一个对象：

    新建一个类：

    1. import lombok.AllArgsConstructor;
    2. import lombok.Data;
    3. import lombok.NoArgsConstructor;
    4. //get、set方法；无参、有参构造。
    5. @Data 
    6. @NoArgsConstructor
    7. @AllArgsConstructor
    8. public class User {
    9.     private String name;
    10.     private Integer age;
    11. }

     编写单元测试：

    1. package com.redis;
    2. import com.redis.pojo.User;
    3. import org.junit.jupiter.api.Test;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.boot.test.context.SpringBootTest;
    6. import org.springframework.data.redis.core.RedisTemplate;
    7. @SpringBootTest
    8. class RedisDemoApplicationTests {
    9.     @Autowired
    10.     private RedisTemplate redisTemplate;
    11.     @Test
    12.     void testSaveUser(){
    13.         //写入数据
    14.         redisTemplate.opsForValue().set("user:100",new User("立夏",21));
    15.         //获取数据
    16.         User user = (User) redisTemplate.opsForValue().get("user:100");
    17.         System.out.println("user: "+ user);
    18.  
    19.     }
    20. }

    执行结果：自动化的：存User转JSON，取JSON转User。自动序列化。

     

    存的时候自动帮我们存入了"@class": "com.redis.pojo.User",所以读取的时候可以自动反序列化从JSON变成User。

    3.3 Radis的Java客户端-StringRedisTemplate

    为了节省内存空间，我们并不会使用JSON序列化器来处理Value，

    而是统一使用String序列化器，要求只能存储String类型的Key和Value。

    当需要存储Java对象时，手动完成对象的序列化和反序列化。

    又因为Spring默认提供了一个StringRedisTemplate类，它的Key和Value的序列化方式默认就是String方式。省去了我们自定义RedisTemplate的过程：

    以为已经有Spring默认的Key和Value的序列化方式：String方式，所以不再需要RedisConfig！！

    1. package com.redis;
    2. import com.fasterxml.jackson.core.JsonProcessingException;
    3. import com.fasterxml.jackson.databind.ObjectMapper;
    4. import com.redis.pojo.User;
    5. import org.junit.jupiter.api.Test;
    6. import org.springframework.beans.factory.annotation.Autowired;
    7. import org.springframework.boot.test.context.SpringBootTest;
    8. import org.springframework.data.redis.core.StringRedisTemplate;
    9.  
    10. @SpringBootTest
    11. class RedisStringTests {
    12.     @Autowired
    13.     private StringRedisTemplate stringRedisTemplate;
    14.     //JSON工具：ObjectMapper是SpringMVC里面默认的JSON处理工具
    15.     private static final ObjectMapper mapper = new ObjectMapper();
    16.     @Test
    17.     void testString() {
    18.         //插入一条string类型的数据
    19.         stringRedisTemplate.opsForValue().set("name","李四");
    20.         //读取一条string类型的数据
    21.         Object name = stringRedisTemplate.opsForValue().get("name");
    22.         System.out.println("name = "+ name);
    23.         //插入一条string类型的数据
    24.         stringRedisTemplate.opsForValue().set("nameS","李小四");
    25.         //读取一条string类型的数据
    26.         Object nameS = stringRedisTemplate.opsForValue().get("nameS");
    27.         System.out.println("nameS = "+ nameS);
    28.     }
    29.     @Test
    30.     void testStringTemplate() throws JsonProcessingException {
    31.         //准备对象
    32.         User user = new User("夏至",18);
    33.         //手动序列化,转JSON，变成字符串
    34.         String json = mapper.writeValueAsString(user);
    35.         //插入一条数据到redis
    36.         stringRedisTemplate.opsForValue().set("user:200",json);
    37.         //读取数据，是一个JSON字符串
    38.         String jsonUser = stringRedisTemplate.opsForValue().get("user:200");
    39.         //反序列化，把字符串转成User对象。
    40.         User user1 = mapper.readValue(jsonUser,User.class);
    41.         System.out.println("user1 = "+ user1);
    42.     }
    43. }

    @SpringBootTest
class RedisStringTests {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    //JSON工具：ObjectMapper是SpringMVC里面默认的JSON处理工具
    private static final ObjectMapper mapper = new ObjectMapper();
    @Test
    void testStringTemplate() throws JsonProcessingException {
        //准备对象
        User user = new User("夏至",18);
        //手动序列化,转JSON，变成字符串
        String json = mapper.writeValueAsString(user);
        //插入一条数据到redis
        stringRedisTemplate.opsForValue().set("user:200",json);
        //读取数据，是一个JSON字符串
        String jsonUser = stringRedisTemplate.opsForValue().get("user:200");
        //反序列化，把字符串转成User对象。
        User user1 = mapper.readValue(jsonUser,User.class);
        System.out.println("user1 = "+ user1);
    }
}

    执行结果：已经没有了"@class": "com.redis.pojo.User"。

    总结：

    3.4 Radis的Java客户端-RedisTemplate操作Hash类型

    在stringRedisTemplate里面，不是以命令行HSet的形式存储Hash值的，而是像java中HashMapper中一样如上使用put。还有很多：

    1. @SpringBootTest
    2. class RedisStringTests {
    3.     @Autowired
    4.     private StringRedisTemplate stringRedisTemplate;
    5.     //JSON工具：ObjectMapper是SpringMVC里面默认的JSON处理工具
    6.     private static final ObjectMapper mapper = new ObjectMapper();
    7.     @Test
    8.     void testHash(){
    9.         //存
    10.         stringRedisTemplate.opsForHash().put("user:400","name","冬至");
    11.         stringRedisTemplate.opsForHash().put("user:400","age","21");
    12.         //取
    13.         Map entries = stringRedisTemplate.opsForHash().entries("user:400");
    14.         System.out.println("entries: "+ entries);
    15.     }
    16.  
    17. }

    执行结果：

    其他的形式可以自己摸索或者参考官方文档，还是很容易掌握的！！！可以自己试一下。 

  • 相关阅读:
    makefile的编写：由浅入深
    python多线程编程: 如何暴力但不失优雅地关闭线程
    2024年消防设施操作员考试题库及答案
    数据表插入数据insert into
    【Java进阶篇】第一章 面向对象
    12 个适合做外包项目的开源后台管理系统
    Excel - 插入空白行
    1.3 测控电路的信号类型、测控电路的类型与组成、测控电路的发展趋势
    【OpenCV + Qt】 制作视频播放器
    童装生意，没有春天？
  • 原文地址：https://blog.csdn.net/qq_41915723/article/details/127428245