Redis使用教程

最新推荐文章于 2024-06-08 23:48:05 发布

weixin_71366486

最新推荐文章于 2024-06-08 23:48:05 发布

阅读量2.4k

点赞数 16

文章标签： redis 数据库缓存

本文链接：https://blog.csdn.net/weixin_71366486/article/details/134378848

版权

1.Redis简介

1 .1 NOSQL简介

NOSQL(非结构型,非关联型)的数据库，对数据库格式没有严格约束，往往形式松散，自由。可以是key-value,可以是文档，或者图格式

NOSQL数据库往往不支持事务，或者不能严格保证ACID的特性，只能实现基本的一致性。

1.2 初识Redis

是一个NOSQL类型的的数据库：

键值（key-value）型，value支持多种不同数据结构，功能丰富
单线程，每个命令具备原子性
低延迟，速度快（基于内存、IO多路复用、良好的编码）。
支持数据持久化(定期将内存搬运到磁盘)
支持主从集群、分片集群（数据拆分）
支持多语言客户

官方文档:Commands | Redis

2. Redis常用命令

2.1 启动Redis服务

默认启动

redis-server：默认启动,需要一直挂着页面

后台启动

必须修改配置文件(/usr/local/src/redis-6.2.6/redis.conf)

requirpass xxx : 设置密码

daemmonize yes

(1) cp redis.conf redis.conf.bak: 备份一份配置文件
(2) vim redis.conf :修改配置文件, eg:修改密码为heima

(3)cd /usr/local/src/redis-6.2.6：进入到redis文件目录
redis-server redis.conf: 使配置文件生效
(4)ps -ef | grep redis： 查看是否启动
(5)kill redis -9:强制终止redis进程，不安全

开机自启

(1) 新建系统服务文件

vim /etc/systemd/system/redis.service

[Unit]
Description=redis-server
After=network.target

[Service]
Type=forking
ExecStart=/usr/local/bin/redis-server /usr/local/src/redis-6.2.6/redis.conf
PrivateTmp=true

[Install]
WantedBy=multi-user.target

(2) 重新加载系统服务

systemctl daemon-reload
(3)启动

systemctl start redis
(4)查看状态

systemctl status redis
(5) 设置开机自启

systemctl enable redis

2.2 Redis客户端

安装完成Redis，我们就可以操作Redis，实现数据的CRUD了。这需要用到Redis客户端，包括：

命令行客户端
图形化桌面客户端
编程客户端

2.2.1.Redis命令行客户端

Redis安装完成后就自带了命令行客户端：redis-cli，使用方式如下：

redis-cli [选项] [commonds]
例如: redis-cli -h 192.168.200.130 -p 6379 -a heima

常用选项

选项:

-h 127.0.0.1：指定要连接的redis节点的IP地址，默认是127.0.0.1
-p 6379：指定要连接的redis节点的端口，默认是6379
-a 123321：指定redis的访问密码

命令：

ping: 与redis服务端做心跳测试，服务端正常会返回pong

细节说明：

1.不指定commond时，会进入redis-cli的交互控制台

2.直接输入密码进入客户端具有危险性,我们可以在进入交互控制台后再输入密码

AUTH 密码 ：登入到redis

2.3 常用命令

TTL：查看key还有多长时间过期 , -2：过期已经删除 ; -1：永久有效

例如：

1.先set一个key:value

2.使用keys查看当前有哪些key

3.删除一个指定key

4.判断一个key是否存在

5.给一个key设置存活期,到期自动删除

6.查看还有多长时间到期

3.常用数据类型

3.1 String

常见指令

SET：添加或修改一个String类型的键值对

GET：根据key值获取String类型的value

MSET：批量添加多个String类型的键值对

MGET：根据多个key值批量获取多个String类型的value

INCR：让一个整形的key自增1

INCRBY：让一个整形的key按照指定大小自增,例如 INCRYBY 2：自增2 , 负数则是减

INCRBYFLOAT：让一个浮点数的key按照指定大小自增, 例如INCRYBYFLOAT 0.5:自增0.5

SETNX：添加一个String类型的键值对,前提是这个key不存在，否则不添加

SETEX：添加一个String类型的键值对,并且指定存活期

setex key expireTime value

3.2 key的结构

如果Value是一个Java对象，例如一个User对象，则可以将对象序列化为JSON字符串后存储：

KEY VALUE
heima:user:1 {“id”:1, “name”: “Jack”, “age”: 21}
heima:product:1 {“id”:1, “name”: “小米11”, “price”: 4999}

一旦我们向redis采用这样的方式存储，那么在可视化界面中，redis会以层级结构来进行存储，形成类似于这样的结构，更加方便Redis获取数据

3.3 Hash

本身Redis就是一个key-value的结构，而hash的value还是一个key-value的结构

常用指令

HSET key field value：添加或修改一个hash类型key的field字段的值

HGET key field：根据key值获取hash类型的field的值

HDEL key field: 根据key值删除hash类型中的field的值

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

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

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

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

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

HSETNX：添加一个hash类型的key和field,前提是这个field不存在，否则不添加

HINCRBY：让一个整形的key按照指定大小自增,例如 HINCRYBY 2：自增2 , 负数则是减

3.4 List

常用指令

LPUSH key element：向左边插入一个元素

LPOP key：移除并返回左边的第一个元素,如果没有返回nil

RPUSH key element：向右边插入一个元素

RPOP key：移除并返回右边的第一个元素,如果没有返回nil

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

BLPOP和BRPOP：和LPOP以及RPOP类似,只不过在没有元素时等待一定时间,而不会直接返回nil

3.5 Set

常用指令

SADD key element：添加一个元素

SREM key element：删除一个元素

SCARD key：查询key中有多少元素

SINTER key1 key2：查询key1和key2的交集

SDIFF key1 key2：查询key1和key2的差集

SUNION key1 key2：查询key1和key2的并集

SISMEMBER key element：查询key中是否有element元素

SMEMB key：查询key中的元素

案例说明

1.SADD zs lisi wangwu zhaoliu
2.SADD lisi wangwu mazi ergou
3.SCARD zs
4.SINTER zs lisi
5.SDIFF zs lisi
6.SUNION zs lisi
7.SISMEMBER zs lisi
8.SISMEMBER lisi zs
9.SREM zs lisi

3.6 SortedSet

每个元素都带上分数，所以才能实现排序

常用指令

ZADD key score member：添加一个或多个值到sorted set中,如果存在则更新score值

ZREM key member：删除sorted set中指定元素

ZSCORE key member：查询key中元素的score

ZRANK key member：查询元素在key中的排名,默认是升序

ZCOUNT key min max：统计key中min到max中元素的数量,默认是升序

ZINCRBY key count member：给key中member自增count数

ZRANGE key min max：升序返回key中min到max的元素

ZREVRANGE key min max：降序返回key中min到max的元素

ZRANGEBYSCORE key min max：返回key中min到max分数中的member值

案例说明

3.7 GEO数据结构

GEO就是Geolocation的简写形式,代表地理坐标,Redis在3.2版本中加入了对GEO的支持,允许存储地理坐标信息,帮助我们根据经纬度来检索数据。

常见命令:

GEOADD：添加一个地理空间信息,包含：经度（longitude）、纬度（latitude）、值（member）

GEODIST：计算指定的两个点之间的距离并返回

GEOHASH：将指定member的坐标转成hash字符串形式并返回

GEOPOS：返回指定member的坐标

GEORADIUS：指定圆心、半径，找到该圆内包含的所有member,并按照与圆心之间的距离排序后返回。6.2以后已废弃

GEOSEARCH：在指定范围内搜素member,并按照与指定点之间的距离排序后返回。范围可以是圆形或者矩形。6.2新功能

GEOSEARCHSTORE：与GEOSEARCH功能一致,不过可以把结果存储到一个指定的key中,6.2新功能

4.Redis的java客户端

4.1 Jedis

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

在Jedis中,方法名对应的就是我们在Redis中所使用的各种命令,适用于学习使用,但Jedis是线程不安全的,所以我们在多线程环境下,需要基于连接池来使用

4.1.1 快速入门

1.导入依赖

<!-- Jedis 依赖 -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
    <version>3.8.0</version>
</dependency>
<!-- 测试 -->
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>org.junit.jupiter</groupId>
    <artifactId>junit-jupiter-api</artifactId>
    <version>5.8.2</version>
    <scope>test</scope>
</dependency>

2.建立连接

import com.heima.utils.JedisConnectionFactory;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

public class jedisTest {

    private Jedis jedis;

    @BeforeEach
    void setUp(){
        //1.建立连接
        jedis = new Jedis("192.168.200.130",6379);
        //2.设置密码
        jedis.auth("heima");
        //3.选择库
        jedis.select(0);
    }

    @Test
     void testString(){
        String result = jedis.set("name", "小明");
        System.out.println("result= " + result);

        String name = jedis.get("name");
        System.out.println("name= "+name);
    }

    @AfterEach
    void tearDown(){
        if(jedis!=null){
            jedis.close();
        }
    }
}

注意

如果连接不上或者连接超时以及空指针异常等问题，注意是否开启防火墙端口

firewall-cmd --permanent --add-port=6379/tcp

4.1.2 Jedis连接池

我们可以使用Jedis的连接池 JedisPool来创建redis连接

1.创建一个工具类

package com.heima.utils;

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

public class JedisConnectionFactory {
    private static JedisPool jedisPool;

    static {
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        //设置最大连接
        poolConfig.setMaxTotal(8);
        //设置最大空闲连接
        poolConfig.setMaxIdle(8);
        //设置最小空闲连接
        poolConfig.setMinIdle(0);
        jedisPool = new JedisPool(poolConfig,"192.168.200.130",6379,1000,"heima");
    }

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

改善代码,使用连接池连接redis

import com.heima.utils.JedisConnectionFactory;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

public class jedisTest {

    private Jedis jedis;

    @BeforeEach
    void setUp(){
        //1.建立连接
//        jedis = new Jedis("192.168.200.130",6379);
        jedis = JedisConnectionFactory.getJedis();
        //2.设置密码
        jedis.auth("heima");
        //3.选择库
        jedis.select(0);
    }

    @Test
     void testString(){
        String result = jedis.set("name", "小明");
        System.out.println("result= " + result);

        String name = jedis.get("name");
        System.out.println("name= "+name);
    }

    @AfterEach
    void tearDown(){
        if(jedis!=null){
            jedis.close();
        }
    }
}

4.2 SpringDataRedis

SpringData是Spring中数据操作的模块，包含对各种数据库的集成，其中对Redis的集成模块就叫做SpringDataRedis，官网地址：https://spring.io/projects/spring-data-redis

提供了对不同Redis客户端的整合（Lettuce和Jedis）
提供了RedisTemplate统一API来操作Redis
支持Redis的发布订阅模型
支持Redis哨兵和Redis集群
支持基于Lettuce的响应式编程(Lettuce之前实在es那里有)
支持基于JDK.JSON.字符串.Spring对象的数据序列化及反序列化
支持基于Redis的JDKCollection实现

SpringDataRedis中提供了RedisTemplate工具类，其中封装了各种对Redis的操作。并且将不同数据类型的操作API封装到了不同的类型中：

4.2.1 快速入门

1.导入依赖

<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>

2.配置文件

spring:
  redis:
    host: 192.168.200.130
    password: heima
    connect-timeout: 1000
    database: 0
    port: 6379
    lettuce:
      pool:
        max-active: 8 #最大连接
        max-idle: 8 #最大空闲连接
        min-idle: 0 #最小空闲连接
        max-wait: 100 #连接等待时间

3.将RedisTemplate，注入到IOC中

@Resource
private RedisTemplate redisTemplate;

4.测试

package com.heima;

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

import javax.annotation.Resource;

@SpringBootTest
class SpringbootRedisApplicationTests {

    @Resource
    private RedisTemplate redisTemplate;

    @Test
    void contextLoads() {
        redisTemplate.opsForValue().set("name","黑麻");
        //获取String数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }

}

5.控制台输出

4.2.2 RedisSerializer

这里我们发现我们取出key时,我们的value值是乱码的情况...

这是由于key和value会被当成对象，被redis底层的默认序列化方法：jdk序列化工具jdkSerializationRedisSerialliszer

而它采用的是objectOutputStream(把java对象转成字节),先把这个key删除掉

写一个RedisConfi:拥有我们的序列化后的redisTemplate

package com.heima.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;

@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);
        template.afterPropertiesSet();
        //返回
        return template;
    }
}

测试类:

package com.heima;

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

import javax.annotation.Resource;

@SpringBootTest
class SpringbootRedisApplicationTests {

    @Resource
    private RedisTemplate<String,Object> redisTemplate;

    @Test
    void contextLoads() {
        redisTemplate.opsForValue().set("name4","黑麻");
//        redisTemplate.opsForValue().getAndDelete("name");

        //获取String数据
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println("name = " + name);
    }

}

输出结果：

注意:

如果我们配置之后还是出现序列化问题，可以在启动redis-cli 服务时在最后加入--raw，即

redis-cli -h 192.168.200.130 --raw

接着尝试加入value值为对象类型

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
   private String name;
   private Integer age;
}

package com.heima.redis.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private Integer age;
}

添加方法:

@Test
    public void testSaveUser(){
        User user = new User();
        user.setName("黑麻");
        user.setAge(18);
        redisTemplate.opsForValue().set("user:100",user);
        System.out.println(redisTemplate.opsForValue().get("user:100"));
    }

测试结果：

发现这个json对象会将类的class写入，这个是为这个class进行反序列化的，但是会存在内存开销

4.3 StrinigRedisTemplate

4.3.1 快速入门

将RedisTemplate改为StringReidisTemplate即可

@Resource
private StringRedisTemplate stringRedisTemplate;

//JSON工具类ObjectMapper,或者可以用fastjson:JSON.toJSONString(), JSON.parseObject()
private static final ObjectMapper mapper = new ObjectMapper();

@Test
    public void testSaveUser() throws JsonProcessingException {
        User user = new User();
        user.setName("黑麻");
        user.setAge(18);
        //手动序列化
        String json = mapper.writeValueAsString(user);

        stringRedisTemplate.opsForValue().set("user:100",json);
        //反序列化
        User user1 = mapper.readValue(stringRedisTemplate.opsForValue().get("user:100"), User.class);
        System.out.println("user1 = " + user1);
    }

测试结果：

接下来测试下哈希结构

string:

@Test
void testHash(){
    stringRedisTemplate.opsForHash().put("user:200","name","张三");
    stringRedisTemplate.opsForHash().put("user:200","age","21");

    Object name = stringRedisTemplate.opsForHash().get("user:200", "name");
    System.out.println("属性name: " + name);
    Map<Object, Object> entries = stringRedisTemplate.opsForHash().entries("user:200");//获取全部的hashkey-hashvalue
    System.out.println("所有属性: " + entries);

weixin_71366486

关注

16
点赞
踩
32

收藏

觉得还不错? 一键收藏
0
评论
Redis使用教程

(非结构型,非关联型)的数据库，对数据库格式没有严格约束，往往形式松散，自由。可以是key-value,可以是文档，或者图格式NOSQL数据库往往不支持事务，或者不能严格保证ACID的特性，只能实现基本的一致性。
复制链接

扫一扫