Redis基础知识（一）

一 Redis的数据类型

1.1 基本数据类型：

String(字符串)? ? ? ? Hash(哈希表)?????????List(列表)? ? ? ? ? ? ? Set(集合) ????????ZSet(有序集合)????????

1.2 特殊类型

GEO(地理空间)? ? ? ? HyperLogLog(基数统计)? ? ? ? bitMap(位图)? ? ? ? bitField(位域) Stream(流)

?

?二、类型详解

2.1 String(字符串)

? ? ? ? 2.1.1 概念

? ? ? ? ? ? ? ? string是字符串类型，可以分成三种1.string(普通字符串);2.int(整数类型)可以自增自减

；3.float(浮点型)可以做自增自减.String类型的最大空间不超过512MB,String结构将对象序列化为JSON后存储

? ? ? ? 2.1.2常用指令

• SET：添加或者修改已经存在的一个String类型的键值对
• GET：根据key获取String类型的value
• MSET：批量添加多个String类型的键值对
• MGET：根据多个key获取多个String类型的value
• INCR：让一个整型的key自增1
• INCRBY：让一个整型的key自增并指定步长，例如：incrby num 2 让num值自增2
• INCRBYFLOAT：让一个浮点类型的数字自增并指定步长
• SETNX：添加一个String类型的键值对，前提是这个key不存在，否则不执行（等价于set + nx）
• SETEX：添加一个String类型的键值对，并且指定有效期（等价于set+ex）

?

2.2 Hash(哈希表)

? ? ? ? 2.2.1 概念

? ? ? ? ? ? ? ? 也叫散列表，他的value是无序字典，类似于Java中的Map

? ? ? ? 2.2.2 常用命令

• HSET key field value：添加或者修改hash类型key的field的值
• HGET key field：获取一个hash类型key的field的值
• HMSET key field1 value1 field2 value2 ...：批量添加多个hash类型key的field的值
• HMGET key field1 field2 ...：批量获取多个hash类型key的field的值
• HGETALL key：获取一个hash类型的key中的所有的field和value
• HKEYS key：获取一个hash类型的key中的所有的field
• HVALS：获取一个hash类型的key中的所有的value
• HINCRBY:让一个hash类型key的字段值自增并指定步长，例如，hincrby heima:user:4 age -2 （age自减2）
• HSETNX：添加一个hash类型的key的field值，前提是这个field不存在，否则不执行

2.3 List（列表）

? ? ? ? 2.3.1 概念：

类似于Java的LinkedList(双向链表),支持从头扫到尾，也支持从尾扫头，

? ? ? ?2.3.2? 常用命令

• LPUSH key element ... ：向列表左侧插入一个或多个元素
• LPOP num：从左侧开始取，取出并移除num个元素，数量不够就返回nil
• RPUSH key element ... ：向列表右侧插入一个或多个元素
• RPOP num：从右侧开始取，取出并移除num个元素，数量不够就返回nil
• LRANGE key star end：返回一段角标范围内的所有元素
• BLPOP和BRPOP：与LPOP和RPOP类似，只不过在没有元素时等待指定时间，而不是直接返回nil
• 

?即v2编号为1，v1编号为2

2.4 Set类型

? ? ? ? 2.4.1 概念

? ? ? ? 类似于java的Set,具有HashSet的特性，同时适合交并集，微博用他来表示你们的共同好友

? ? ? ? 2.4.2 常用指令

• SADD key member ... ：向set中添加一个或多个元素
• SREM key member ... : 移除set中的指定元素
• SCARD key： 返回set中元素的个数
• SISMEMBER key member：判断一个元素是否存在于set中
• SMEMBERS：获取set中的所有元素
• SINTER key1 key2 ... ：求key1与key2的交集
• SDIFF key1 key2 ... ：求key1与key2的差集
• SUNION key1 key2 ...：求key1和key2的并集

练习：

sadd zs ls ww zl

sadd ls ww zg;

scard zs

sinter zs ls

sdiff zs ls

sunion zs ls

sismember zs ls

sismember ls zs

srem zs ls

?2.5 ZSet

????????2.5.1 概念

????????一个可排序的set集合，与Java中的TreeSet有些类似，但底层数据结构却差别很大。SortedSet中的每一个元素都带有一个score属性，可以基于score属性对元素排序，底层的实现是一个跳表（SkipList）加 hash表。SortedSet具有的特点：可排序元素、不重复、查询速度快。因为SortedSet的可排序特性，经常被用来实现排行榜这样的功能

????????2.5.3 常用指令

• ? ? ZADD key score member：添加一个或多个元素到sorted set ，如果已经存在则更新其score值
• ? ? ZREM key member：删除sorted set中的一个指定元素
• ? ? ZSCORE key member : 获取sorted set中的指定元素的score值
• ? ? ZRANK key member：获取sorted set 中的指定元素的排名
• ? ? ZCARD key：获取sorted set中的元素个数
• ? ? ZCOUNT key min max：统计score值在给定范围内的所有元素的个数
• ? ? ZINCRBY key increment member：让sorted set中的指定元素自增，步长为指定的increment值
• ? ? ZRANGE key min max：按照score排序后，获取指定排名范围内的元素
• ? ? ZRANGEBYSCORE key min max：按照score排序后，获取指定score范围内的元素
• ? ? ZDIFF、ZINTER、ZUNION：求差集、交集、并集

三、实战

导入maven依赖

        <!--jedis依赖-->
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>3.7.0</version>
        </dependency>
        <!--junit依赖-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter</artifactId>
            <version>5.7.0</version>
            <scope>test</scope>
        </dependency>
        <!--SpringBoot整合SpringDataRedis对应的Starter-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--Redis连接池依赖-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

?3.1 Jedis连接池

package com.hhxy.jedis.util;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

/**
 * @author ghp
 * @date 2022/12/25
 * @title
 * @description
 */
public class JedisConnectionFactory {

    private static final JedisPool jedisPool;

    static {
        // 配置连接
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        // 配置线程池能够处理的线程数量（默认值是8，能够处理的包括工作线程和阻塞线程）
        poolConfig.setMaxTotal(8);
        // 配置线程池能够工作的线程数量（默认值是8）
        poolConfig.setMaxIdle(8);
        // 配置线程池最小的空闲连接（默认值是0）
        poolConfig.setMinIdle(0);
        // 等待空闲线程的时间
        poolConfig.setMaxWaitMillis(1000);

        // 创建连接池对象
        jedisPool = new JedisPool(poolConfig,"192.168.88.130", 6379, 1000,  "32345678");
    }

    public static Jedis getJedis(){
        return jedisPool.getResource();
    }

}

?3.2 yml里面配置redis基本连接信息

  redis:
    port: 6379
    host: 192.168.59.133
    password: picMemo
    timeout: 1800000
    lettuce:
      pool:
        max-active: 20
        max-wait: -1

3.3 测试

- **Step4**：测试


```java
package com.hhxy;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;

@SpringBootTest
class SpringbootSpringdateRedisApplicationTests {

  @Autowired
  private RedisTemplate redisTemplate;

  @Test
  void contextLoads() {

  }

  @Test
  public void testString(){
      // 存入String类型的数据
      redisTemplate.opsForValue().set("name","ghp");
      // 获取存入的数据
      Object name = redisTemplate.opsForValue().get("name");
      System.out.println("name = " + name);
  }

}

3.4 自定义RedisTemple，

解决中文存入问题，因为RedisTemplate底层序列化，默认使用的JDK序列化,本质上是ObjectOutputStream

maven

 <!--lombok依赖-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--SpringBoot整合SpringDataRedis对应的Starter-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <!--Redis连接池依赖-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

        <!--Jackson依赖-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
        </dependency>

        <!--SpringBoot整合Junit对应的Starter-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

package com.hhxy.redis.config;

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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;

/**
 * @author ghp
 * @date 2022/12/25
 * @title
 * @description
 */
@Configuration
public class RedisConfig {

    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory){
        // 创建RedisTemplate对象
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 设置连接工厂
        template.setConnectionFactory(connectionFactory);
        // 创建JSON序列化工具
        GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        // 设置key的序列化
        template.setKeySerializer(RedisSerializer.string());
        template.setHashKeySerializer(RedisSerializer.string());
        // 设置value的序列化
        template.setValueSerializer(jsonRedisSerializer);
        template.setHashValueSerializer(jsonRedisSerializer);
        // 返回序列化后的结果
        return template;
    }
}

?为了避免内部开销，j我们选择用String 序列化器，则是StringRedisTemplate(默认提供)

package com.hhxy.redis;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.hhxy.redis.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;

/**
 * @author ghp
 * @date 2022/12/25
 * @title
 * @description 通过采用String序列化器+手动序列化反序列化Object类型的value
 */
@SpringBootTest
public class RedisStringTest {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    public void testString(){
        // 存入String类型的数据（直接使用Spring提供的StringRedisTemplate就行了）
        stringRedisTemplate.opsForValue().set("name","张三");
        // 获取存入的数据
        Object name = stringRedisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }

    // ObjectMapper是SpringMVC默认的JSON处理工具
    private static final ObjectMapper mapper = new ObjectMapper();

    @Test
    public void testObject() throws JsonProcessingException {
        // 创建User对象（需要手动序列化和反序列化，其实可以通过AOP封装一个方法）
        User user = new User("张三", 21);
        // 手动序列化
        String json = mapper.writeValueAsString(user);
        // 将数据存入Redis中
        stringRedisTemplate.opsForValue().set("user",json);
        // 获取存入的数据
        String name = stringRedisTemplate.opsForValue().get("user");
        // 手动反序列化
        User user1 = mapper.readValue(json, User.class);
        System.out.println("user1 = " + user1);
    }

}