Spring Boot：使用Redis存储技术

最新推荐文章于 2022-11-04 16:09:14 发布
最新推荐文章于 2022-11-04 16:09:14 发布
阅读量354 收藏
点赞数 1
分类专栏： Spring Boot 文章标签： Spring Boot redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xifengxiaoma/article/details/94553144
版权

综合概述

Redis是一个开源免费的高性能key-value数据库，读取速度达110000次/s,写入速度达81000次/s。Redis支持丰富的数据类型，如Lists, Hashes, Sets 及 Ordered Sets 数据类型。Redis的所有操作都是原子性的，要么成功执行要么失败完全不执行。另外还可以通过MULTI和EXEC指令包起来支持事务。此外，Redis还具备丰富的特性 ，比如支持发布/订阅（publish/subscribe）模式,可以充当简单的消息中间件，还支持通知, key过期设置主从复制等等特性。

Redis主要以下三个特点：

1.支持数据的持久化，可以将内存中的数据保存在磁盘中，重启的时候可以再次加载进行使用。

2.支持丰富的数据类型，除了支持简单的key-value类型，同时还提供list，set，zset，hash等数据结构的存储。

3.支持数据的备份，即主从（master-slave）模式模式的数据备份。

接下来，我们就用一个简单的案例来说明在Spring Boot中如何使用Redis技术。

实现案例

首先，需要安装Redis，教程很多，这里不再赘述。可以参考：Redis安装教程。

生成项目模板

为方便我们初始化项目，Spring Boot给我们提供一个项目模板生成网站。

1.  打开浏览器，访问：https://start.spring.io/

2.  根据页面提示，选择构建工具，开发语言，项目信息等。

3.  点击 Generate the project，生成项目模板，生成之后会将压缩包下载到本地。

4.  使用IDE导入项目，我这里使用Eclipse，通过导入Maven项目的方式导入。

添加相关依赖

清理掉不需要的测试类及测试依赖，添加 Redis相关依赖。

<!-- spring boot redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- lettuce pool -->
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-pool2</artifactId>
</dependency>

Spring Boot框架中已经集成了redis，在1.x.x的版本中默认使用jedis客户端，而在2.x.x版本中默认使用的lettuce客户端。

两种客户端的区别如下：

  • Jedis和Lettuce都是Redis Client
  • Jedis 是直连模式，在多个线程间共享一个 Jedis 实例时是线程不安全的，
  • 如果想要在多线程环境下使用 Jedis，需要使用连接池，
  • 每个线程都去拿自己的 Jedis 实例，当连接数量增多时，物理连接成本就较高了。
  • Lettuce的连接是基于Netty的，连接实例可以在多个线程间共享，
  • 所以，一个多线程的应用可以使用同一个连接实例，而不用担心并发线程的数量。
  • 当然这个也是可伸缩的设计，一个连接实例不够的情况也可以按需增加连接实例。
  • 通过异步的方式可以让我们更好的利用系统资源，而不用浪费线程等待网络或磁盘I/O。
  • Lettuce 是基于 netty 的，netty 是一个多线程、事件驱动的 I/O 框架，
  • 所以 Lettuce 可以帮助我们充分利用异步的优势。

我的项目是使用的是Spring Boot 2.1.5.RELEASE，所以采用lettuce来进行配置。

pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.5.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.louis.springboot</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- web -->
        <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
         </dependency>
        <!-- swagger -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!-- spring boot redis -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- lettuce pool -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

添加相关配置

1.添加swagger 配置

添加一个swagger 配置类，在工程下新建 config 包并添加一个 SwaggerConfig 配置类。

SwaggerConfig.java

package com.louis.springboot.demo.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.builders.PathSelectors;
import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket createRestApi(){
        return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo())
                .select()
                .apis(RequestHandlerSelectors.any())
                .paths(PathSelectors.any()).build();
    }

    private ApiInfo apiInfo(){
        return new ApiInfoBuilder()
                .title("Swagger API Doc")
                .description("This is a restful api document of Swagger.")
                .version("1.0")
                .build();
    }

}

2.修改application.properties文件名为application.yml，在其中添加Redis配置信息。

application.yml

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

3.添加一个Redis配置类，使用@EnableCaching注解来开启缓存。

RedisConfig.java

package com.louis.springboot.demo.config;

import java.lang.reflect.Method;

import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport{
    
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }
}

编写业务逻辑

编写一个简单的用户实体类，包含用户名和密码。

User.java

package com.louis.springboot.demo.model;

import java.io.Serializable;

public class User implements Serializable {

    private static final long serialVersionUID = 1L;
    
    private String username;
    private String password;
    
    public User(String username, String password) {
        super();
        this.username = username;
        this.password = password;
    }
    
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    
    @Override
    public String toString() {
        return "{username:" + getUsername() + ", password:" +getPassword() + "}";
    }
}

编写一个业务控制器，分别编写测试字符串和对象的存取接口，另外还通过@Cacheable(value="user-key")注解给方法开启缓存，这样就可以缓存方法返回的结果，只有当缓存不存在的时候采用执行方法返回新的用户对象。

RedisController.java

package com.louis.springboot.demo.controller;

import java.util.concurrent.TimeUnit;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import com.louis.springboot.demo.model.User;

@RestController
public class RedisController {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Autowired
    private RedisTemplate redisTemplate;

    @GetMapping("/testString")
    public String testString()  {
        stringRedisTemplate.opsForValue().set("name", "louis");
        String name = stringRedisTemplate.opsForValue().get("name");
        return "the value of key 'name' is : " + name ;
    }
    
    @GetMapping("/testObject")
    public String testObject()  {
        StringBuilder result = new StringBuilder();
        User user = new User("louis", "123");
        ValueOperations<String, User> operations = redisTemplate.opsForValue();
        operations.set("sys.user", user);
        operations.set("sys.user.timeout", user, 1, TimeUnit.SECONDS);    // 设置1秒后过期
        result.append("过期前：").append("\n");
        result.append("sys.user=" + operations.get("sys.user")).append("\n");
        result.append("sys.user.timeout=" + operations.get("sys.user.timeout"));
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        result.append("\n").append("过期后：").append("\n");
        result.append("sys.user=" + operations.get("sys.user")).append("\n");
        result.append("sys.user.timeout=" + operations.get("sys.user.timeout"));
        return result.toString();
    }
    
    @GetMapping("/getUser")
    @Cacheable(value="user-key")
    public User getUser() {
        User user = new User("louis", "123");
        System.out.println("用户对象缓存不存在，返回一个新的用户对象。");
        return user;
    }
}

编译运行测试

1.  右键项目 -> Run as -> Maven install，开始执行Maven构建，第一次会下载Maven依赖，可能需要点时间，如果出现如下信息，就说明项目编译打包成功了。

 

2.  右键文件 DemoApplication.java -> Run as -> Java Application，开始启动应用，当出现如下信息的时候，就说明应用启动成功了，默认启动端口是8080。

 

3.  打开浏览器，访问：http://localhost:8080/swagger-ui.html，进入swagger接口文档界面。

4.调用testString接口，如果能出现如下图所示结果就说明成功了。

5.调用testObject接口，如果能出现如下图所示结果就说明成功了。

6.调用getUser接口，此时因为是第一次调用此方法，所以没有key值为“user-key”的缓存，所以会执行方法并将返回结果进行缓存。在执行getUser方法的时候控制台输出了我们添加的提示信息如下。

用户对象缓存不存在，返回一个新的用户对象。

7.然后再次调用getUser接口，发现getUser没有再次被执行，控制台也没有输出上一步的提示信息，那是因为在方法调用之前，应用从key值为“user-key”的缓存中获取成功，所以并不需要继续执行getUser方法的内容了。

 

参考资料

官方网站：https://redis.io/documentation

百度百科：https://baike.baidu.com/item/Redis/6549233?fr=aladdin

菜鸟教程：https://www.runoob.com/redis/redis-tutorial.html

相关导航

Spring Boot 系列教程目录导航

Spring Boot：快速入门教程

Spring Boot：整合Swagger文档

Spring Boot：整合MyBatis框架

Spring Boot：实现MyBatis分页

源码下载

码云：https://gitee.com/liuge1988/spring-boot-demo.git

作者：朝雨忆轻尘
出处：https://www.cnblogs.com/xifengxiaoma/ 
版权所有，欢迎转载，转载请注明原文作者及出处。

朝雨忆轻尘
关注
专栏目录
Springboot结合Redis开发
XLBoy的博客
05-04 158
Redis 是一种键值数据库，而且以字符串类型为中心，当前它能够支持多种数据类型，包括字符串、散列 列表（链表）、集合、有序集合、基数和地理位置等。 从图中可以看出RedisConnection接口操作Redis的，而RedisConnection则对原生Jedis进行封装。要获取RedisConnection接口对象，是通过RedisConnectFactory接口生成的。 RedisConn...
Spring Boot 整合：Redis 延时队列的实现方案（基于有赞的设计）
最新发布
2401_84091580的博客
05-03 1060
一般像这样的大企业都有好几轮面试，所以自己一定要花点时间去收集整理一下公司的背景，公司的企业文化，俗话说「知己知彼百战不殆」，不要盲目的去面试，还有很多人关心怎么去跟HR谈薪资。这边给大家一个建议，如果你的理想薪资是30K，你完全可以跟HR谈33~35K，而不是一下子就把自己的底牌暴露了出来，不过肯定不能说的这么直接，比如原来你的公司是25K，你可以跟HR讲原来的薪资是多少，你们这边能给到我的是多少？你说我这边希望可以有一个20%涨薪。
Spring Boot中使用Redis
shaopengjie的博客
08-23 9422
1.Redis是基于内存的key-value结构数据库优点：基于内存存储，读写性能高适合存储热点数据（短时间被被大量用户读取的数据）2.NoSQL,泛指非关系型数据库，是关系型数据库的补充3.Redis应用场景：缓存，任务队列，消息队列，分布式锁,下载的redis是源文件，需要进行编译安装，Windows版本百度即可5.Linux下安装Redis安装过程中如果报错：You need tcl x.x or newer in order to run the Redis test。
redis各种类型的存储情况分析
张波的技术积累
01-22 1万+
1：SORT命令的时间复杂度是0(n+mlogm)，其中n表示要排序的列表（集合或有序集合）中的元素个数，m表示要返回的元素个数    所以开发中使用SORT命令时需要注意以下几点。 （1）尽可能减少待排序键中元素的数量（使n尽可能小）。 （2）使用LIMIT参数只获取需要的数据（使m尽可能小）。 （3）如果要排序的数据数量较大，尽可能使用STORE参数将结果缓存 2： 任务队列
springboot+redis+token保持登录
08-03
通过redis 设置session过期时间，实现token 登录机制
Spring Boot中使用Redis做缓存的方法实例
08-30
Spring Boot 中使用 Redis 做缓存的方法实例 在本文中，我们将详细介绍如何在 Spring Boot 中使用 Redis 做缓存。缓存是一种非常重要的技术，可以极大地提高应用程序的性能。Redis 是一个非常流行的 Nosql 数据库，...
Spring Boot项目利用Redis实现集中式缓存实例
08-30
* 提高可扩展性：使用Redis作为缓存存储介质，我们可以轻松地水平扩展系统，提高系统的可扩展性。 * 提高可用性：使用Redis作为缓存存储介质，我们可以实现高可用性的系统，减少系统宕机的可能性。 7. 结论 Spring...
Spring Boot 2.5 实战 Redis 分布式 缓存 6.0
天空鸟的博客
11-04 2101
跟之前差不多，get by ID ， add user for 循环，构造 100 个用户，插入 list，后面。之前差不多，get by ID ， add user for 循环，构造 100 个用户，插入 list，后面。了抽象，本质上 Java 连 Redis 有基础 Redis 的驱动，使用基础的网络链接和 Redis 服。重要的 Java 驱动、工具驱动库，有 Redis 的链接池，使用的是比较有名的 Java 社群。Java 链接远程 Redis，Redis 服务器端要允许远程。
SpringBoot整合Redis缓存
凉茶铺的博客
07-15 4776
7）基于注解的Redis缓存更新测试。先通过浏览器访问“http//localhost8080/updateComment/1/shitou”更新id为1的评论作者名为shitou；接着，继续访问“http//localhost8080/findCommentById?id=1”查询id为1的用户评论信息可以看出，执行updateComment()方法更新id为1的数据时执行了一条更新SQL语句，后续调用findById()方法查询id为1的用户评论信息时没有执行查询SQL语句，且浏览器正确返回。.....
在Spring中使用Redis
unber的博客
09-09 4524
在教程《在Java程序中使用Redis》中介绍了在没有封装情况下使用 Java API 的缺点，需要自己编写规则把 Java 对象和 Redis 的字符串进行相互转换，而在 Spring 中这些问题都可以轻松处理。
【SpringBoot整合缓存】-----spring-boot-starter-cache篇
Learning_xzj的博客
06-28 8235
缓存在企业级应用主要作用是信息处理，当需要读取数据时，由于受限于数据库的访问效率，导致整体系统性能偏低。 ​ 应用程序直接与数据库打交道，访问效率低​ 为了改善上述现象，开发者通常会在应用程序与数据库之间建立一种临时的数据存储机制，该区域中的数据在内存中保存，读写速度较快，可以有效解决数据库访问效率低下的问题。这一块临时存储数据的区域就是缓存。使用缓存后，应用程序与缓存打交道，缓存与数据库打交道，数据访问效率提高。​ 缓存是什么？缓存是一种介于数据永久存储
list操作 rediscluster_SpringBoot 结合 Spring Cache 操作 Redis 实现数据缓存
weixin_30013175的博客
01-05 423
系统环境：Redis 版本：5.0.7SpringBoot 版本：2.2.2.RELEASE参考地址：Redus 官方网址：https://redis.io/博文示例项目 Github 地址：https://github.com/my-dlq/blog-example/tree/master/springboot/springboot-redis-cache-example一、缓存概念知识1、是什...
spring集成redis
jjkang的博客
01-05 1533
spring集成redisredis的安装redis的常用配置使用配置文件的方式启动停止redis服务redis的配置信息redis与spring整合的配置文件RedisCacheManagerpom.xml redis的安装 将redis的安装包解压到/usr/local下 sudo make，生成 sudo make install，将redis的命令安装到/usr/bin/目录 redi...
[redis]spring整合redis
weixin_43303530的博客
09-10 1931
两种：spring整合redis，springboot整合redis spring整合redis： 1、环境及jar包： 环境：jdk1.6；spring+springmvc+ibatis+maven；redis3.2； pom.xml： <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId&gt.
springboot整合redis
小鲍侃java
09-26 4856
redis简介 redis是一个支持key-value的数据库，数据全部在内存中处理，在在一定时间间隔中将数据固化到磁盘。因为是内存操作，所以速度特别快。（这里我们主要介绍redis作为缓存使用） 总结一下他有以下特点： 1.速度快，Redis能读的速度是110000次/s,写的速度是81000次/s 。 2.能够存储String,hash,set,map,zset(有序集合)。且单个value的...
java操作springboot与redis存对象过程
热门推荐
sanding的博客
07-08 1万+
问题一：当执行如下测试代码的时候：报错：原因：解决：移除redis.clients问题二：当直接存对象的时候，设置信息如下。报错：也就是当存对象的时候，默认必须要实现序列化。放开注释部分：不报错。但是，redis的可视化工具显示如下：原因：修改实体为实现序列化：结果：取：取的结果：反序化可行。序列化与反序列化，对象流和字节数组流操作。对象的深拷贝，多例。也是这样的。StringRedisTempl...
SpringBoot整合Redis来存储对象
amadeus_liu2的博客
04-19 484
1.配置文件 spring.redis.host=localhost spring.redis.port=6379 spring.redis.password=123456 spring.redis.timeout=1000 2配置类 package org.fkit.hellotest; import org.springframework.context.annotation.Bean; i...
Spring Boot高效整合Redis：配置与实战
本文档详细介绍了如何在Spring Boot项目中集成和使用Redis作为缓存技术，以提高系统性能。首先，我们了解到在实际开发中，为了提升响应速度，通过缓存存储用户频繁访问的数据至关重要。Redis被选作缓存是因为其快速...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

朝雨忆轻尘

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值