【Java】SpringBoot快速整合Redis

本文介绍: SpringBoot快速整合Redis，测试从数据查询和从redis缓存中查询的效率差别。

文末有源码gitee地址

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

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

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

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

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

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

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

// 存储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类型数据
redisTemplate.opsForList().rightPushAll("tasks", "task1", "task2");

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

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

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

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

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

// 存储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

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

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

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;
    }

}