SpringBoot集成Redis并使用Knife4j测试

基于若依的ruoyi-vue前后端分离版本，若依官网：http://www.ruoyi.vip/

项目目录结构

项目的目录结构如下：

1.新建maven项目

我们此处以ideal为例，打开ideal，新建一个maven项目，我们此处点击next

输入项目信息，点击finish

2.导入依赖

我们在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.4.3</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>org.example</groupId><artifactId>springboot-redis</artifactId><version>1.0-SNAPSHOT</version><properties><!-- 自定义redis版本 --><!-- <redis.version>2.4.3</redis.version>--></properties><dependencies><!-- redis --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId><!-- <version>${redis.version}</version> --></dependency><!-- 整合redis需要配合 commons-pool2 对象池依赖 --><dependency><groupId>org.apache.commons</groupId><artifactId>commons-pool2</artifactId></dependency><!-- web依赖 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><!-- fastJson --><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId><version>1.2.70</version></dependency><!-- knife4j --><dependency><groupId>com.github.xiaoymin</groupId><artifactId>knife4j-spring-boot-starter</artifactId><version>2.0.8</version></dependency></dependencies></project>

knife4j介绍

knife4j是为Java MVC框架集成Swagger生成Api文档的增强解决方案，前身是swagger-bootstrap-ui，取名kni4j是希望她能像一把匕首一样小巧、轻量、并且功能强悍!

knife4j的前身是swagger-bootstrap-ui，为了契合微服务的架构发展，由于原来swagger-bootstrap-ui采用的是后端Java代码+前端Ui混合打包的方式，在微服务架构下显的很臃肿,因此项目正式更名为knife4j。

更名后主要专注的方面

前后端Java代码以及前端Ui模块进行分离,在微服务架构下使用更加灵活
提供专注于Swagger的增强解决方案，不同于只是改善增强前端Ui部分

更多详情，可以去看我的knife4j博客，点击前往

3.新建redis配置类

FastJson2JsonRedisSerializer.java

我们Redis使用FastJson序列化，新建 FastJson2JsonRedisSerializer.java 类，代码如下：

package com.demo.config;import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.parser.ParserConfig;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.type.TypeFactory;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.SerializationException;
import org.springframework.util.Assert;import java.nio.charset.Charset;/*** Redis使用FastJson序列化* RedisSerializer：对象到字节数组(二进制数据)的基本接口序列化和反序列化。* 建议实现设计为在序列化和反序列化端处理空对象/空数组。注意，Redis不接受null键或null值，但可以返回null回复(对于不存在的键)。*/
public class FastJson2JsonRedisSerializer<T> implements RedisSerializer<T>
{// @SuppressWarnings 用来屏蔽一些无关紧要的警告@SuppressWarnings("unused")// ObjectMapper：用来操作对象等转换为json的private ObjectMapper objectMapper = new ObjectMapper();public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");private Class<T> clazz;static{// autotype类型默认时被fastjson禁用掉了的，这里进行开启ParserConfig.getGlobalInstance().setAutoTypeSupport(true);// 如果遇到反序列化autoType is not support错误，请添加并修改一下包名到bean文件路径// ParserConfig.getGlobalInstance().addAccept("com.xxxxx.xxx");}public FastJson2JsonRedisSerializer(Class<T> clazz){super();this.clazz = clazz;}@Overridepublic byte[] serialize(T t) throws SerializationException{if (t == null){return new byte[0];}/** SerializerFeature.WriteClassName：若之前进行序列化的x是Employee的子类且使用了SerializerFeature.WriteClassName，那么经过反序列化Employee x = (Employee) JSON.parse(text)以后，进行System.out.println(JSON.toJSONString(x))则会输出子类的完整json信息* */return JSON.toJSONString(t, SerializerFeature.WriteClassName).getBytes(DEFAULT_CHARSET);}@Overridepublic T deserialize(byte[] bytes) throws SerializationException{if (bytes == null || bytes.length <= 0){return null;}String str = new String(bytes, DEFAULT_CHARSET);return JSON.parseObject(str, clazz);}public void setObjectMapper(ObjectMapper objectMapper){Assert.notNull(objectMapper, "'objectMapper' must not be null");this.objectMapper = objectMapper;}protected JavaType getJavaType(Class<?> clazz){return TypeFactory.defaultInstance().constructType(clazz);}
}

RedisConfig.java

之后我们新建 RedisConfig.java 文件，用于配置redis，具体代码如下：

package com.demo.config;import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.serializer.StringRedisSerializer;/*** redis配置，配置RedisTemplate注册到IOC容器中* 提供一个redisTemplate，这个redisTemplate用fastjson来序列化value的值，用string来序列化key的值。*/
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport
{/**步骤：* 1.RedisConnectionFactory ，线程安全的redis工厂* 2.设置Value的序列器(FastJson2JsonRedisSerializer)，使用FastJson进行String和字节码的转换,而FastJson2JsonRedisSerializer*   又要设置ObjectMapper，用来实现JSON实际的读/写* 3.设置key的序列器(StringRedisSerializer)* 4.使用afterPropertiesSet进行初始化** @param connectionFactory* @return*/@Bean// @SuppressWarnings 用来屏蔽一些无关紧要的警告@SuppressWarnings(value = { "unchecked", "rawtypes" })public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory connectionFactory){// 新建RedisTemplate对象RedisTemplate<Object, Object> template = new RedisTemplate<>();// 设置连接工厂template.setConnectionFactory(connectionFactory);// 使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值// Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);// 使用Fastjson2JsonRedisSerializer来序列化和反序列化redis的value值FastJson2JsonRedisSerializer serializer = new FastJson2JsonRedisSerializer(Object.class);// Jackson之ObjectMapper对象的使用: https://blog.csdn.net/qq_41834086/article/details/111152470ObjectMapper mapper = new ObjectMapper();// ALL：此伪类型表明所有访问器都受到影响。ANY：所有类型的访问修饰符都是可接受的，从私有到公有。mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);mapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.PROPERTY);serializer.setObjectMapper(mapper);// 使用StringRedisSerializer来序列化和反序列化redis的key值，通过new StringRedisSerializer() 可以使key不带引号template.setKeySerializer(new StringRedisSerializer());// 使用Jackson2JsonRedisSerializerr来序列化和反序列化redis的value值template.setValueSerializer(serializer);// Hash的key也采用StringRedisSerializer的序列化方式template.setHashKeySerializer(new StringRedisSerializer());template.setHashValueSerializer(serializer);// 使用afterPropertiesSet进行初始化,始化参数和初始化工作。template.afterPropertiesSet();return template;}/** redis的lua脚本配置* csdn链接： https://blog.csdn.net/liubenlong007/article/details/53816087* 在应用上下文中配置一个DefaultRedisScript 的单例，避免在每个脚本执行的时候重复创建脚本的SHA1.* */@Beanpublic DefaultRedisScript<Long> limitScript(){DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();redisScript.setScriptText(limitScriptText());redisScript.setResultType(Long.class);return redisScript;}/*** 限流脚本* 注意，lua脚本中的变量都要是local 的，不可以是全局变量。否则会报错。详见 http://doc.redisfans.com/script/eval.html#id6*/private String limitScriptText(){return "local key = KEYS[1]\n" +"local count = tonumber(ARGV[1])\n" +"local time = tonumber(ARGV[2])\n" +"local current = redis.call('get', key);\n" +"if current and tonumber(current) > count then\n" +"    return current;\n" +"end\n" +"current = redis.call('incr', key)\n" +"if tonumber(current) == 1 then\n" +"    redis.call('expire', key, time)\n" +"end\n" +"return current;";}
}

application.yml

之后我们需要在 application.yml配置文件中进行redis和项目的配置，具体代码如下：

server:port: 8080servlet:context-path: /spring:# redis 配置redis:# 地址host: localhost# 端口，默认为6379port: 6379# 数据库索引database: 0# 密码password:# 连接超时时间timeout: 10s# Lettuce 配置，Lettuce 是一个可伸缩线程安全的 Redis 客户端，多个线程可以共享同一个 RedisConnection，它利用优秀 netty NIO 框架来高效地管理多个连接lettuce:pool:# 连接池中的最小空闲连接min-idle: 0# 连接池中的最大空闲连接max-idle: 8# 连接池的最大数据库连接数（使用负值表示没有限制）max-active: 8# #连接池最大阻塞等待时间（使用负值表示没有限制）max-wait: -1ms

4.新建redis工具类

RedisCache.java

用于操作redis，我们 RedisCache.java 文件，具体代码如下：

package com.demo.core;import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;import java.util.*;
import java.util.concurrent.TimeUnit;/*** spring redis 工具类****/
// @SuppressWarnings 用来屏蔽一些无关紧要的警告
@SuppressWarnings(value = { "unchecked", "rawtypes" })
@Component
public class RedisCache
{@Autowiredpublic RedisTemplate redisTemplate;/*** 缓存基本的对象，Integer、String、实体类等** @param key 缓存的键值* @param value 缓存的值*/public <T> void setCacheObject(final String key, final T value){redisTemplate.opsForValue().set(key, value);}/*** 缓存基本的对象，Integer、String、实体类等** @param key 缓存的键值* @param value 缓存的值* @param timeout 时间* @param timeUnit 时间颗粒度*/public <T> void setCacheObject(final String key, final T value, final Integer timeout, final TimeUnit timeUnit){redisTemplate.opsForValue().set(key, value, timeout, timeUnit);}/*** 设置有效时间** @param key Redis键* @param timeout 超时时间* @return true=设置成功；false=设置失败*/public boolean expire(final String key, final long timeout){return expire(key, timeout, TimeUnit.SECONDS);}/*** 设置有效时间** @param key Redis键* @param timeout 超时时间* @param unit 时间单位* @return true=设置成功；false=设置失败*/public boolean expire(final String key, final long timeout, final TimeUnit unit){return redisTemplate.expire(key, timeout, unit);}/*** 获得缓存的基本对象。** @param key 缓存键值* @return 缓存键值对应的数据*/public <T> T getCacheObject(final String key){ValueOperations<String, T> operation = redisTemplate.opsForValue();return operation.get(key);}/*** 删除单个对象** @param key*/public boolean deleteObject(final String key){return redisTemplate.delete(key);}/*** 删除集合对象** @param collection 多个对象* @return*/public long deleteObject(final Collection collection){return redisTemplate.delete(collection);}/*** 缓存List数据** @param key 缓存的键值* @param dataList 待缓存的List数据* @return 缓存的对象*/public <T> long setCacheList(final String key, final List<T> dataList){Long count = redisTemplate.opsForList().rightPushAll(key, dataList);return count == null ? 0 : count;}/*** 获得缓存的list对象** @param key 缓存的键值* @return 缓存键值对应的数据*/public <T> List<T> getCacheList(final String key){return redisTemplate.opsForList().range(key, 0, -1);}/*** 缓存Set** @param key 缓存键值* @param dataSet 缓存的数据* @return 缓存数据的对象*/public <T> BoundSetOperations<String, T> setCacheSet(final String key, final Set<T> dataSet){BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);Iterator<T> it = dataSet.iterator();while (it.hasNext()){setOperation.add(it.next());}return setOperation;}/*** 获得缓存的set** @param key* @return*/public <T> Set<T> getCacheSet(final String key){return redisTemplate.opsForSet().members(key);}/*** 缓存Map** @param key* @param dataMap*/public <T> void setCacheMap(final String key, final Map<String, T> dataMap){if (dataMap != null) {redisTemplate.opsForHash().putAll(key, dataMap);}}/*** 获得缓存的Map** @param key* @return*/public <T> Map<String, T> getCacheMap(final String key){return redisTemplate.opsForHash().entries(key);}/*** 往Hash中存入数据** @param key Redis键* @param hKey Hash键* @param value 值*/public <T> void setCacheMapValue(final String key, final String hKey, final T value){redisTemplate.opsForHash().put(key, hKey, value);}/*** 获取Hash中的数据** @param key Redis键* @param hKey Hash键* @return Hash中的对象*/public <T> T getCacheMapValue(final String key, final String hKey){HashOperations<String, String, T> opsForHash = redisTemplate.opsForHash();return opsForHash.get(key, hKey);}/*** 获取多个Hash中的数据** @param key Redis键* @param hKeys Hash键集合* @return Hash对象集合*/public <T> List<T> getMultiCacheMapValue(final String key, final Collection<Object> hKeys){return redisTemplate.opsForHash().multiGet(key, hKeys);}/*** 获得缓存的基本对象列表** @param pattern 字符串前缀* @return 对象列表*/public Collection<String> keys(final String pattern){return redisTemplate.keys(pattern);}}

5.新建实体类

做好redis的配置后，我们就可以使用redis了。我们新建model包和entity包，model包下有LoginUser.java，用于在redis中存放用户信息，entity包下有SysUser.java，此为数据库实体类，LoginUser.java中包含SysUser.java对象，具体代码如下：

SysUser.java

package com.demo.entity;import com.fasterxml.jackson.annotation.JsonIgnore;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.swagger.annotations.ApiModelProperty;import java.io.Serializable;
import java.util.Date;
import java.util.List;/*** 用户对象 sys_user**/public class SysUser implements Serializable
{private static final long serialVersionUID = 1L;/** 用户ID */@ApiModelProperty("用户ID")private Long userId;/** 用户账号 */@ApiModelProperty("用户账号")private String userName;/** 手机号码 */@ApiModelProperty("手机号码")private String phoneNumber;public Long getUserId() {return userId;}public void setUserId(Long userId) {this.userId = userId;}public String getUserName() {return userName;}public void setUserName(String userName) {this.userName = userName;}public String getPhoneNumber() {return phoneNumber;}public void setPhoneNumber(String phoneNumber) {this.phoneNumber = phoneNumber;}@Overridepublic String toString() {return "SysUser{" +"userId=" + userId +", userName='" + userName + '\'' +", phoneNumber='" + phoneNumber + '\'' +'}';}
}

LoginUser.java

package com.demo.model;import com.demo.entity.SysUser;
import io.swagger.annotations.ApiModelProperty;import java.io.Serializable;/*** 登录用户身份权限**/
public class LoginUser implements Serializable
{private static final long serialVersionUID = 1L;/*** 用户ID*/@ApiModelProperty("用户ID")private Long userId;/*** 用户唯一标识*/@ApiModelProperty("用户唯一标识")private String token;/*** 登录时间*/@ApiModelProperty("登录时间")private Long loginTime;/*** 过期时间*/@ApiModelProperty("过期时间")private Long expireTime;/*** 用户信息*/@ApiModelProperty("用户信息")private SysUser user;public Long getUserId() {return userId;}public void setUserId(Long userId) {this.userId = userId;}public String getToken() {return token;}public void setToken(String token) {this.token = token;}public Long getLoginTime() {return loginTime;}public void setLoginTime(Long loginTime) {this.loginTime = loginTime;}public Long getExpireTime() {return expireTime;}public void setExpireTime(Long expireTime) {this.expireTime = expireTime;}public SysUser getUser() {return user;}public void setUser(SysUser user) {this.user = user;}@Overridepublic String toString() {return "LoginUser{" +"userId=" + userId +", token='" + token + '\'' +", loginTime=" + loginTime +", expireTime=" + expireTime +", user=" + user +'}';}
}

6.新建controller

用于测试，此处我们新建 RedisController.java 文件，

package com.demo.controller;import com.demo.model.LoginUser;
import com.demo.core.RedisCache;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import io.swagger.annotations.ApiParam;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;import java.util.concurrent.TimeUnit;/**创建者: ty*创建时间:2021/11/15 15:52*/
@Api(value = "Redis测试管理", tags = "Redis测试")
@RestController
@RequestMapping("/redis")
public class RedisController {@Autowiredprivate RedisCache redisCache;/* 测试全局异常配置 */@GetMapping("/exception")public String exception(){int i = 1/0;return "123";}@ApiOperation(value = "测试简单缓存-无过期时间",notes = "测试简单缓存-无过期时间",httpMethod = "GET")@GetMapping("/{key}/{value}")public String set(@ApiParam(name = "key", value = "key", required = true) @PathVariable("key") String key,@ApiParam(name="value", value = "key", required = true) @PathVariable("value") String value) {redisCache.setCacheObject(key, value);return "ok";}@ApiOperation(value = "测试简单缓存-有过期时间",notes = "测试简单缓存-有过期时间",httpMethod = "GET")@GetMapping("/{key}/{value}/{expireTime}")public String set(@ApiParam(name="key", value="key", required=true) @PathVariable("key") String key,@ApiParam(name="value", value = "key", required = true) @PathVariable("value") String value,@ApiParam(name = "expireTime", value = "expireTime", required = true) @PathVariable("expireTime") Integer expireTime) {redisCache.setCacheObject(key, value, expireTime, TimeUnit.MINUTES);return "ok";}@ApiOperation(value = "测试复杂缓存-无过期时间",notes = "测试简单缓存-无过期时间",httpMethod = "POST")@RequestMapping(value = "/fuza/{key}", method = RequestMethod.POST)public String test(@ApiParam(name="key", value="key", required=true) @PathVariable("key") String key,LoginUser loginUser){redisCache.setCacheObject(key, loginUser);return "ok";}@ApiOperation(value = "测试复杂缓存-有过期时间",notes = "测试复制缓存-有过期时间",httpMethod = "POST")@RequestMapping(value = "/fuza/{key}/{expireTime}", method = RequestMethod.POST)public String test(@ApiParam(name="key", value="key", required=true) @PathVariable("key") String key,@ApiParam(name = "expireTime", value = "expireTime", required = true) @PathVariable("expireTime") Integer expireTime,LoginUser loginUser){redisCache.setCacheObject(key, loginUser, expireTime, TimeUnit.MINUTES);return "ok";}}

7.新建启动类并启动

我们新建项目启动类 DemoApplication.java ，此处因为我们需要借助knife4j进行测试，所以我们要开启swagger文档，即加上注解 @EnableSwagger2WebMvc

package com.demo;import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import springfox.documentation.swagger2.annotations.EnableSwagger2WebMvc;/* 开启swageger文档 */
@EnableSwagger2WebMvc
@SpringBootApplication
public class DemoApplication {public static void main(String[] args) {SpringApplication.run(DemoApplication.class, args);}
}

之后我们启动项目，

8.使用knife4j测试

我们输入 http://localhost:8080/doc.html 访问knife4j，注意，knife4j的默认访问路径为 /doc.html

测试简单缓存-有过期时间

此处我们测试有过期时间的，具体如下：

之后我们打开 RDM（redis-desktop-manager） ，此为redis管理软件（可关注我的微信公众号进行获取），我们发现数据已经存入到redis，且1分钟后过期

测试复杂缓存-有过期时间

此处我们测试有过期时间的，具体如下：

之后我们打开 RDM（redis-desktop-manager），此为redis管理软件，我们发现数据已经存入到redis，且1分钟后过期

扩展：全局异常处理

相信细心的你已经发现了，我在代码中额外做了一个简单的全局异常处理。

即 RedisController.java 中的以下这段代码，我书写了如下代码，执行一下代码会报一个 java.lang.ArithmeticException: / by zero 的异常，

     /* 测试全局异常配置 */@GetMapping("/exception")public String exception(){int i = 1/0;return "123";}

之后项目中还有一个 GlobalExceptionHandler.java 全局异常处理类，此处只是简单做了一个捕获异常后对异常信息的返回处理，并没有使用响应类进行设置响应结果的处理，也没有对异常进行分类的处理，感兴趣的同学可以自行去了解，此处只是做一个简单的测试。

package com.demo.core;import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestControllerAdvice;/*** 全局异常处理器** @author wedding*/
@RestControllerAdvice
public class GlobalExceptionHandler
{private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);/*** @description 系统异常捕获处理*/@ResponseBody@ExceptionHandler(value = Exception.class)public String globalExceptionHandler(Exception ex) {log.error("捕获到Exception异常：",ex);// 返回统一结果处理return "捕获到Exception异常";}
}

如果我们没有GlobalExceptionHandler.java 全局异常处理类，当我访问 http://localhost:8080/redis/exception ，浏览器呈现的界面如下：

但是当我们有 GlobalExceptionHandler.java 全局异常处理类后，当我访问 http://localhost:8080/redis/exception ，浏览器呈现的界面如下：

源码获取

至此，我们的SpringBoot集成Redis并使用Knife4j测试就讲解完成了。源码和RDM软件可以通过关注我的微信公众号我爱学习呀嘻嘻，回复关键字redis集成进行获取哦。