redis的基本使用_redis启动命令

一、 Redis简介

1. Redis是一个基于内存的 key-value 结构数据库。Redis是一款采用key-value数据存储格式的内存级NoSQL数据库，重点关注数据存储格式，是key-value格式，也就是键值对的存储形式。（redis是对Mysql的补充）
   • 与MySQL数据库不同，MySQL数据库有表、有字段、有记录，Redis没有这些东西，就是一个名称对应一个值，并且数据以存储在内存中使用为主。
   • 什么叫以存储在内存中为主？其实Redis有它的数据持久化方案，分别是RDB和AOF，但是Redis自身并不是为了数据持久化而生的，主要是在内存中保存数据，加速数据访问的，所以说是一款内存级数据库。
2. 官网介绍：Redis是一个开源（BSD许可），内存存储的数据结构服务器，可用作数据库，高速缓存和消息队列代理。它支持字符串、哈希表、列表、集合、有序集合，位图，hyperloglogs等数据类型。内置复制、Lua脚本、LRU收回、事务以及不同级别磁盘持久化功能，同时通过Redis Sentinel提供高可用，通过Redis Cluster提供自动分区
3. 特点：
   • 基于内存存储，读写性能高
   • 适合存储热点数据（热点商品、资讯、新闻）
   • 企业应用广泛

Redis在windows下的安装

1. Redis安装包分为 Windows 版和 Linux 版：

   • Windows版下载地址：https://github.com/microsoftarchive/redis/releases
   • Linux版下载地址： https://download.redis.io/releases/
     

2. 下载的安装包有两种形式，一种是一键安装的msi文件，还有一种是解压缩就能使用的zip文件，哪种形式都行。

   • 啥是msi，其实就是一个文件安装包，不仅安装软件，还帮你把安装软件时需要的功能关联在一起，打包操作。比如如安装序列、创建和设置安装路径、设置系统依赖项、默认设定安装选项和控制安装过程的属性。说简单点就是一站式服务，安装过程一条龙操作一气呵成，就是为小白用户提供的软件安装程序。

3. Redis的Windows版属于绿色软件，直接解压zip文件即可使用，解压后目录结构如下：
   

二、redis的使用

二、1、服务器启动命令

1. 服务启动命令：redis-server.exe redis.windows.conf（要在该文件夹目录下进行）
   

通过快捷键Ctrl + C 即可停止Redis服务

二、2、客户端连接命令

1. 客户端连接命令：redis-cli.exe
   

2. 注意：通过redis-cli.exe命令默认连接的是本地的redis服务，并且使用默认6379端口（初学者无需调整服务器对外服务端口，默认6379。）。也可以通过指定如下参数连接：

   • -h ip地址
   • -p 端口号
   • -a 密码（如果需要）
     • redis默认是没有设置密码的，如果需要可以到redis的配置文件里面进行设置。
     • 注意：连接redis是没有用户的说法的，只需要使用密码就可以进行连接了，这个与mysql有区别的

3. redis设置密码：
   
   
   

二、3、Redis的客户端图形界面

1. 安装：下载.exe文件然后进行安装
   
   
   
2. 基本使用：
   
   
   

三、 5种常用数据类型

1. Redis存储的是key-value结构的数据，其中key是字符串类型，value有5种常用的数据类型：
   • 字符串 string：普通字符串，Redis中最简单的数据类型（常用）
   • 哈希 hash：也叫散列，类似于Java中的HashMap结构（一般拿来存储对象）
   • 列表 list：按照插入顺序排序，可以有重复元素，类似于Java中的LinkedList（使用例子：朋友圈的点赞）
   • 集合 set：无序集合，没有重复元素，类似于Java中的HashSet
   • 有序集合 （sorted set / zset）：集合中每个元素关联一个分数（score），根据分数升序排序，没有重复元素（使用例子：各种排行榜）

三、1、 redis的常用命令

三、1.1、 字符串操作命令

1. Redis 的String字符串类型常用命令：
   • （SET key value）：设置指定key的值
   • （GET key）：获取指定key的值
   • （SETEX key seconds value ）：设置指定key的值，并将 key 的过期时间设为 seconds 秒（常用的例子：短信的验证码）
   • （SETNX key value）：只有在 key 不存在时设置 key 的值（常用例子：分布式锁）

用法说明：

set name tom   =》表示 设置 键名为name的值为tom，这里的name就是key的名称（键名）

get name    =》表示 获取 键名为name的值

setex age 60 100  =》表示 设置 键名为age的值为100，并把age的过期时间设置为60秒。（从创建完成后开始计时60秒，之后该键名的值就会失效。

setnx month 12     =》当month键名不存在时，表示设置month的值为12，当month键名已经存在时，命令失效，无法设置成功。

1
2
3
4
5
6
7
8

三、1.2、 哈希操作命令

1. Redis hash 是一个string类型的 field 和 value 的映射表，hash特别适合用于存储对象，常用命令：
   • （HSET key field value）： 将哈希表 key 中的字段 field 的值设为 value
   • （HGET key field）： 获取存储在哈希表中指定字段的值
   • （HDEL key field）：删除存储在哈希表中的指定字段
   • （HKEYS key）： 获取哈希表中所有字段
   • （HVALS key）：获取哈希表中所有值

用法说明：

hset 1 name zhangsan   
=》表示 设置 key为1的哈希表，key里面filed的值为name，filed对应的值为zhangsan（可以把filed看成属性，然后把value看成属性值）

hget 1 name   
=》表示 获取 存储在key为1的哈希表里面的字段为name的值

hdel 1 name 
=》表示删除存储在key为1的哈希表中里面的字段名为name的字段

hkeys 1 
=》表示获取key为1的哈希表的所有字段

hvals 1
=》表示获取key为1的哈希表里面的所有字段的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

三、1.3、 列表操作命令

1. Redis 列表list，是简单的字符串列表，按照插入顺序排序，常用命令：
   • （LPUSH key value1 [value2] ）： 将一个或多个值插入到列表头部(左边)
   • （LRANGE key start stop ）： 获取列表指定范围内的元素
   • （RPOP key ）： 移除并获取列表最后一个元素(右边)
   • （LLEN key ）： 获取列表长度

三、1.4、 集合操作命令

1. Redis的set 是string类型的无序集合。集合成员是唯一的，集合中不能出现重复的数据，常用命令：
   • （SADD key member1 [member2] ）： 向集合添加一个或多个成员
   • （SMEMBERS key ）： 返回集合中的所有成员
   • （SCARD key ）： 获取集合的成员数
   • （SINTER key1 [key2] ）： 返回给定所有集合的交集
   • （SUNION key1 [key2] ）： 返回所有给定集合的并集
   • （SREM key member1 [member2] ）： 删除集合中一个或多个成员

三、1.5、 有序集合操作命令

1. Redis的sortedSet有序集合是string类型元素的集合，且不允许有重复成员。每个元素都会关联一个double类型的分数。常用命令：
   • （ZADD key score1 member1 [score2 member2] ）： 向有序集合添加一个或多个成员
   • （ZRANGE key start stop [WITHSCORES] ）： 通过索引区间返回有序集合中指定区间内的成员
   • （ZINCRBY key increment member ）： 有序集合中对指定成员的分数加上增量 increment
   • （ZREM key member [member …] ）： 移除有序集合中的一个或多个成员

三、1.6、 redis通用操作命令

1. Redis的通用命令是不分数据类型的，都可以使用的命令：
   • （KEYS pattern ）： 查找所有符合给定模式( pattern)的 key
   • （EXISTS key ）： 检查给定 key 是否存在
   • （TYPE key ）： 返回 key 所储存的值的类型
   • （DEL key ）： 该命令用于在 key 存在是删除 key

四、在java中操作redis

四、1、redis的java客户端

1. Redis 的 Java 客户端很多，常用的几种：

   • Jedis（官方推荐的java客户端）
   • Lettuce
   • Spring Data Redis

2. Spring Data Redis 是 Spring 的一部分，对 Redis 底层开发包进行了高度封装。

   • 在 Spring 项目中，可以使用Spring Data Redis来简化操作。

四、1.1、 Spring Data Redis 的使用方式

1. 操作步骤：
   • 1. 导入Spring Data Redis 的maven坐标
   • 2. 配置Redis数据源
   • 3. 编写配置类，创建RedisTemplate对象，然后通过RedisTemplate对象操作Redis

步骤①：导入springboot整合redis的starter坐标

上述坐标可以在创建模块的时候通过勾选的形式进行选择，归属NoSQL分类中

步骤②：进行基础配置

spring:
  redis:
    host: localhost
    port: 6379
    database: 10   # database是指定使用redis里面的哪个数据库（默认用的是0数据库）
1
2
3
4
5

操作redis，最基本的信息就是操作哪一台redis服务器，所以服务器地址属于基础配置信息，不可缺少。但是即便你不配置，目前也是可以用的。因为以上两组信息都有默认配置，刚好就是上述配置值。

步骤③：使用springboot整合redis的专用客户端接口操作，此处使用的是RedisTemplate

可以选择创建redis对象：（在里面可以添加一些操作）

@Configuration
@Slf4j  //日志的注解，有它下面的log.info才能使用
public class RedisConfiguration {
    @Bean   // 按照类型 注入对象RedisConnectionFactory
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
        log.info("开始创建redis模板类...");
        RedisTemplate redisTemplate = new RedisTemplate();
//        设置redis的连接工厂对象
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        
        // 设置Key的序列化器，默认为JdkSerializationRedisSerializer
        redisTemplate.setKeySerializer(new StringRedisSerializer());

        return redisTemplate;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

测试类：注意，测试类的位置要和引导类处于同一目录下（一般用idea的Spring Initializr创建的测试环境自动给你建立好目录的，但是如果是使用maven自己导入依赖实现的springboot项目，写测试类的时候则需要建立和引导类所处的目录结构，或者在@SpringbootTest()注解里面指定引导类）

注意操作redis之前，记得启动redis。

@SpringBootTest
class SpringbootRedisApplicationTests {
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void set() {
        ValueOperations ops = redisTemplate.opsForValue();
        ops.set("age",41);
    }
    @Test
    void get() {
        ValueOperations ops = redisTemplate.opsForValue();
        Object age = ops.get("name");
        System.out.println(age);
    }
    @Test
    void hset() {
        HashOperations ops = redisTemplate.opsForHash();
        ops.put("info","b","bb");
    }
    @Test
    void hget() {
        HashOperations ops = redisTemplate.opsForHash();
        Object val = ops.get("info", "b");
        System.out.println(val);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

在操作redis时，需要先确认操作何种数据，根据数据种类得到操作接口。例如使用opsForValue()获取string类型的数据操作接口，使用opsForHash()获取hash类型的数据操作接口，剩下的就是调用对应api操作了。各种类型的数据操作接口如下：

@SpringBootTest
public class springDataRedisTest {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testRedisTemplate(){
        System.out.println(redisTemplate);
//        获取字符串对象
        ValueOperations valueOperations = redisTemplate.opsForValue();
//        获取hash对象
        HashOperations hashOperations = redisTemplate.opsForHash();
//        获取list列表对象
        ListOperations listOperations = redisTemplate.opsForList();
//        获取set对象
        SetOperations setOperations = redisTemplate.opsForSet();
//        获取ZSet对象
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();
    }

    /**
     * 操作字符串类型的数据
     */
    @Test
    public void testString(){
//        插入字符串类型的数据
        redisTemplate.opsForValue().set("city","北京");
//        获取字符串类型的数据
        String city = (String)redisTemplate.opsForValue().get("city");
        System.out.println("city=== "+city);
//        设置key-value的有效时间
        redisTemplate.opsForValue().set("code","1234",3, TimeUnit.MINUTES);

//        只有在 key 不存在时设置 key 的值（常用例子：分布式锁）
        redisTemplate.opsForValue().setIfAbsent("lock","1"); // 可以设置成功
        redisTemplate.opsForValue().setIfAbsent("lock","2"); // 设置不成功
    }

    /**
     * 操作hash类型的数据
     */
    @Test
    public void testHash(){
        //hset hget hdel hkeys hvals
        HashOperations hashOperations = redisTemplate.opsForHash();
//        插入一条hash类型的数据
        hashOperations.put("100","name","tom");
        hashOperations.put("100","age","20");

//        获取hash类型的数据
        String name = (String) hashOperations.get("100", "name");
        System.out.println(name);

//        获取所有key=100的hash表的所有的key
        Set keys = hashOperations.keys("100");
        System.out.println(keys);

        //        获取所有key=100的hash表的所有的value
        List values = hashOperations.values("100");
        System.out.println(values);

//        删除字段
        hashOperations.delete("100","age");
    }

    /**
     * 操作列表类型的数据
     */
    @Test
    public void testList(){
        //lpush lrange rpop llen
        ListOperations listOperations = redisTemplate.opsForList();

        listOperations.leftPushAll("mylist","a","b","c");
        listOperations.leftPush("mylist","d");

        List mylist = listOperations.range("mylist", 0, -1);
        System.out.println(mylist);

        listOperations.rightPop("mylist");

        Long size = listOperations.size("mylist");
        System.out.println(size);
    }

    /**
     * 操作集合类型的数据
     */
    @Test
    public void testSet(){
        //sadd smembers scard sinter sunion srem
        SetOperations setOperations = redisTemplate.opsForSet();

        setOperations.add("set1","a","b","c","d");
        setOperations.add("set2","a","b","x","y");

        Set members = setOperations.members("set1");
        System.out.println(members);

        Long size = setOperations.size("set1");
        System.out.println(size);

        Set intersect = setOperations.intersect("set1", "set2");
        System.out.println(intersect);

        Set union = setOperations.union("set1", "set2");
        System.out.println(union);

        setOperations.remove("set1","a","b");
    }

    /**
     * 操作有序集合类型的数据
     */
    @Test
    public void testZset(){
        //zadd zrange zincrby zrem
        ZSetOperations zSetOperations = redisTemplate.opsForZSet();

        zSetOperations.add("zset1","a",10);
        zSetOperations.add("zset1","b",12);
        zSetOperations.add("zset1","c",9);

        Set zset1 = zSetOperations.range("zset1", 0, -1);
        System.out.println(zset1);

        zSetOperations.incrementScore("zset1","c",10);

        zSetOperations.remove("zset1","a","b");
    }

    /**
     * 通用命令操作
     */
    @Test
    public void testCommon(){
        //keys exists type del
        Set keys = redisTemplate.keys("*");
        System.out.println(keys);

        Boolean name = redisTemplate.hasKey("name");
        Boolean set1 = redisTemplate.hasKey("set1");

        for (Object key : keys) {
            DataType type = redisTemplate.type(key);
            System.out.println(type.name());
        }

        redisTemplate.delete("mylist");
    }

}


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

四、1.2、 StringRedisTemplate

由于redis内部不提供java对象的存储格式，因此当操作的数据以对象的形式存在时，会进行转码，转换成字符串格式后进行操作。为了方便开发者使用基于字符串为数据的操作，springboot整合redis时提供了专用的API接口StringRedisTemplate，你可以理解为这是RedisTemplate的一种指定数据泛型的操作API。

@SpringBootTest
public class StringRedisTemplateTest {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Test
    void get(){
        ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
        String name = ops.get("name");
        System.out.println(name);
    }
}
1
2
3
4
5
6
7
8
9
10
11

四、1.3、 Redis客户端的选择

1. Spring Boot默认使用的Redis客户端是Lettuce。Lettuce是一个高性能的异步Redis客户端，它基于Netty框架实现了高效的异步通信。它支持连接池和集群模式，并提供了丰富的功能和灵活的配置选项。

   • 在Spring Boot中，你可以通过在配置文件中设置spring.redis.client-type属性来指定使用的Redis客户端。默认情况下，该属性的值是lettuce，即使用Lettuce作为Redis客户端。如果你想使用Jedis作为Redis客户端，可以根据需要切换成指定客户端技术将该属性的值设置为对应的客户端技术，比如jedis。

2. 切换成jedis客户端技术操作步骤如下：

步骤①：导入jedis坐标

<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>
1
2
3
4

edis坐标受springboot管理，无需提供版本号
步骤②：配置客户端技术类型，设置为jedis

spring:
  redis:
    host: localhost
    port: 6379
    client-type: jedis
1
2
3
4
5

3. lettcus与jedis区别
   • jedis连接Redis服务器是直连模式，当多线程模式下使用jedis会存在线程安全问题，解决方案可以通过配置连接池使每个连接专用，这样整体性能就大受影响
   • lettcus基于Netty框架进行与Redis服务器连接，底层设计中采用StatefulRedisConnection。 StatefulRedisConnection自身是线程安全的，可以保障并发访问安全问题，所以一个连接可以被多线程复用。当然lettcus也支持多连接实例一起工作

五、redis的两种持久化方式

1. redis提供了两种持久化的方式，分别是RDB（Redis DataBase）和AOF（Append Only File）。
   • RDB：就是在不同的时间点，将redis存储的数据生成快照并存储到磁盘等介质上；
   • AOF：与RDB相比，则是换了一个角度来实现持久化，那就是将redis执行过的所有写指令记录下来，在下次redis重新启动时，只要把这些写指令从前到后再重复执行一遍，就可以实现数据恢复了。
   • 其实RDB和AOF两种方式也可以同时使用，在这种情况下，如果redis重启的话，则会优先采用AOF方式来进行数据恢复，这是因为AOF方式的数据恢复完整度更高。如果没有数据持久化的需求，也完全可以关闭RDB和AOF方式。这样的话，redis将变成一个纯内存数据库，就像memcache一样。

Redis的使用应该是在Linux环境，这里只是基本了解下Redis的知识。