【Java】SpringBoot快速整合Redis

什么是Redis？

        文末有源码gitee地址

        【面试】浅学Redis_redis 广播-CSDN博客

        Redis是一种高性能开源的基于内存的，采用键值对存储的非关系型数据库，它支持多种数据结构，包括字符串、哈希表、列表、集合、有序集合等。Redis的特点之一是数据存储在内存中，因此读写速度非常快。

以下是Redis的一些主要特点和作用：

1. 高性能： Redis的数据存储在内存中，读写速度非常快，这使得它成为处理大量请求的理想选择。

2. 数据结构丰富： Redis支持多种数据结构，包括字符串、哈希表、列表、集合、有序集合等。这使得它可以应用于各种不同的场景，如缓存、消息队列、计数器等。

3. 持久化： Redis可以通过将数据写入磁盘来实现持久化，以防止数据丢失。它支持两种持久化方式：RDB（快照）和AOF（日志文件）。

4. 分布式： Redis支持分布式架构，可以将数据分布在多个节点上，提高系统的扩展性和容错性。

5. 缓存： 作为缓存系统，Redis可以用于存储频繁访问的数据，以减轻数据库负载，提高访问速度。

6. 消息队列： Redis的发布/订阅机制可以用作简单的消息队列，用于解耦系统的各个组件。

7. 计数器： Redis的原子操作和高速性使其成为实现计数器功能的理想选择，例如网站的访问计数器。

8. 事务支持： Redis支持事务，可以将多个命令包装在一个事务中，保证这些命令要么全部执行成功，要么全部失败。

Redis的5种数据存储结构和使用场景

存储结构包含：String字符串，List列表，Set集合，ZSet有序集合，Hash哈希。

    String（字符串）：
        适用场景：存储简单的键值对数据，如配置信息、计数器等。
        示例应用：缓存系统配置、用户token、简单计数器。

    Hash（哈希表）：
        适用场景：存储对象的多个字段，方便获取和更新特定字段。
        示例应用：用户信息存储、对象属性存储。

    List（列表）：
        适用场景：存储有序的元素列表，支持在两端进行元素的插入和删除。
        示例应用：消息队列、任务队列、实时消息推送。

    Set（集合）：
        适用场景：存储不重复的元素集合，支持集合运算（交集、并集、差集）。
        示例应用：用户标签、共同关注的好友、无序集合数据。

    ZSet（有序集合）：
        适用场景：类似Set，但每个元素都关联一个分数，用于支持元素的有序排列。
        示例应用：排行榜、按权重排序的任务队列。

如何使用呢？

String（字符串）：

// 存储String类型数据
redisTemplate.opsForValue().set("greeting", "Hello, Redis!");

// 读取String类型数据
String value = (String) redisTemplate.opsForValue().get("greeting");

System.out.println(value);  // 输出: Hello, Redis!

Hash（哈希表）：

// 存储Hash类型数据
redisTemplate.opsForHash().put("userDetails", "userId", "123");
redisTemplate.opsForHash().put("userDetails", "userName", "John Doe");

// 读取Hash类型数据
String userId = (String) redisTemplate.opsForHash().get("userDetails", "userId");
String userName = (String) redisTemplate.opsForHash().get("userDetails", "userName");

System.out.println(userId);  // 输出: 123
System.out.println(userName);  // 输出: John Doe

List（列表）：

// 存储List类型数据
redisTemplate.opsForList().rightPushAll("tasks", "task1", "task2");

// 读取List类型数据
List<String> tasks = redisTemplate.opsForList().range("tasks", 0, -1);

System.out.println(tasks);  // 输出: [task1, task2]

Set（集合）：

// 存储Set类型数据
redisTemplate.opsForSet().add("uniqueUsers", "user1", "user2", "user3");

// 读取Set类型数据
Set<String> uniqueUsers = redisTemplate.opsForSet().members("uniqueUsers");

System.out.println(uniqueUsers);  // 输出: [user1, user2, user3]

ZSet（有序集合）：

// 存储ZSet类型数据
redisTemplate.opsForZSet().add("topScores", "player1", 100.0);
redisTemplate.opsForZSet().add("topScores", "player2", 150.0);

// 读取ZSet类型数据（按分数从小到大排序）
Set<ZSetOperations.TypedTuple<Object>> topScores = redisTemplate.opsForZSet().rangeWithScores("topScores", 0, -1);

for (ZSetOperations.TypedTuple<Object> tuple : topScores) {
    System.out.println(tuple.getValue() + " - " + tuple.getScore());
}
// 输出:
// player1 - 100.0
// player2 - 150.0

SpringBoot整合ElasticSearch的步骤：

1.代码层级结构

1. 添加依赖

在pom.xml中添加redis的依赖：

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

2. 配置redis连接信息

在application.properties或(application.yml)中配置redis连接信息，如下：

spring:
  data:
    redis:
      port: 6379
      username:
      password:
      host: 127.0.0.1

3.在业务层进行注入RedisTemplate

package com.example.springbootredis.service.impl;

import com.example.springbootredis.domain.Courses;
import com.example.springbootredis.mapper.CoursesMapper;
import com.example.springbootredis.service.CoursesService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.Arrays;
import java.util.List;

@Service
@Slf4j
public class CoursesServiceImpl implements CoursesService {


    @Autowired
    private RedisTemplate redisTemplate;


    @Autowired
    private CoursesMapper coursesMapper;

    @Override
    public List<Courses> findAll() throws JsonProcessingException {
        // 从Redis缓存中进行获取
        String cachedSalaries = (String) redisTemplate.opsForValue().get("Salaries");
        if (cachedSalaries != null) {
            // 如果有直接进行返回
            log.info("从缓存中获取");
            return Arrays.asList(new ObjectMapper().readValue(cachedSalaries, Courses[].class));
        }

        // 如果redis缓存中没有，从数据库中进行查询，然后同步到缓存中
        List<Courses> courses = coursesMapper.findAll();
        if (!courses.isEmpty()) {
            // 同步到Redis缓存当中
            log.info("从数据库中获取，并同步到缓存当中");
            redisTemplate.opsForValue().set("Salaries", new ObjectMapper().writeValueAsString(courses));
            return courses;
        }

        return null;
    }

}

上述只给出了Redis相关部分的代码，如果想进行测试，直接拉去gitee代码，然后在数据库中执行courses对应的sql，还有修改数据库用户名和密码即可测试。

测试结果：

 测试从数据查询和从redis缓存中查询的效率差别。

gitee下载地址：https://gitee.com/sophisticatedxin/springboot-redis.git