教程 Redis Java

Redis入门与使用

简单介绍了Redis及其在Java中的使用

Redis入门

简介

Redis是一个基于内存的键值对（key-value）结构数据库

Redis对比MySQL的区别：

  • 基于内存存储，读写性能高
  • 适合存储热点数据（短时间大量用户访问）

Redis并不是用来取代MySQL的，而是和MySQL一起使用

下载与使用

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

本文仅介绍windows的使用

启动Redis

解压下载好的压缩包，在解压出来的文件夹打开命令行窗口

PixPin_2025-10-05_18-48-02

在命令行窗口输入下方命令，启动Redis

1

redis-server.exe redis.windows.conf

image-20251005184957748

想要关闭Redis，在命令行窗口使用快捷键ctrl + c即可结束进程

连接本地Redis

演示基础连接方式，一般会使用图形化工具连接

要想连接上Redis，需要重复上述操作，再打开一个命令行窗口，输入下方命令即可连接（不要关闭刚刚启动Redis的命令行窗口）

1

redis-cli.exe

需要取消连接的话，输入exit即可

image-20251005203356205

连接指定Redis

如果需要连接指定ip地址的Redis可以使用下方命令

1

redis-cli.exe -h ip地址 -p 端口号
image-20251005203650980

配置密码

Redis默认是没有密码的，可以在redis.windows.conf中配置密码，输入requirepass 密码来设置密码

image-20251005205017620 image-20251005205229525

连接Redis没有用户的概念，只需要提供密码即可

设置后台自动启动

将Redis安装为Windows服务后可通过服务管理器启动，实现后台运行

在刚刚启动Redis的窗口输入下方命令

1

redis-server --service-install redis.windows.conf --loglevel verbose

此后Redis就会如同MySQL一样，开机后自动在后台运行，不会占用窗口，也无需手动启动

如果不希望自动启动，想要改为手动启动或者禁用可以通过下方步骤操作：

  1. 按下 Win + R 输入 services.msc 打开服务管理器

  2. 在列表中找到 Redis 相关服务（通常名为 Redis 或 Redis Server）

  3. 右键点击服务 → 选择 “属性”

  4. 在 “启动类型” 下拉菜单中可选择：

    • 自动：系统启动时自动运行（默认）
    • 自动（延迟启动）：系统启动后延迟一段时间运行
    • 手动：需要手动启动服务
    • 禁用：禁止启动服务

数据类型

常用数据类型

Redis存储的是key-value结构的数据，其中key是字符串类型，value有5种常用的数据类型：

  • 字符串 string
  • 哈希 hash
  • 列表 list
  • 集合 set
  • 有序集合 sorted set / zset

各种数据类型简介

哈希：也叫散列，类似于Java中的HashMap结构

列表：按照插入顺序排序，可以有重复元素，类似于Java中的LinkedList

集合：又称无序集合，没有重复元素，类似于Java中的HashSet

有序集合：集合中每个元素关联一个分数（score），根据分数升序排序，没有重复元素

image-20251005211049404

常用命令

在Redis中，与MySQL不同的是，MySQL的增删改查命令都是通用的，不区分数据类型，但在Redis中，不同的数据类型有不同的命令，并不是全部通用的

字符串操作命令

Redis 中字符串类型常用命令：

  • SET key value：设置指定key的值
  • GET key：获取指定key的值
  • SETEX key seconds value：设置指定key的值，并将 key 的过期时间设为 seconds 秒
  • SETNX key value：只有在 key 不存在时设置 key 的值

更多命令可以参考Redis中文网：https://www.redis.net.cn

image-20251005214502067

此处使用的图形化工具为DataGrip

哈希操作命令

Redis hash 是一个string类型的 field 和 value 的映射表，hash特别适合用于存储对象，常用命令：

  • HSET key field value：将哈希表 key 中的字段 field 的值设为 value
  • HGET key field：获取存储在哈希表中指定字段的值
  • HDEL key field：删除存储在哈希表中的指定字段
  • HKEYS key：获取哈希表中所有字段（也就是下图中的field1和field2）
  • HVALS key：获取哈希表中所有值（也就是下图中的value1和value2）
image-20251005214946227

image-20251005215841758

image-20251005220152357

列表操作命令

Redis 列表是简单的字符串列表，按照插入顺序排序，常用命令：

  • LPUSH key value1 [value2]：将一个或多个值插入到列表头部
  • LRANGE key start stop：获取列表指定范围内的元素，start 和 stop 是索引，从0开始数，-1可以表示最后一个
  • RPOP key：移除并获取列表最后一个元素
  • LLEN key：获取列表长度
  • BRPOP key1 [key2 ] timeout：移出并获取列表的最后一个元素，如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止
image-20251005220248538

image-20251005220744204

集合操作命令

Redis set 是string类型的无序集合。集合成员是唯一的，这就意味着集合中不能出现重复的数据，常用命令：

  • SADD key member1 [member2]：向集合添加一个或多个成员
  • SMEMBERS key：返回集合中的所有成员
  • SCARD key：获取集合的成员数
  • SINTER key1 [key2]：返回给定所有集合的交集
  • SUNION key1 [key2]：返回所有给定集合的并集
  • SREM key member1 [member2]：移除集合中一个或多个成员
image-20251005220910862

有序集合操作命令

Redis有序集合是string类型元素的集合，且不允许有重复成员。每个元素都会关联一个double类型的分数

常用命令：

  • ZADD key score1 member1 [score2 member2]：向有序集合添加一个或多个成员
  • ZRANGE key start stop [WITHSCORES]：通过索引区间返回有序集合中指定区间内的成员，如果加上 WITHSCORES 会连同分数一起返回。start 和 stop 是索引，从0开始数，-1可以表示最后一个
  • ZINCRBY key increment member：有序集合中对指定成员的分数加上增量 increment
  • ZREM key member [member ...]：移除有序集合中的一个或多个成员
image-20251005221348200

通用命令

Redis的通用命令是不分数据类型的，都可以使用的命令：

  • KEYS pattern：查找所有符合给定模式（pattern）的 key
  • EXISTS key：检查给定 key 是否存在
  • TYPE key：返回 key 所储存的值的类型
  • DEL key：该命令用于在 key 存在是删除 key

在Java中操作Redis

Redis的Java客户端

在Java程序中操作Redis需要使用Redis的Java客户端，就如同使用JDBC操作MySQL数据库一样

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

  • Jedis
  • Lettuce
  • Spring Data Redis

Spring Data Redis对Jedis和Lettuce进行了封装，在Spring Boot项目中还提供了对应的Starter，即 spring-boot-starter-data-redis

Spring Data Redis使用方式

环境搭建

1.在pom.xml文件中导入依赖

1
2
3
4

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

2.在application.yml中配置数据源

1
2
3
4
5
6
7

spring:
  data:
    redis:
      port: 6379
      host: 127.0.0.1
      # passage: 123456 配置密码，不过我没设密码所以注释掉
      database: 0

注：如果用的是SpringBoot2，则不加data，如下

1
2
3
4
5

spring:
  redis:
    port: 6379
    host: 127.0.0.1
    database: 0

3.编写配置类，创建RedisTemplate对象

 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

package com.yuanyu.config;

import lombok.extern.slf4j.Slf4j;
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.StringRedisSerializer;

@Configuration
@Slf4j
public class RedisConfiguration {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        log.info("开始创建redis模板对象...");
        RedisTemplate redisTemplate = new RedisTemplate();
        //设置redis的连接工厂对象
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //设置redis key的序列化器
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        //设置redis value的序列化器(不建议)
        redisTemplate.setValueSerializer(new StringRedisSerializer());
        return redisTemplate;
    }
}

当前配置类不是必须的，因为Spring Boot框架会自动装配 RedisTemplate 对象，但是默认的key和value序列化器为

JdkSerializationRedisSerializer，导致我们存到Redis中后的数据和原始数据有差别（会变成一串编码），故设置为

StringRedisSerializer序列化器

不过不建议将value也序列化为String类型，否则后续可能会出现一些问题

4.测试

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

package com.yuanyu;

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.*;

@SpringBootTest
class RedisDemoApplicationTests {

    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testRedisTemplate() {
        System.out.println("redisTemplate:" + redisTemplate);
        // redisTemplate:org.springframework.data.redis.core.RedisTemplate@34fcd292
    }

}

测试能成功运行说明环境搭建完成

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

//string数据操作
ValueOperations valueOperations = redisTemplate.opsForValue();
//hash类型的数据操作
HashOperations hashOperations = redisTemplate.opsForHash();
//list类型的数据操作
ListOperations listOperations = redisTemplate.opsForList();
//set类型数据操作
SetOperations setOperations = redisTemplate.opsForSet();
//zset类型数据操作
ZSetOperations zSetOperations = redisTemplate.opsForZSet();

在Java中通过上面五种类型的对象来操作Redis

操作常见类型数据

操作字符串类型数据 

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

/**
 * 操作字符串类型的数据
 */
@Test
public void testString(){
    // set
    redisTemplate.opsForValue().set("name","小明");
    // get
    String city = (String) redisTemplate.opsForValue().get("name");
    System.out.println(city);
    // setex
    redisTemplate.opsForValue().set("code","0721",3, TimeUnit.MINUTES);
    // setnx
    redisTemplate.opsForValue().setIfAbsent("lock","1");
    redisTemplate.opsForValue().setIfAbsent("lock","2");
    System.out.println(redisTemplate.opsForValue().get("lock"));
}

操作哈希类型数据 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

/**
 * 操作哈希类型的数据
 */
@Test
public void testHash(){
    HashOperations hashOperations = redisTemplate.opsForHash();
    // hset
    hashOperations.put("100","name","tom");
    hashOperations.put("100","age","20");
    // hget
    String name = (String) hashOperations.get("100", "name");
    System.out.println(name);
    // hkeys
    Set keys = hashOperations.keys("100");
    System.out.println(keys);
    // hvals
    List values = hashOperations.values("100");
    System.out.println(values);
    // hdel
    hashOperations.delete("100","age");
}

操作列表类型数据 

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

/**
 * 操作列表类型的数据
 */
@Test
public void testList(){
    ListOperations listOperations = redisTemplate.opsForList();
    // lpush
    listOperations.leftPushAll("mylist","a","b","c");
    listOperations.leftPush("mylist","d");
    // lrange
    List mylist = listOperations.range("mylist", 0, -1);
    System.out.println(mylist);
    // rpop
    listOperations.rightPop("mylist");
    // llen
    Long size = listOperations.size("mylist");
    System.out.println(size);
}

操作集合类型数据 

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

/**
 * 操作集合类型的数据
 */
@Test
public void testSet(){
    SetOperations setOperations = redisTemplate.opsForSet();
    // sadd
    setOperations.add("set1","a","b","c","d");
    setOperations.add("set2","a","b","x","y");
    // smembers
    Set members = setOperations.members("set1");
    System.out.println(members);
    // scard
    Long size = setOperations.size("set1");
    System.out.println(size);
    // sinter
    Set intersect = setOperations.intersect("set1", "set2");
    System.out.println(intersect);
    // sunion
    Set union = setOperations.union("set1", "set2");
    System.out.println(union);
    // srem
    setOperations.remove("set1","a","b");
}

操作有序集合类型数据 

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

/**
 * 操作有序集合类型的数据
 */
@Test
public void testZset(){
    ZSetOperations zSetOperations = redisTemplate.opsForZSet();
    // zadd
    zSetOperations.add("zset1","a",10);
    zSetOperations.add("zset1","b",12);
    zSetOperations.add("zset1","c",9);
    // zrange
    Set zset1 = zSetOperations.range("zset1", 0, -1);
    System.out.println(zset1);
    // zincrby
    zSetOperations.incrementScore("zset1","c",10);
    // zrem
    zSetOperations.remove("zset1","a","b");
}

通用命令操作 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

/**
 * 通用命令操作
 */
@Test
public void testCommon(){
    //keys
    Set keys = redisTemplate.keys("*");
    System.out.println(keys);
    // exists
    Boolean name = redisTemplate.hasKey("name");
    Boolean set1 = redisTemplate.hasKey("set1");
    // type
    for (Object key : keys) {
        DataType type = redisTemplate.type(key);
        System.out.println(type.name());
    }
    // del
    redisTemplate.delete("mylist");
}
© 2025 - 2026 缘鱼
本站于2025年3月26日建立
使用 Hugo 构建
主题 Stack 由 Jimmy 设计