中间件：SpringBoot集成Redis

[1.1 Redis简介](#1.1 Redis简介)

[1.1.1 基本信息](#1.1.1 基本信息)

[1.1.2 数据结构](#1.1.2 数据结构)

[1.1.3 优势](#1.1.3 优势)

[1.2 Redis基本使用](#1.2 Redis基本使用)

[1.2.1 Windows安装](#1.2.1 Windows安装)

[1.2.2 配置](#1.2.2 配置)

[1.2.3 启动](#1.2.3 启动)

[1.2.4 连接](#1.2.4 连接)

编辑

[1.2.5 基本操作](#1.2.5 基本操作)

[1.3 Jedis操作Redis](#1.3 Jedis操作Redis)

[1.3.1 基本操作](#1.3.1 基本操作)

[1.3.2 连接池](#1.3.2 连接池)

[1.4 SpringBoot操作Redis](#1.4 SpringBoot操作Redis)

[1.4.1 基本操作](#1.4.1 基本操作)

中间件是互联网公司支撑高并发业务的必备组件。中间件在分布式架构设计中发挥着至关重要的作用，它能够为应用程序提供各种服务，如数据访问、消息传递、事务处理等。在高并发场景下，中间件能够提升系统性能、保证数据一致性、实现异步通信等功能，是构建稳定、高效、可扩展的互联网业务系统的关键。因此，中间件是互联网公司不可或缺的技术支撑。

1.1 Redis简介

Redis是一个高性能的key-value数据库，以下是对其的详细介绍：

1.1.1 基本信息

全称：Remote Dictionary Server（远程字典服务器），简称Redis。
开发语言：使用ANSI C语言编写。
特点：支持网络、可基于内存亦可持久化、日志型、Key-Value数据库，提供多种语言的API。

1.1.2 数据结构

Redis支持丰富的数据类型，包括但不限于：

String（字符串）：可以存储图片或者序列化的对象，值最大存储为512M。
Hash（哈希）：值本身又是一个键值对（k-v）结构。
List（列表）：用来存储多个有序的字符串，一个列表最多可以存储2^32-1个元素。
Set（集合）：用来保存多个的字符串元素，但是不允许重复元素。
zset（有序集合）：已排序的字符串集合，同时元素不能重复。

此外，Redis还提供了Geospatial、Hyperloglog、Bitmap等特殊的数据结构类型。

1.1.3 优势

基于内存存储：Redis是基于内存存储实现的数据库，相对于数据存在磁盘的数据库（如MySQL），省去了磁盘I/O的消耗。
数据结构丰富：Redis支持多种数据类型，使得它能够满足各种不同的应用场景需求。
高性能：Redis的高性能使得它能够处理高并发的读写操作，保证系统的稳定性和响应速度。

1.2 Redis基本使用

1.2.1 Windows安装

Redis安装地址

Redis支持32位和64位，这个需要根据你的系统平台实际情况选择

1.2.2 配置

安装后，再不配置Redis的情况下，Redis也可以直接启动，因为有一个默认配置文件。在官方发布的版本中一般叫做redis.conf，而在本教程中使用的是windows编译的版本，配置文件改名为叫做redis.windows.conf。这个文件中包含了Redis各方面的配置。

配置：

// 绑定的主机
bind 127.0.0.1

// 端口号
port 6379

// 请求密码，默认是注释的
requirepass 123456

1.2.3 启动

1.2.4 连接

注意：密码为刚刚配置的redis.windows.conf文件中的requirepass

1.2.5 基本操作

使用set、get命令进行数据的简单的读和写

1.3 Jedis操作Redis

Jedis是一个用于Java的Redis客户端库，它提供了一组API，使得Java开发者能够方便地与Redis数据库进行交互，执行Redis命令，并操作Redis数据结构。

1.3.1 基本操作

1.添加jedis依赖

javascript 复制代码

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

2.编写junit单元测试JedisTester

java 复制代码

public class JedisTester {
    private Jedis jedis;

    @BeforeEach
    public void setup(){
        jedis = new Jedis("127.0.0.1", 6379);
        // 密码
        jedis.auth("123456");
    }
}

操作字符串

java 复制代码

    @Test
    public void testString(){
        jedis.set("name", "lqw");
        String name = jedis.get("name");
        System.out.println(name);

        jedis.append("name","czkt");
        System.out.println(jedis.get("name"));

        jedis.del("name");
        System.out.println(jedis.get("name"));

        // 设置多个健值对
        jedis.mset("name","lqw","age","25","add","郴州");
        jedis.incr("age");
        System.out.println(jedis.get("name") + "-" + jedis.get("age") + "-" + jedis.get("add"));
    }

1.3.2 连接池

java 复制代码

public final class RedisPool {
    // Redis服务器IP
    private static String ADDR = "127.0.0.1";

    // Redis的端口号
    private static int PORT = 6379;

    // 访问密码
    private static String AUTH = "luoqiangwu";

    // 可用连接实例的最大数目，默认值为8；
    // 如果赋值为-1，则表示不限制；如果pool已经分配了maxActive个jedis实例，则此时pool的状态为exhausted(耗尽)。
    private static int MAX_ACTIVE = 1024;

    // 控制一个pool最多有多少个状态为idle(空闲的)的jedis实例，默认值也是8。
    private static int MAX_IDLE = 200;

    // 等待可用连接的最大时间，单位毫秒，默认值为-1，表示永不超时。如果超过等待时间，则直接抛出JedisConnectionException；
    private static int MAX_WAIT = 10000;
    private static int TIMEOUT = 10000;
    // 在borrow一个jedis实例时，是否提前进行validate操作；如果为true，则得到的jedis实例均是可用的；
    private static boolean TEST_ON_BORROW = true;
    private static JedisPool jedisPool = null;

    /**
     * 初始化Redis连接池
     */
    static {
        try {
            // 创建一个JedisPoolConfig实例
            JedisPoolConfig config = new JedisPoolConfig();
            // 设置连接池的最大总连接数
            config.setMaxTotal(MAX_ACTIVE);
            // 设置连接池的最大空闲连接数
            config.setMaxIdle( MAX_IDLE);
            // 设置连接池的最大等待时间
            config.setMaxWaitMillis(MAX_WAIT);
            // 设置是否在从池中获取连接前进行检验
            config.setTestOnBorrow(TEST_ON_BORROW);
            // 使用配置好的config对象创建Jedis连接池
            jedisPool = new JedisPool(config, ADDR, PORT, TIMEOUT, AUTH);
        } catch (Exception e) {
            // 打印异常堆栈跟踪
            e.printStackTrace();
        }
    }

    /**
     * 获取Jedis实例
     *
     * @return
     */
    public synchronized static Jedis getJedis(){
        try {
            if (jedisPool!= null){
                return jedisPool.getResource();
            }else {
                return null;
            }
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 释放Jedis资源
     *
     * @param jedis
     */
    public static void returnResource(final Jedis jedis){
        if (jedis!=null){
            jedisPool.returnResource(jedis);
        }
    }
}

工具类

java 复制代码

public class RedisUtil {

    /**
     * 设置key的有效时间，单位是秒
     *
     * @param key
     * @param exTime
     * @return
     */
    public static Long expire(String key, int exTime) {
        // 创建 Jedis 对象，用于执行 Redis 操作
        Jedis jedis = null;
        // 定义一个变量 result，用来存储操作结果，默认为 null
        Long result = null;
        try {
            // 从连接池中获取一个 Jedis 实例
            jedis = RedisPool.getJedis();
            // 设置 key 的过期时间为 exTime 秒
            result = jedis.expire(key, exTime);
        } catch (Exception e) {
            // 打印异常堆栈跟踪
            e.printStackTrace();
        } finally {
            // 释放 Redis 连接资源
            RedisPool.returnResource(jedis);
        }
        // 返回过期时间设置操作的结果
        return result;
    }

    // exTime单位是秒
    // 设置key-value并设置过期时间
    public static String setEx(String key, String value, int exTime) {
        Jedis jedis = null;
        String result = null;
        try {
            // 从Redis连接池中获取一个Jedis对象
            jedis = RedisPool.getJedis();
            result = jedis.setex(key, exTime, value);
        } catch (Exception e) {
            e.printStackTrace();
            return result;
        } finally {
            RedisPool.returnResource(jedis);
        }
        return result;
    }

    public static String set(String key, String value) {
        Jedis jedis = null;
        String result = null;
        try {
            jedis = RedisPool.getJedis();
            result = jedis.set(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return result;
        } finally {
            RedisPool.returnResource(jedis);
        }
        return result;
    }

    public static String get(String key) {
        Jedis jedis = null;
        String result = null;
        try {
            jedis = RedisPool.getJedis();
            result = jedis.get(key);
        } catch (Exception e) {
            e.printStackTrace();
            return result;
        } finally {
            RedisPool.returnResource(jedis);
        }
        return result;
    }

    public static Long del(String key) {
        Jedis jedis = null;
        Long result = null;
        try {
            jedis = RedisPool.getJedis();
            result = jedis.del(key);
        } catch (Exception e) {
            e.printStackTrace();
            return result;
        } finally {
            RedisPool.returnResource(jedis);
        }
        return result;
    }


}

1.4 SpringBoot操作Redis

1.4.1 基本操作

1.添加依赖

javascript 复制代码

        <!-- 引入SpringBoot对Redis的支持 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- 引入SpringBoot对Redis的支持 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

2.application.yml 配置相关信息

bash 复制代码

spring:
  data:
    #Redis配置
    redis:
      # Redis 数据库索引，默认为 0
      database: 0
      # Redis 服务器主机地址，默认为 localhost
      host: localhost
      # Redis 服务器端口号，默认为 6379
      port: 6379
      # Redis 服务器密码
      password: luoqiangwu
      # Redis 的 lettuce 客户端连接池配置
      lettuce:
        pool:
          # 连接池最大活动连接数，默认为 8
          max-active: 8
          # 连接池最大阻塞等待时间，-1 表示无限等待
          max-wait: -1
          # 连接池中的最大空闲连接数，默认为 8
          max-idle: 8
          # 连接池中最小空闲连接数，默认为 0
          min-idle: 0

3.测试使用

java 复制代码

@SpringBootTest
public class RedisTemplateTester {

    @Resource
    private StringRedisTemplate stringRedisTemplate; // 操作字符串数据

    @Resource
    private RedisTemplate redisTemplate; // 操作其他数据类型

    @Test
    public void testString() {
        stringRedisTemplate.opsForValue().set("name", "lqw");
        Assert.assertEquals("lqw", stringRedisTemplate.opsForValue().get("name"));
    }
}