Redis基础篇

目录

初识Redis

1.认识NoSQL

2.认识Redis

3.安装Redis

Redis常见命令

1.Redis的数据结构

2.通用命令

3.String类型

1.简介

2.常见命令

3.key的结构

4.Hash类型

5.List类型

6.Set类型

7.SortedSet类型

1.简介

2.常用命令

3.练习

Redis的Java客户端

1.Jedis

1.快速入门：

2.Jedis连接池

2.SpringDataRedis

3.SpringBoot整合redis

4.RedisTemplate的两种序列化实践方案

方案一：

方案二：

5.redid中操作hash类型数据

---

初识Redis

1.认识NoSQL

表格对照

【补充】数据库ACID与BASE理论

2.认识Redis

Redis诞生于2009年全称是Remote Dictionary Server，远程词典服务器，是一个基于内存的键值型NoSQL数据库。

特征：

键值（key-value）型，value支持多种不同数据结构（String、List、Set、SortedSet、Hash等），功能丰富

单线程，每个命令具备原子性，安全

低延迟，速度快（基于内存、IO多路复用、良好的编码）。

支持数据持久化（AOF和RDB持久化策略）

支持主从集群、分片集群

支持多语言客户端----Java、C++、C#、Python、PHP等语言都支持。

3.安装Redis

redis官方是没有提供Windows系统的redis版本的，官方仅仅提供了Linux系统版本的redis，Windows版本的redis是微软开发的。

1.安装redis

略

2.Redis客户端

（1）命令行客户端

命令行客户端会在Redis的客户端安装成功时同时安装成功

（2）图形化桌面客户端

略。

3）编程客户端----C++、C、C#、Java客户端

后面在项目中整合。

Redis常见命令

1.Redis的数据结构

简介：

2.通用命令

通用指令是部分数据类型的，都可以使用的指令，常见的有：

KEYS：查看符合模板的所有key，不建议在生产环境设备上使用，因为redis是单线程的，当有大量数据进行查询时会阻塞，但是可以在redis主从节点的从节点上面去做这种扫描全表的操作，以提升效率。

DEL：删除一个指定的key

EXISTS：判断key是否存在

EXPIRE：给一个key设置有效期，有效期到期时该key会被自动删除

TTL：查看一个KEY的剩余有效期

3.String类型

1.简介

String类型，也就是字符串类型，是Redis中最简单的存储类型。

其value是字符串，不过根据字符串的格式不同，又可以分为3类：

string：普通字符串

int：整数类型，可以做自增、自减操作

float：浮点类型，可以做自增、自减操作

不管是哪种格式，底层都是字节数组形式存储，只不过是编码方式不同。字符串类型的最大空间不能超过512m.

2.常见命令

String的常见命令有：

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不存在，如果存在就会执行失败

SETEX：添加一个String类型的键值对，并且指定有效期

3.key的结构

问：Redis没有类似MySQL中的Table的概念，我们该如何区分不同类型的key呢？例如，需要存储用户、商品信息到redis，有一个用户id是1，有一个商品id恰好也是1。

答：Redis的key允许有多个单词形成层级结构，多个单词之间用':'隔开，格式如下：

​                                                        项目名:业务名:类型:id

这个格式并非固定，也可以根据自己的需求来删除或添加词条。

4.Hash类型

1.简介

Hash类型，也叫散列，其value是一个无序字典，类似于Java中的HashMap结构。

String结构是将对象序列化为JSON字符串后存储，当需要修改对象某个字段时很不方便：

Hash结构可以将对象中的每个字段独立存储，可以针对单个字段做CRUD：

2.Hash的常见命令有：

HSET key field value：添加或者修改hash类型key的field的值

HGET key field：获取一个hash类型key的field的值

HMSET：批量添加多个hash类型key的field的值

HMGET：批量获取多个hash类型key的field的值

HGETALL：获取一个hash类型的key中的所有的field和value

 

HKEYS：获取一个hash类型的key中的所有的field

HVALS：获取一个hash类型的key中的所有的value

HINCRBY:让一个hash类型key的字段值自增并指定步长，可以写负数，做出自减的效果

HSETNX：添加一个hash类型的key的field值，前提是这个field不存在，否则不执行，案例如图：

5.List类型

1.简介

Redis中的List类型与Java中的LinkedList类似，可以看做是一个双向链表结构。既可以支持正向检索和也可以支持反向检索。

特征也与LinkedList类似：

有序

元素可以重复

插入和删除快

查询速度一般

常用来存储一个有序数据，例如：朋友圈点赞列表，评论，秒杀列表等。

2.List类型的常见命令

LPUSH key element ... ：向列表左侧插入一个或多个元素

LPOP key：移除并返回列表左侧的第一个元素，没有则返回nil

RPUSH key element ... ：向列表右侧插入一个或多个元素

RPOP key：移除并返回列表右侧的第一个元素

LRANGE key star end：返回一段角标范围内的所有元素

BLPOP和BRPOP：与LPOP和RPOP类似都是移除并返回列表左侧的第一个元素，只不过在没有元素时会去等待一定的时间，而不是直接返回nil，即这是个等待式（阻塞式）的移除元素方式

例如：移除user:service:4这个队列左侧的第一个元素，如果user:service:4这个队列没有元素则会等待20s。

3.

（1）如何利用List结构模拟一个栈?

入口和出口在同一边

（2）如何利用List结构模拟一个队列?

入口和出口在不同边

（3）如何利用List结构模拟一个阻塞队列?

入口和出口在不同边出队时采用BLPOP或BRPOP

6.Set类型

1.简介

Redis的Set结构与Java中的HashSet类似，可以看做是一个value为null的HashMap。因为也是一个hash表，因此具备与HashSet类似的特征：

无序

元素不可重复

查找快

支持交集、并集、差集等功能

2.常见命令

Set的常见命令有：

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的并集

7.SortedSet类型

1.简介

Redis的SortedSet是一个可排序的set集合，与Java中的TreeSet有些类似，但底层数据结构却差别很大。SortedSet中的每一个元素都带有一个score属性，可以基于score属性对元素排序，底层的实现是一个跳表（SkipList）加 hash表。SortedSet具备下列特性：

可排序

元素不重复

查询速度快（查询快的原因在于底侧使用了hash表，查询时可以做到精准定位）

因为SortedSet的可排序特性，经常被用来实现排行榜这样的功能。

2.常用命令

SortedSet的常见命令有：

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：求差集、交集、并集注意：所有的排名默认都是升序，如果要降序则在命令的Z后面添加REV即可

3.练习

代码结果：

Redis的Java客户端

在Redis官网中提供了各种语言的客户端，地址：https://redis.io/resources/clients/

1.Jedis

Jedis的官网地址： GitHub - redis/jedis: Redis Java client designed for performance and ease of use.

1.快速入门：

Jedis使用的基本步骤：

（1）引入依赖

<dependencies>
    <!--1.导入依赖-->
    <!--jedis依赖-->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.7.0</version>
    </dependency>
    <!--测试依赖-->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>RELEASE</version>
        <scope>test</scope>
    </dependency>

</dependencies>

（2）创建Jedis对象，建立连接

（3）使用Jedis，方法名与Redis命令一致

（4）释放资源

package cn.zcj.Jedis;

import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;

public class JedisTest {
    private Jedis jedis;

    //2.建立连接
    @BeforeEach
    void setup() {
        //建立连接
        //建立连接的前提：必须保证redis的配置文件里面允许用这个IP去访问redis
        //jedis = new Jedis("127.0.0.1",6379);
        jedis = new Jedis("192.168.1.43", 6379);
        //设置密码
        jedis.auth("123456");
        //选择库
        jedis.select(0);
    }

    //3.测试在redis中存入String类型的数据
    @Test
    void testString() {
        // 插入数据，方法名称就是redis命令名称，非常简单
        String result = jedis.set("name", "小王");
        System.out.println("result = " + result);
        // 获取数据
        String name = jedis.get("name");
        System.out.println("name = " + name);
    }

    //4.释放资源
    @AfterEach
    void tearDown() {
        //释放资源
        if (jedis != null) {
            jedis.close();
        }
    }

}

 【注意】在创建连接时，必须保证redis的配置文件里面允许用这个IP去访问redis，否则会报连接超时移除

2.Jedis连接池

1.导入依赖

<dependencies>
    <!--1.导入依赖-->
    <!--jedis依赖-->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
        <version>3.7.0</version>
    </dependency>
    <!--测试依赖-->
    <dependency>
        <groupId>org.junit.jupiter</groupId>
        <artifactId>junit-jupiter</artifactId>
        <version>RELEASE</version>
        <scope>test</scope>
    </dependency>

</dependencies>

 2.准备连接池工厂

package cn.zcj;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

public class JedisConnectionFactory {
    private static final JedisPool jedisPool;

    static {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
        // 最大连接
        jedisPoolConfig.setMaxTotal(8);
        // 最大空闲连接--连接池里面最大允许多少个连接空闲
        jedisPoolConfig.setMaxIdle(8);
        // 最小空闲连接--连接池里面一直存在多少个连接
        jedisPoolConfig.setMinIdle(1);
        // 设置最长等待时间（ms）--当连接池里面没有连接可用时，是否等待连接，如果等待，那么就要设置等待时间
        jedisPoolConfig.setMaxWaitMillis(200);
        jedisPool = new JedisPool(jedisPoolConfig, "192.168.1.43", 6379, 1000, "123456");
    }

    // 获取Jedis对象
    public static Jedis getJedis() {
        return jedisPool.getResource();
    }
}

 3.测试

package cn.zcj.Jedis;

import cn.zcj.JedisConnectionFactory;
import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;

public class JedisTest {
    private Jedis jedis;
    //3.测试在redis中存入String类型的数据
    @Test
    void testString() {
        jedis = JedisConnectionFactory.getJedis();
        // 插入数据，方法名称就是redis命令名称，非常简单
        String result = jedis.set("name", "小六");
        System.out.println("result = " + result);
        // 获取数据
        String name = jedis.get("name");
        System.out.println("name = " + name);
    }
}

4.测试输出：

2.SpringDataRedis

SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis，官网地址：Spring Data Redis

1.SpringDataRedis的功能：

提供了对不同Redis客户端的整合（Lettuce和Jedis）

提供了RedisTemplate统一API来操作Redis

支持Redis的发布订阅模型

支持Redis哨兵和Redis集群

支持基于Lettuce的响应式编程

支持基于JDK、JSON、字符串、Spring对象的数据序列化及反序列化

支持基于Redis的JDKCollection实现

2.数据类型

3.SpringBoot整合redis

3.1.导入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>cn.zcj</groupId>
    <artifactId>JedisStudyAndTest</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <!--SpringBoot父工程依赖-->
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.4.RELEASE</version>
    </parent>

    <dependencies>
        <!--1.导入依赖-->
        <!--redis依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!--连接池依赖-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <!--测试依赖-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>

    </dependencies>


</project>

 3.2.准备配置文件

3.3.准备启动类

package cn.zcj;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringDataApp {
    public static void main(String[] args) {
        SpringApplication.run(SpringDataApp.class);
    }
}

 3.4.测试

package cn.zcj.redis;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

@SpringBootTest
@RunWith(SpringRunner.class)
public class RedisTest {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testString() {
        //key一般用string类型,value一般用Json序列化类型
        // 插入一条string类型数据
        redisTemplate.opsForValue().set("name999", "张三丰");
        // 读取一条string类型数据
        Object name = redisTemplate.opsForValue().get("name999");
        System.out.println("name999 = " + name);
    }
}

3.5.测试输出：

3.6.SpringDataRedis的序列化方式

3.6.1.问题展示：

问：为什么java代码中明明输入的是"name999"，但是在redis的客户机上展示的却是"\xac\xed\x00\x05t\x00\aname999"？

答：RedisTemplate可以接收任意Object作为值写入Redis，只不过写入前会把Object序列化为字节形式，默认是采用JDK序列化，得到的结果是这样的。此时自动注入的redis使用了SpringDataRedis默认的序列化方式，默认的序列化方式是<Object,Object>这种类型的键值对，其中键和值均默认为对象，redis在序列化时将<"name999","张三丰">当成了两个对象在进行序列化，而不是将<"name999","张三丰">当成两个字符串在进行序列化，因此会出现这种情况。

3.6.2.序列化问题改进

3.6.2.1.添加依赖

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

 3.6.2.2.自定义RedisTemplate的序列化方式

package cn.zcj.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;

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        // 创建Template
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 设置连接工厂
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        // 设置序列化工具
        GenericJackson2JsonRedisSerializer jsonRedisSerializer =
                new GenericJackson2JsonRedisSerializer();
        // key和 hashKey采用 string序列化
        redisTemplate.setKeySerializer(RedisSerializer.string());
        redisTemplate.setHashKeySerializer(RedisSerializer.string());
        // value和 hashValue采用 JSON序列化
        redisTemplate.setValueSerializer(jsonRedisSerializer);
        redisTemplate.setHashValueSerializer(jsonRedisSerializer);
        return redisTemplate;
    }
}

3.6.2.3.测试

package cn.zcj.redis;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

@SpringBootTest
@RunWith(SpringRunner.class)
public class RedisTest {
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    @Test
    public void testString() {
        //key一般用string类型,value一般用Json序列化类型
        // 插入一条string类型数据
        redisTemplate.opsForValue().set("name999", new Student(9,"张三丰"));
        // 读取一条string类型数据
        Student name = (Student) redisTemplate.opsForValue().get("name999");
        System.out.println("Student:" + name);
    }
}
class Student {
    private Integer id;
    private String name;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Student() {
    }

    public Student(Integer id, String name) {
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
}

测试输出： 

再次对比：

4.RedisTemplate的两种序列化实践方案

方案一：

（1）自定义RedisTemplate

（2）修改RedisTemplate的序列化器为GenericJackson2JsonRedisSerializer

案例展示：上文3.6.2的案例就是。

方案二：

（1）使用StringRedisTemplate

（2）写入Redis时，手动把对象序列化为JSON

（3）读取Redis时，手动把读取到的JSON反序列化为对象

方案二的问题展示：

尽管JSON的序列化方式可以满足我们的需求，但依然存在一些问题，如图：

为了在反序列化时知道对象的类型，JSON序列化器会将类的class类型写入json结果中，存入Redis，会带来额外的内存开销。

为了节省内存空间，我们并不会使用JSON序列化器来处理value，而是统一使用String序列化器，要求只能存储String类型的key和value。当需要存储Java对象时，手动完成对象的序列化和反序列化。

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

package cn.zcj.redis;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

import java.io.IOException;

@SpringBootTest
@RunWith(SpringRunner.class)
public class RedisTest02 {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    // JSON工具
    private static final ObjectMapper mapper = new ObjectMapper();
    @Test
    public void testStringTemplate() throws IOException {
        // 准备对象
        User user = new User();
        user.setId(12);
        user.setName("张无忌");
        // 手动序列化
        String json = mapper.writeValueAsString(user);
        // 写入一条数据到redis
        stringRedisTemplate.opsForValue().set("user:200", json);
        // 读取数据
        String val = stringRedisTemplate.opsForValue().get("user:200");
        // 反序列化
        User user1 = mapper.readValue(val, User.class);
        System.out.println("user1 = " + user1);
    }
    static class User {
        private Integer id;
        private String name;

        public Integer getId() {
            return id;
        }

        public void setId(Integer id) {
            this.id = id;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public User() {
        }

        @Override
        public String toString() {
            return "User{" +
                    "id=" + id +
                    ", name='" + name + '\'' +
                    '}';
        }
    }
}

【注意】此时内部类必须要加关键字static，否则就会出现嵌套异常；如果不是内部类，是单独的pojo对象，就可以不须要关键字static.

测试输出：

5.redid中操作hash类型数据

package cn.zcj.redis;

import com.fasterxml.jackson.databind.ObjectMapper;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.Map;

@SpringBootTest
@RunWith(SpringRunner.class)
public class RedisHashTest {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Test
    public void testHash(){
        stringRedisTemplate.opsForHash().put("user:10010","id","123");
        stringRedisTemplate.opsForHash().put("user:10010","name","独孤求败");
        stringRedisTemplate.opsForHash().put("user:10010","sex","男");

        Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("user:10010");
        System.out.println(entries);
    }
}

 测试输出：