Spring Boot应用程序集成Redis

SpringBoot集成Redis示例
原创 已于 2024-06-07 11:26:54 修改 · 705 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#spring boot #redis #spring

于 2024-06-07 10:25:30 首次发布

以下是一个Spring Boot应用程序集成Redis的示例，展示了如何存储和查询数据。我们将使用Spring Data Redis模块来实现这个示例。

创建Spring Boot项目

首先，确保你在项目的pom.xml文件中添加了以下依赖：

    <dependencies>
        <!-- Spring Boot Starter Data Redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.3.12.RELEASE</version>
        </dependency>

        <!-- Spring Boot Starter Web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.3.12.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
            <version>2.11.1</version>
        </dependency>
    </dependencies>

配置Redis

在项目的application.yml文件中添加Redis相关的配置：

spring:
  redis:
    database: 0
    # 地址
    host: 127.0.0.1
    # 端口，默认为6379
    port: 6379
    # 密码
    password:
    # 连接超时时间 ms
    timeout: 10000
    lettuce:
      pool:
        # 连接池中的最小空闲连接
        min-idle: 1
        # 连接池中的最大空闲连接
        max-idle: 8
        # 连接池的最大数据库连接数
        max-active: 8
        # #连接池最大阻塞等待时间（使用负值表示没有限制） ms
        max-wait: -1

创建实体类

创建一个简单的实体类：


package com.example.redisdemo.model;

import java.io.Serializable;

public class User implements Serializable {

    private String id;
    private String name;
    private int age;

    // Getters and setters

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

创建配置类

创建一个配置类来定义RedisTemplate：

package com.example.redisdemo.config;


import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.connection.RedisPassword;
import org.springframework.data.redis.connection.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceClientConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.time.Duration;

@Configuration
public class RedisConfig {
    @Value("${spring.redis.database}")
    private int database;

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.password}")
    private String password;

    @Value("${spring.redis.port}")
    private int port;

    @Value("${spring.redis.timeout}")
    private long timeout;

    @Value("${spring.redis.lettuce.pool.max-idle}")
    private int maxIdle;

    @Value("${spring.redis.lettuce.pool.min-idle}")
    private int minIdle;

    @Value("${spring.redis.lettuce.pool.max-active}")
    private int maxActive;

    @Value("${spring.redis.lettuce.pool.max-wait}")
    private long maxWait;

    Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);

    @Bean
    public LettuceConnectionFactory redisConnectionFactory() {
        GenericObjectPoolConfig genericObjectPoolConfig = new GenericObjectPoolConfig();
        genericObjectPoolConfig.setMaxIdle(maxIdle);
        genericObjectPoolConfig.setMinIdle(minIdle);
        genericObjectPoolConfig.setMaxTotal(maxActive);
        genericObjectPoolConfig.setMaxWaitMillis(maxWait);
        genericObjectPoolConfig.setTimeBetweenEvictionRunsMillis(100);
        RedisStandaloneConfiguration redisStandaloneConfiguration = new RedisStandaloneConfiguration();
        redisStandaloneConfiguration.setDatabase(database);
        redisStandaloneConfiguration.setHostName(host);
        redisStandaloneConfiguration.setPort(port);
        redisStandaloneConfiguration.setPassword(RedisPassword.of(password));
        LettuceClientConfiguration clientConfig = LettucePoolingClientConfiguration.builder()
                .commandTimeout(Duration.ofMillis(timeout))
                .poolConfig(genericObjectPoolConfig)
                .build();

        LettuceConnectionFactory factory = new LettuceConnectionFactory(redisStandaloneConfiguration, clientConfig);
        return factory;
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate() {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(redisConnectionFactory());
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
}

创建服务层

创建一个服务层来封装业务逻辑：

package com.example.redisdemo.service;


import com.example.redisdemo.model.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class UserService {

    private static final String USER_KEY_PREFIX = "user:";

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public void saveUser(User user) {
        redisTemplate.opsForValue().set(USER_KEY_PREFIX + user.getId(), user, 10, TimeUnit.MINUTES);
    }

    public User getUser(String id) {
        return (User) redisTemplate.opsForValue().get(USER_KEY_PREFIX + id);
    }

    public void deleteUser(String id) {
        redisTemplate.delete(USER_KEY_PREFIX + id);
    }
}

创建控制器

创建一个控制器来处理HTTP请求：

package com.example.redisdemo.controller;


import com.example.redisdemo.model.User;
import com.example.redisdemo.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/users")
public class UserController {

    @Autowired
    private UserService userService;

    @PostMapping
    public String saveUser(@RequestBody User user) {
        userService.saveUser(user);
        return "User saved successfully!";
    }

    @GetMapping("/{id}")
    public User getUser(@PathVariable String id) {
        return userService.getUser(id);
    }

    @DeleteMapping("/{id}")
    public String deleteUser(@PathVariable String id) {
        userService.deleteUser(id);
        return "User deleted successfully!";
    }
}

Spring Boot 主类

创建Spring Boot应用程序的主类：

package com.example.redisdemo;


import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class RedisDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(RedisDemoApplication.class, args);
    }
}

运行应用程序

启动Spring Boot应用程序，确保Redis服务器正在运行。然后，你可以使用Postman或其他HTTP客户端来测试API：

  • 存储数据：

    POST http://localhost:8080/users 
Body: { "id": "1", "name": "John", "age": 30 }

  • 查询数据：

    GET http://localhost:8080/users/1

  • 删除数据：

    DELETE http://localhost:8080/users/1

解释

  1. 依赖管理：

    • 使用Spring Boot Starter Data Redis来简化Redis集成。
    • 使用Spring Boot Starter Web来简化Web应用开发。

  2. 配置：

    • 在application.yml中指定Redis服务器的地址。

  3. 配置类：

    • 使用 @Configuration 注解定义 RedisTemplate ，设置键和值的序列化方式。

  4. 实体类：

    • 创建一个简单的 User 类来表示存储的数据对象。

  5. 服务层：

    • 封装业务逻辑，提供数据存储和查询的高层接口。

  6. 控制器：

    • 处理HTTP请求，提供RESTful API进行数据存储和查询。

通过这个示例，你可以轻松地使用Spring Boot集成Redis来实现数据的存储和查询功能。

Redis Streams在Spring Boot中的应用：构建可靠的消息队列解决方案【redis实战 二】
todoitbo的博客
12-25 13万+
本文深入探讨了如何利用Spring Boot和Redis Streams构建一个高效、可靠的消息队列系统。从基本概念到高级实现，我们将一步步介绍如何在Spring Boot应用中集成Redis Streams，包括设置环境、消息的发布和订阅、处理消息以及监控和故障处理。通过本文，你将获得宝贵的实践知识，帮助你构建出能够处理高并发、高吞吐量场景的消息队列系统。
【SpringBoot】整合Redis（使用spring-boot-starter-data-redis）
qq_27579471的博客
08-03 1万+
前言 Jedis是Redis官方推荐的面向Java的操作Redis的客户端，而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端，比Jedis多了自动管理连接池的特性，方便与其他Spring框架进行搭配使用如：SpringCache。 Lettuce 和 Jedis 的都是连接Redis Server的客户端程序。Jedis在实现上是直连redis server，多线程环境下非线
一、springboot 集成 spring-boot-starter-data-redis
ray的博客
03-19 1099
文章目录前言一、 springboot 版本二、引入 redis 依赖三、增加配置文件四、增加配置类1、 RedissonConfig2、RedisConfig五、增加操作类，主要操作 string总结 前言 一、 springboot 版本 <spring-boot.version>2.3.5.RELEASE</spring-boot.version> <dependencyManagement> <dependencies&g
SpringBoot整合redis
埃泽漫笔
08-11 313
文件（如果你使用的是 Gradle）中添加 Spring Data Redis 和 Jedis 或 Lettuce 依赖。通过以上配置和实现，您可以构建一个高效、可靠的 Redis 集成方案，满足各种业务场景需求。创建一个配置类来自定义 RedisTemplate 和连接工厂。文件（如果你使用的是 Maven）或。文件中配置 Redis 连接属性。并使用它进行 Redis 操作。可以在你的服务类或控制器中注入。
Spring Boot 整合 Redis 集群详解
weixin_42118323的博客
04-13 6985
分析结果，我们发现出现了一串字符串 “\xac\xed\x00\x05t\x00\x10”，这串字符串明显不是我们想要看到的，难道是 Redis 集成又出问题了吗，使用代码获取了缓存字符串，发现并没有这串奇奇怪怪的字符串，那是怎么回事呢？以上配置，会自动由 Spring Boot 自动装配，不需要再配置类，Spring Boot 会自动把这些配置参数加载后实例化连接池。本篇简单分享了 Spring Boot 项目集成 Redis 过程中可能会需要的一些问题，希望能够帮助到有需要的朋友。
redis实战spring-boot-starter-data-redis
weixin_44383484的博客
08-22 2093
1：默认整合了两种连接池，lettuce 和 jedis ，默认使用 lettuce连接池（因为支持的功能多）2：如果配置了自定义的RedisConnectionFactory ，Spring Boot就不会自动配置 RedisConnectionFactory2：不配置序列化器，我们是无法看懂的1：场景：配置文件中用户，密码是加密的，需要解密后 设置到连接池中。2： 可以发现自定义配置参数会 覆盖配置文件的配置参数1:配置了Jedis连接池后，用的就是Jedis了。
spring-boot-starter-data-redis(spring cloud 操作redis) RedisTemplate
ityqing的博客
03-07 7750
入门: 引入依赖: <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> yml配置文件: ...
spring boot 集成redis代码
10-26
综上所述，Spring Boot集成Redis主要涉及添加依赖、配置连接信息、注入RedisTemplate以及根据业务需求进行操作。通过这种方式，我们可以充分利用Redis的高效特性，为应用程序提供快速的数据访问和缓存功能。在实际...
Spring boot整合分布式缓存RedisSpring-redis-redission.zip
06-07
通过上述步骤，你可以成功地在Spring Boot项目中集成Redis和Redission，实现高效、可靠的分布式缓存方案。记得在实际开发中根据业务需求选择合适的数据结构和功能，以达到最佳性能和可维护性。同时，定期检查和优化...
sample-spring-redis:演示Spring Boot应用程序，显示Spring Data Redis存储库的用法
05-24
Spring Boot是Spring框架的一个扩展，旨在简化Spring应用程序的创建和配置过程，而Spring Data Redis则提供了与Redis内存数据存储的无缝集成。 **Redis基础** Redis是一个高性能的键值存储系统，常用于缓存、消息...
Spring Boot集成Redis（基于Jedis）
最新发布
10-06
因此生成的项目目录是这样的项目【SpringBoot集成Redis (使用Jedis实现)】在Spring Boot应用中集成Redis是一个常见的需求，因为Redis作为一个高性能的键值数据库，常用于缓存、消息队列等多种场景。本篇文章将介绍...
SpringBoot揭密：spring-boot-starter-data-redis
zhangweiocp的专栏
12-04 1万+
一. POM解析 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter</artifactId> <version>2.0.0.RELEASE</version> <scope>comp
springboot集成redis -- spring-boot-starter-data-redis
喜欢分享,善于记录工作中遇到的问题,和自己的思考
11-09 1417
当前环境 springboot版本 2.7.17。
springboot 整合 redis
不懂一休
06-30 1万+
文章目录jedis导入依赖 视频链接 官网：https://redis.io/ 中文官网：http://redis.cn/ jedis java 操作 jedis ,jedis 是 redis 官方推荐的 java 连接开发工具！使用 Java 操作 redis 中间件 导入依赖 新建 maven 项目，导入 jedis 依赖 <dependencies> <dependency> <groupId>redis.client
SpringBoot集成Redis
qq_48508157的博客
09-20 1272
如果我们存储的是对象，默认使用的是 JdkSerializationRedisSerializer，也就是Jdk的序列化方式（通过ObjectOutputStream和ObjectInputStream实现，缺点是我们无法直观看到存储的对象内容）。redis的序列化也是我们在使用RedisTemplate的过程中需要注意的事情。我们的配置工作准备就绪以后，我们就可以在项目中操作redis了，操作的话，使用spring-data-redis中为我们提供的 RedisTemplate 这个类，就可以操作了。
spring-boot-starter-data-redis介绍
weixin_41786712的博客
07-11 6898
spring-boot-starter-data-redis
【未完成】Redis（四）Spring Boot 整合 spring-boot-starter-data-redis
fox_bert的博客
11-20 3239
一、spring-boot-starter-data-redis提供的功能 1、连接池自动管理，提供了一个高度封装的“RedisTemplate”类 2、针对jedis客户端中大量api进行了归类封装,将同一类型操作封装为operation接口 ValueOperations：简单K-V操作 HashOperations：针对map类型的数据操作 ListOperations：针对lis...
【Spring Boot组件集成实战】集成Redis数据库
拾年之璐
10-20 588
1. Redis的产生原因 一个技术的出现，必然有它的道理。 大数据时代的当前，每天都在处理海量、多样的数据，而且这些数据，需要实时处理。互联网应用必须保证高并发、高可用、高性能，才能满足这些需求。 我们都知道，CPU的运行速度比内存快一百多倍，比硬盘快几百万倍。 传统的关系型数据库，如MySQL，其将数据保存至硬盘。而高并发场景下，限制数据库性能的瓶颈，主要在于硬盘。 所以，在某些需要存储大量Web应用数据，并且需要对这些应用数据进行高并发的读写的场景下，关系型数据集并不能满足我们的需求。 在这样的背景下
Spring Boot 整合Redis （一） spring-boot-starter-data-redis
热门推荐
一生一世一双人的博客
04-16 4万+
使用lettuce连接池 1.maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> &l...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值