环境：

• 操作系统： Ubuntu 20.04
• Redis：6.2.6
• 开发工具：IntelliJ IDEA 2022.1 (Community Edition)

Redis官网（ https://redis.io/docs/clients/#java ）所推荐的Java客户端有：

• Redisson
• Jedis
• lettuce

等等。本文将介绍 Jedis 和 lettuce 。

Jedis

方法1：手工配置

即手工搜索并下载所需的jar包，可以到以下网站搜索：

• https://mvnrepository.com/
• https://search.maven.org/

搜索 jedis ，下载 jedis-4.2.2.jar 文件。

新建项目 test0427_1 ：

在项目下创建 lib 目录，把 jedis-4.2.2.jar 复制到这里。

➜  test0427_1 mkdir lib
➜  test0427_1 cp ~/Downloads/jedis-4.2.2.jar lib/
➜  test0427_1 

File -> Project Structure... -> Modules -> Dependencies ，点击 + 图标，选择 JARs or Directories... ，然后选择 jedis-4.2.2.jar 文件：

创建 Test0427.java 文件如下：

package pkg1;

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

public class Test0427 {
    public static void main(String[] args) {
        JedisPool pool = new JedisPool("localhost", 6379);

        try (Jedis jedis = pool.getResource()) {
            jedis.set("mykey1", "500");
        }
    }
}

运行程序，报错如下：

/home/ding/IdeaProjects/test0427_1/src/pkg1/Test0427.java:8:26
java: cannot access org.apache.commons.pool2.impl.GenericObjectPoolConfig
  class file for org.apache.commons.pool2.impl.GenericObjectPoolConfig not found

从 http://www.bjpowernode.com/tutorial_redis/342.html 可知，还需要下载 commons-pool2 。

搜索 commons-pool2 ，并下载 commons-pool2-2.11.1.jar 文件，按前面的方法将其添加到项目里。

运行程序，报错如下：

Exception in thread "main" java.lang.NoClassDefFoundError: org/slf4j/LoggerFactory
	at redis.clients.jedis.JedisPool.<clinit>(JedisPool.java:19)
	at pkg1.Test0427.main(Test0427.java:8)
Caused by: java.lang.ClassNotFoundException: org.slf4j.LoggerFactory
	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:641)
	at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:188)
	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:520)
	... 2 more

继续搜索 slf4j.api ，下载 slf4j-api-2.0.0-alpha7.jar 文件，按前面的方法将其添加到项目里。

运行程序，报错如下：

SLF4J: No SLF4J providers were found.
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#noProviders for further details.
Exception in thread "main" java.lang.NoClassDefFoundError: com/google/gson/Gson
	at redis.clients.jedis.CommandObjects.<clinit>(CommandObjects.java:3655)
	at redis.clients.jedis.Jedis.<init>(Jedis.java:39)
	at redis.clients.jedis.JedisFactory.makeObject(JedisFactory.java:181)
	at org.apache.commons.pool2.impl.GenericObjectPool.create(GenericObjectPool.java:571)
	at org.apache.commons.pool2.impl.GenericObjectPool.borrowObject(GenericObjectPool.java:298)
	at org.apache.commons.pool2.impl.GenericObjectPool.borrowObject(GenericObjectPool.java:223)
	at redis.clients.jedis.util.Pool.getResource(Pool.java:34)
	at redis.clients.jedis.JedisPool.getResource(JedisPool.java:364)
	at pkg1.Test0427.main(Test0427.java:10)
Caused by: java.lang.ClassNotFoundException: com.google.gson.Gson
	at java.base/jdk.internal.loader.BuiltinClassLoader.loadClass(BuiltinClassLoader.java:641)
	at java.base/jdk.internal.loader.ClassLoaders$AppClassLoader.loadClass(ClassLoaders.java:188)
	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:520)
	... 9 more

SLF4J 的错误其实并不影响运行，真正影响运行的是 gson 的错误。继续搜索gson ，下载 gson-2.9.0.jar 文件，按前面的方法将其添加到项目里。

运行程序，报错如下：

SLF4J: No SLF4J providers were found.
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#noProviders for further details.

不过也成功了。

如果想移除错误，继续搜索slf4j.simpl ，下载 slf4j-simple-2.0.0-alpha7.jar 文件，按前面的方法将其添加到项目里。

运行程序，这回终于没有任何错误了。

最终所使用的的jar包如下：

方法2：Maven配置

手工配置Jedis实在太麻烦，所以显而易见的解决方案是使用Maven来管理依赖。

新建Maven项目test0427_2 ：

打开 pom.xml 文件，添加如下内容：

        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
            <version>4.2.2</version>
        </dependency>

注：需要加到 <dependencies> 里面，如果没有就手工创建一下。

同样，创建 Test0427.java 文件如下：

package pkg1;

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

public class Test0427 {
    public static void main(String[] args) {
        JedisPool pool = new JedisPool("localhost", 6379);

        try (Jedis jedis = pool.getResource()) {
            jedis.set("mykey1", "500");
        }
    }
}

运行程序，报错如下：

SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.

不过也成功了。

这个错误跟方法1缺少 slf4j-simple-2.0.0-alpha7.jar 文件的错误完全一样。

查看 External Libraries ，可见除了 slf4j-simple-2.0.0-alpha7.jar 以外，已经包含了方法1所添加的那些jar包。

如果想移除错误，在 pom.xml 中添加以下依赖：

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.32</version>
        </dependency>

注：版本是 1.7.32 ，因为 slf4j-api 的版本是 1.7.32 。如果换成别的版本（比如 2.0.0-alpha7 ），貌似不行，仍然报错。

查看 External Libraries ，如下：

方法3：SpringBoot

参见下面Lettuce部分的SpringBoot配置。Spring Data Redis默认使用的是Lettuce。

Lettuce

方法1：手工配置

即手工搜索并下载所需的jar包。可从（https://github.com/lettuce-io/lettuce-core/releases）下载。我看到的最新版本是6.1.8，但是该版本只提供源码下载，需要自己做build，于是我下载了6.1.7的包 lettuce-core-6.1.7.RELEASE-bin.tar.gz 。

解压后得到 lettuce-core-6.1.7.RELEASE.jar 以及其它一些jar包。

新建项目 test0429_1 ：

在项目下创建 lib 目录，把 lettuce-core-6.1.7.RELEASE.jar 以及其它所有的jar包都复制到这里。

File -> Project Structure... -> Modules -> Dependencies ，点击 + 图标，选择 JARs or Directories... ，然后选择 lib 目录下所有的文件：

最终所使用的jar包如下：

创建 Test0429.java 文件如下：

package pkg1;

import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.sync.RedisCommands;

import java.time.Duration;
import java.time.temporal.ChronoUnit;

public class Test0429 {
    public static void main(String[] args) {
        RedisURI redisUri = RedisURI.builder()
                .withHost("localhost")
                .withDatabase(0)
                .withPort(6379)
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();

        RedisClient redisClient = RedisClient.create(redisUri);

        StatefulRedisConnection<String, String> conn = redisClient.connect();

        RedisCommands<String, String> command = conn.sync();

        command.set("mykey1", "500");

        conn.close();

        redisClient.shutdown();
    }
}

运行程序，OK，测试成功！

方法2：Maven配置

新建Maven项目test0429_2 ：

打开 pom.xml 文件，添加如下内容：

<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
    <version>6.1.8.RELEASE</version>
</dependency>

注：需要加到 <dependencies> 里面，如果没有就手工创建一下。

同样，创建 Test0429.java 文件如下：

package pkg1;

import io.lettuce.core.RedisClient;
import io.lettuce.core.RedisURI;
import io.lettuce.core.api.StatefulRedisConnection;
import io.lettuce.core.api.sync.RedisCommands;

import java.time.Duration;
import java.time.temporal.ChronoUnit;

public class Test0429 {
    public static void main(String[] args) {
        RedisURI redisUri = RedisURI.builder()
                .withHost("localhost")
                .withDatabase(0)
                .withPort(6379)
                .withTimeout(Duration.of(10, ChronoUnit.SECONDS))
                .build();

        RedisClient redisClient = RedisClient.create(redisUri);

        StatefulRedisConnection<String, String> conn = redisClient.connect();

        RedisCommands<String, String> command = conn.sync();

        command.set("mykey1", "500");

        conn.close();

        redisClient.shutdown();
    }
}

运行程序，OK，测试成功！

查看 External Libraries ，如下：

注：如果要使用连接池，则需要 commons-pool2 。在 pom.xml 文件中添加如下依赖：

        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.11.1</version>
        </dependency>

方法3：SpringBoot

打开 https://start.spring.io/ ，搜索 redis ，添加依赖 Spring Data Redis (Access+Driver) ，如下图所示：

创建项目 test0429_3 ，下载 test0429_3.zip 文件，解压生成项目，并打开。

打开 pom.xml 文件，可见相关的依赖为：

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

打开 application.properties 文件，添加Redis的配置信息：

spring.redis.host=localhost
spring.redis.port=6379

本例只配置了 host 和 port ，若有其它信息，也可在此配置。

打开 Test04293ApplicationTests.java 文件，添加依赖注入的 StringRedisTemplate ，然后添加一个自定义Test，最终代码如下：

package com.example.test0429_3;

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;

@SpringBootTest
class Test04293ApplicationTests {

	@Autowired
	StringRedisTemplate redisTemplate;

	@Test
	void contextLoads() {
	}

	@Test
	void myTest() {
		redisTemplate.opsForValue().set("mykey1", "500");
	}
}

运行 myTest ，OK，测试成功！

注：这里使用的是 StringRedisTemplate 而不是 RedisTemplate 。如果是后者，运行也OK，但是从 redis-cli 命令行检查，key和value都是一些奇怪的编码，这是因为 RedisTemplate 默认采用的是JDK的序列化策略。

最终项目结构如下：

参考

• https://redis.io/
• https://github.com/redis/jedis
• https://mvnrepository.com/
• https://search.maven.org/
• https://lettuce.io/
• https://github.com/lettuce-io/
• http://www.bjpowernode.com/tutorial_redis/342.html

一、通过Jedis 操作Redis

1. 引入Jedis 依赖 :
2. 创建Jedis 连接 → 操作Redis → 关闭Jedis 连接
   
   注意 : 如果连接不上，可能是redis配置文件的问题，需要到redis主机上的redis.conf中进行如下修改 :
   ① 把bind=127.0.0.1注释掉。
   ② 将protected-mode设置为no。
   通常不这样直接使用Jedis，而是通过Jedis连接池来创建Jedis : 创建连接池类 → 通过连接池类创建Jedis
   连接池类 :
   
   获取Jedis :
   获取到Jedis之后的使用就没什么特别的了。

二、通过SpringDataRedis 操作Redis
SpringDataRedis 是Spring Boot 集成的Redis服务，使用步骤 : 引入Redis 和common-pool 依赖 → 在application.properties中配置Redis 相关信息 → 获取RedisTemplate 对象，并通过RedisTemplate 对象操作Redis 数据库。
① 引入Redis 和common-pool 依赖 :

② 在application.properties中配置Redis 相关信息 :

注意 : SpringDataRedis 默认使用 lettuce 而不是Jedis。
③ 获取RedisTemplate 对象，并通过RedisTemplate 对象操作Redis 数据库 :

SpringDataRedis存在的问题 :
Redis会自动对接收到的数据进行序列化，因此当写入Redis 时，实际存在Redis 数据库中的内容跟我们写入的不一样 :

参考资料 : https://www.bilibili.com/video/BV1cr4y1671t?p=22
解决方法 : 自定义RedisTemplate 的序列化方式 :
序列化方案一 :


这种方案的优点 : 能自动进行序列化和反序列化，也就是当我们存入一个对象时，会自动帮我们序列化成JSON 数据存入Redis；同样的，当从Redis 去除对应的JSON数据时，也会自动反序列化成对象。
缺点 : 存入Redis 时需要多保存属性 (用于保存JSON数据与对象的映射)，带来额外开销。

方案二 :

优点 : 不增加额外开销。
缺点 : 需要手动序列化和反序列化。

----- end ------

由于在博主的博客专栏《杂货铺实战》中的杂货铺项目中用到了Redis，那么本篇博文就针对Redis的五种数据结构以及如何在JAVA中封装使用做一个简单的介绍。

数据结构

Redis有五种基础数据结构，分别为：
1、string(字符串)
2、list(列表)
3、hash(字典)
4、set(集合)
5、zset(有序集合)

接下来我们就来具体看看每种数据结构的简介和常用指令，以及在JAVA中如何封装使用吧！

string字符串

string字符串简介

字符串的结构使用非常的广泛，常见的用途就是缓存用户信息。比如说博主的《杂货铺实战专栏》中的杂货铺项目，邮箱验证时生成的邮箱验证码等等。

我们将要存储的对象信息使用JSON序列化成字符串，然后将序列化后的字符串使用Redis进行缓存。在取存储信息的时候进行一次反序列化操作就可以了。

Redis的字符串与Java的字符串有所不同的就是，Java中的String是final类型的字符串，而Redis的字符串是动态字符串，是可以修改的字符串，内部实现结构类似于Java的ArrayList，采用预分配冗余空间来减少内存的频繁分配。

既Redis会分配比实际字符串大的capacity（空间），扩容的时候就扩容加倍现有的空间。但是字符串的最大长度为512MB。

一些普通的操作比如set、get、exists、del如下：

当然也可以通过mset、mget批量读写：

我们都知道，有些数据我们是不会让它长久存储在缓存里的，所以要设置对应的过期时间，可以通过expire、setex来设置，并且可以通过sexnx来判断key值是否存在不存在就创建：

当我们的value是一个整数的时候，还可以通过incr、decr、incrby、decrby进行增减操作，需要注意的是它的返回是介于signed long的最大值以及最小值之间的，一旦超出这个范围，就会报错：

string字符串在Java中的封装

（注：以下只列举string类型的工具类的完整写法，其他数据结构只列举部分写法）

在pom.xml引入依赖：

        <!-- redis依赖包 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

你可以在yml文件中配置，或者在properties文件中配置，挑选一个你认为看着舒服的配置上就好：

# yml文件配置
spring:
  redis:
    host: 127.0.0.1
    port: 6379
    password:
    jedis:
      pool:
        #连接池最大连接数（使用负值表示没有限制）
        max-active: 20
        #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-wait: -1
        #连接池中的最大空闲连接
        max-idle: 20
        #连接池中的最小空闲连接
        min-idle: 2
    #连接超时时间（毫秒）
    timeout: 5000

# properties文件配置
#Redis服务器地址
spring.redis.host=127.0.0.1
#Redis服务器连接端口
spring.redis.port=6379
#Redis数据库索引（默认为0）
spring.redis.database=0
#连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=50
#连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=3000
#连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=20
#连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=2
#连接超时时间（毫秒）
spring.redis.timeout=5000

然后编写Redis的工具类：

package com.gantiexia.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;

/**
 * @author GanTieXia
 * @date 2021/11/21 18:07
 */

@Component
public class RedisUtils {

    /** 引入对应的依赖后注入即可*/
    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    /**
     * 读取缓存
     *
     * @param key
     * @return
     */
    public String get(final String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 写入缓存
     */
    public boolean set(final String key, String value) {
        boolean result = false;
        try {
            redisTemplate.opsForValue().set(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 带失效时间key
     *
     * @param key
     * @param value
     * @param timeOut
     * @param timeUnit
     * @return
     */
    public boolean setKeyTimeOut(final String key,String value,long timeOut,TimeUnit timeUnit){
        boolean result = false;
        try {
            redisTemplate.opsForValue().set(key, value, timeOut, timeUnit);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 更新缓存
     */
    public boolean getAndSet(final String key, String value) {
        boolean result = false;
        try {
            redisTemplate.opsForValue().getAndSet(key, value);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 删除缓存
     */
    public boolean delete(final String key) {
        boolean result = false;
        try {
            redisTemplate.delete(key);
            result = true;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return result;
    }
}

list列表

list列表简介

Redis的列表相当于Java语言中的LinkedList，但是它是链表，而不是数组。那么这就意味着它的插入和删除非常快，而索引定位却是比较慢的。

列表中的每个元素是使用双向指针连接起来的，支持向前遍历和向后遍历。当列表弹出最后一个元素时，该数据结构自动删除，内存被回收。

Redis的列表结构可以用来做异步队列使用。我们把需要延后处理的任务结构序列化成字符串，存入Redis列表，再启用另一个线程从列表中取得数据进行处理。

队列

众所周知，队列是先进先出的数据结构，可用于我们常听到的消息队列，可确保元素的访问顺序性。

栈

栈是一种先进后出的数据结果，跟我们常用的撤回是一个道理。

还可以通过lindex查找对应位置上的元素，lrange 0 -1（-1代表最后一个元素，-2代表倒数第二个元素）获取所有的元素，ltrim可以保留某个区间的元素，砍掉其他位置的元素。但是这些操作的时间复杂度为O(n)，所以一般都不推荐使用。

list列表在Java中的封装

（完整代码参考上文string的封装）

// 根据你的需要传入相应的参数
// set方法的主要语句
redisTemplate.opsForList(). ;  // .后面的方法根据你的应用场景写入

hash(字典)

hash字典简介

Redis的字典相当于JAVA语言里的HashMap，它是一个无需字典，内部存储了很多键值对。

而针对HashMap的概念模型，在博主的JAVA进阶篇——HashMap底层实现解析（一）一文中讲解得很清晰了。

不同的是，Redis的字典的值只能是字符串，并且他们的rehash也是不一样的。Java的HashMap在字典很大的时候，rehash是非常耗时的操作，得一次性全部rehash。而redis为了延续高性能，不产生堵塞，采用了渐进式的rehash策略。

渐进式rehash策略就是会在rehash的同时，保留新旧两个hash结构，查询时会同时查询两个hash结构，然后通过后续的定时任务以及hash操作指令中，将旧的hash结构转移到新的hash结构中，在最后一个hash元素搬移之后，旧hash结构删除，内存被回收。

hash的好处在哪呢，举个例子，当我们存储用户信息的时候，string是将整条信息直接序列化后存储，取出来以后还需要反序列化再获取我们想要的信息。使用hash则可以对用户结构中的每一个单一字段进行存储，比如我们要获取用户名的之后，就不用拿到一整条用户信息了，这样就可以节省网络流量。

但美中不足的是，hash结构的存储消耗要高于单个字符串。

接下来我们来看看操作：

hash字典在Java中的封装

（完整代码参考上文string的封装）

// 根据你的需要传入相应的参数
// set方法的主要语句
redisTemplate.opsForHash(). ;  // .后面的方法根据你的应用场景写入

set(集合)

set集合简介

Redis的集合相当于Java中的HashSet，内部的键值是无序的、唯一的，也就是在Java中我们所常用的使用Set去重。

Redis的集合内部相当于一个特殊的字典，字典中每一个key的键值value都是NULL，同其他数据结构一样，最后一个元素被移除时，数据结构删除，内存被回收。

接下来我们来看看操作指令：

set集合在Java中的封装

（完整代码参考上文string的封装）

// 根据你的需要传入相应的参数
// set方法的主要语句
redisTemplate.opsForSet(). ;  //.后面的方法根据你的应用场景写入

zset(有序列表)

zset有序列表

zset也是一个set，它保证了内部value的唯一性，并且给每一个value赋予一个score，代表value的排序权重。

zset可以用来干什么呢？比如粉丝列表，打开粉丝列表，value存储用户信息，score存储关注时间，粉丝列表就可以以关注时间排序展示…等等这里就不做过多的阐述了。

下面我们来看看操作：

zset有序列表在Java中的封装

（完整代码参考上文string的封装）

// 根据你的需要传入相应的参数
// set方法的主要语句
redisTemplate.opsForZSet(). ;  // .后面的方法根据你的应用场景写入