Spring-Redis

已于 2023-12-07 16:24:00 修改
阅读量995 收藏 26
点赞数 23
文章标签： spring redis bootstrap
于 2023-12-07 16:21:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62778995/article/details/134858648
版权

什么是Redis

Redis是一种基于键值对（key-value）的NoSQL数据库

什么是Spring-redis

为了方便在spring工程中使用redis,创建的依赖包

配置Redis连接

为了操作Redis，我们需要使用Java的Redis客户端，下面是Redis官方推荐的三种客户端

IO方式线程安全
Jedis阻塞式否
Lettuce非阻塞是
Redission非阻塞是

Redis各个客户端的操作差别很大，为了屏蔽这种差异，spring提供了一套对应的抽象 spring-boot-starter-data-redis，它屏蔽了各种客户端的操作差异，使得我们可以使用相同的操作来使用Redis

<!-- 导入lettuce -->
<dependency>
    <groupId>io.lettuce</groupId>
    <artifactId>lettuce-core</artifactId>
</dependency>
<!-- 导入jedis -->
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

导入spring-boot-starter-data-redis

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version></version>
</dependency>

spring-boor-starter-data-redis默认使用lettuce作为默认客户端，且仅支持jedis和lettuce


如果需要使用jedis作为操作Redis客户端，需要从spring-boor-starter-data-redis中排除lettuce依赖，并导入jedis

 <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>io.lettuce</groupId>
                    <artifactId>lettuce-core</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        
        <dependency>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </dependency>

spring-data-redis为redis提供的抽象

Redis的自动配置

spring为Redis设置了配置类xxxConnectionConfiguration类(xxx=Jedis/Lettuce)；
其中有两个Bean xxxClientResources (提供构建客户端所需要的资源，和配置), redisConnectionFactory（用于建立和Redis的连接）
可以使用spring-actuator来查看这两个bean

配置连接信息

spring相关的配置前缀为spring.redis，具体的配置有RedisRroperties类实现:

# application.yml
spring:
  redis:
    host: 192.168.56.10
    port: 6379
    password: 123456

主要的配置信息如下

配置项默认值说明
spring.redis.hostlocalhostRedis 服务器主机名
spring.redis.port6379Redis 服务器端口
spring.redis.passwordRedis 服务器密码
spring.redis.timeout60s连接超时时间
spring.redis.sentinel.masterRedis 服务器主节点名称
spring.redis.sentinel.nodes哨兵节点列表，节点用“主机名:端口”表示，主机之间用逗号分割
spring.redis.sentinel.password哨兵节点密码
springredis.cluster.nodes集群节点列表，节点可以自发现，但至少要配置一个节点
spring.redis.cluster.maxRedirects5在集群中执行命令时的最大重定向次数
spring.redis.jedis.pool.*Jedis连接池配置
spring.redis.lettuce.*Lettuce特定的配置

Template类

spring将各种固有的操作封装成模板类如JdbcTemplate等，而redis中的常用操作被封装成了RedisTemplate类，


SpringBoot的RedisAutoConfiguration创建了两个默认的RedisTemplate对象，stringRedisTemplate类专用于字符串类型的Redis操作，redisTemplate用于通用类型的Redis操作。
Redis中有很多种数据结构，虽然键都是字符串类型的，但是由于值的种类各不相同，所以Template为了操作这些数据结构，必须要为每种数据结构提供一个操作集，对于每一种值都需要使用操作集包含的方法来执行操作

Template中封装的操作类型

    private final ValueOperations<K, V> valueOps = new DefaultValueOperations(this);
    private final ListOperations<K, V> listOps = new DefaultListOperations(this);
    private final SetOperations<K, V> setOps = new DefaultSetOperations(this);
    private final StreamOperations<K, ?, ?> streamOps = new DefaultStreamOperations(this, new ObjectHashMapper());
    private final ZSetOperations<K, V> zSetOps = new DefaultZSetOperations(this);
    private final GeoOperations<K, V> geoOps = new DefaultGeoOperations(this);
    private final HyperLogLogOperations<K, V> hllOps = new DefaultHyperLogLogOperations(this);
    private final ClusterOperations<K, V> clusterOps = new DefaultClusterOperations(this);
操作描述
ClusterOperationsRedis集群的相关操作
GeoOperationsRedis地理位置的相关操作
HashOperationsRedisHash类型的相关操作
HyperLogLogOperationsRedis HyperLogLog类型的相关操作
ListOperationsRedis列表类型的相关操作
SetOperationsRedis集合类型的相关操作
StreamOperationsRedis 流的相关操作
ValueOperationsRedis值类型的相关操作
ZSetOperationsRedis有序结合类型的相关操作

在使用Template时，我们调用Template对象的opsForXXX就可以获取到这些操作集，就可以使用操作集中的add(),get()等方法来操作Redis

于此同时，一些和Redis数据结构无关的操作直接封装到了Template类中，比如删除键，设置键的过期时间等操作；

Redis中存放对象

在Spring-redis中RedisTemplate负责将对象序列化并存储到redis中，Spring-data-redis默认会使用JDK自带的序列化机制来进行序列化和反序列化，而能够使用jdk序列化的类，需要实现Serializable接口

public class Actor implements Serializable {
    private static final long SERIALIZABLE_ID= 13543843449464L;
    private Integer actorId;
    private String firstName;
    private String lastName;

    public Actor(Integer actorId, String firstName, String lastName) {
        this.actorId = actorId;
        this.firstName = firstName;
        this.lastName = lastName;
    }

}

设置一个简单的示例来展示Redis存放java对象的
示例的目录


负责实现存放对象到Redis的逻辑的RedisServiceImpl

import org.example.entity.Actor;
import org.example.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

@Service
public class RedisServiceImpl implements RedisService {
    @Resource(name="redisTemplate")
    RedisTemplate redisTemplate;

    @Override
    public void addActor(Actor actor) {
        redisTemplate.opsForValue().set("Actor",actor);
    }

    @Override
    public Actor getActor(String key) {
        return (Actor)redisTemplate.opsForValue().get(key);
    }
}

控制器类

import org.example.entity.Actor;
import org.example.service.RedisService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ActorController {
    @Autowired
    private RedisService service;

    @RequestMapping("test")
    public String addActor(){
        Actor actor=new Actor(115,"jonh","sin");
        service.addActor(actor);
        return "success";
    }

    @RequestMapping("get")
    public Actor getActor(){
        return service.getActor("Actor");
    }
}

运行结果


运行完成之后我们可以看到Redis中增加了一个新的键值对，但是这种键值对无法直接使用，更不能实现在不同编程语言中共用这些缓存数据，我们希望使用JSON来实现对象的序列化和反序列化。
前面提到了RedisTemplate负责实现对象存储，这是由于RedisTemplate的初始化方法
中的下面这段决定的

        if (this.defaultSerializer == null) {
            this.defaultSerializer = new JdkSerializationRedisSerializer(this.classLoader!= null ? this.classLoader : this.getClass().getClassLoader());
        }

        if (this.enableDefaultSerializer) {
            if (this.keySerializer == null) {
                this.keySerializer = this.defaultSerializer;
                defaultUsed = true;
            }

            if (this.valueSerializer == null) {
                this.valueSerializer = this.defaultSerializer;
                defaultUsed = true;
            }

所以我们要更改Redis的序列化方式，只需要更改keySerializer和valueSerializer这两个序列化器即可,RedisSerializer类为我们提供了多种内置的序列化器，其中就有JSON的序列化器。

序列化器快捷方式说明
JdkSerializationRedisSerializerRedisSerializer.java()使用JDK的序列化方式
ByteArrayRedisSerializerRedisSerializer.byteArray()直接透传 byte[]，不做任何处理
StringRedisSerializerRedisSerializer.string()根据字符集将字符串序列化为字节
GenericToStringSerializer依赖Spring的 ConversionService来序列字符串
GenericJackson2JsonRedisSerializerRedisSerializer.json()按照object来序列化对象
Jackson2JsonRedisSerializer根据给定的泛型类型序列化对象
OxmSerializer依赖Spring的OXM(Object/XMLMapprO/M 映射器)来序列化对象
package org.example.config;

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.serializer.RedisSerializer;

@Configuration
public class RedisConfig {
    @Bean(name="redisTemplate")
    public RedisTemplate initRedisTemplate(RedisConnectionFactory fac){
        RedisTemplate redisTemplate=new RedisTemplate();
        redisTemplate.setConnectionFactory(fac);
        redisTemplate.setKeySerializer(RedisSerializer.string());
        redisTemplate.setValueSerializer(RedisSerializer.json());
        return redisTemplate;
    }
}

所以我们添加一个配置类，其中覆盖了原生自动配置的redisTemplate，修改其keySerializer和ValueSerializer，并将需要被序列化为json的类修改为Java Bean的形式(提供构造函数和getter，setter方法) 然后重新启动程序,

public class Actor  {
    private static final long SERIALIZABLE_ID= 13543843449464L;
    private Integer actorId;
    private String firstName;
    private String lastName;

    public Actor() {
    }
    public Integer getActorId() {
        return actorId;
    }

    public void setActorId(Integer actorId) {
        this.actorId = actorId;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }
    
}

执行完成之后，可以看到redis直接将我们传入的key用字符串存储，然后对象使用JSON存储

在现实开发中，对象的属性也可能是一个对象，这个时候只需要将对象中的子对象也设置成JavaBean的格式，会自动存储为JSON格式，无需额外处理

package org.example.entity;

public class Actor  {
    private static final long SERIALIZABLE_ID= 13543843449464L;
    private Integer actorId;
    private String firstName;
    private String lastName;
//添加了son属性用于测试
    private Son son;

    public Son getSon() {
        return son;
    }

    public void setSon(Son son) {
        this.son = son;
    }

    public Actor() {
    }
    public Integer getActorId() {
        return actorId;
    }

    public void setActorId(Integer actorId) {
        this.actorId = actorId;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

}

image.png

但是也不是所有的类都是我们自己定义的，能够被JSON序列化器直接序列化的，比如我们从依赖中导入的类。实际上，序列化器，Servializer的对象转换到Json是交给ObjectMapper类来处理的，我们可以通过定制ObjectMapper来覆盖SpringBoot自动配置的ObjectMapper，来控制类应该映射成什么样的json格式。下面以被广泛用于表示货币金额的Java库-Joda-Money来做解释，我们创建一个Java类：

import org.joda.money.Money;

public class Order {
   Money money;
   String orderName;

    public Order() {
    }

    public Money getMoney() {
        return money;
    }

    public void setMoney(Money money) {
        this.money = money;
    }

    public String getOrderName() {
        return orderName;
    }

    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }
}

导入org.joda.joda-money类库

         <dependency>
            <groupId>org.joda</groupId>
            <artifactId>joda-money</artifactId>
            <version>1.0.1</version>
            <scope>runtime</scope>
        </dependency>

不做处理直接使用，可以看到下面的类中许多信息是我们不需要的，我们只想将amount属性以特定的格式保存，所以这时候就需要自定义Order的ObjectMapper

  1. 定制Money类的序列化器和反序列化器


    自定义序列化器(serializers)通常是通过Module方式注册到Jackson中，但在Spring Boot中提供了@JsonComponent注解作为替代方案，它能帮我们更为轻松的将序列化器注册到Spring Beans中。
    我们可以直接在JsonSerializer 或 JsonDeserializer类上使用 @JsonComponent注解，该注解允许我们将带该注解的类公开为Jackson序列化器或反序列化器，而无需再手动将其添加到ObjectMapper。

  2. 有时jackson官方也会为我们提供一个默认的Moudule注册方案，我们只需要将这个Module注册到ObjectMapper中即可,一般来说只要注册为Bean，ObjectMapper会自动注入这个Module

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.datatype/jackson-datatype-joda-money -->
<dependency>
    <groupId>com.fasterxml.jackson.datatype</groupId>
    <artifactId>jackson-datatype-joda-money</artifactId>
    <version>2.15.0</version>
</dependency>

Redis的Repository操作

为了简化Spring-redis的CRUD操作，我们可以使用Redis提供的Repository操作，其中包含了对这些简单操作的逻辑的封装，直接调用这些方法来即可。Repository操作可以这样理解：我们定义了一个仓库(仓库有一个仓库的名字)，仓库中有很多实体类对象，这些对象分别有一个id来识别，这些对象可以使用我们提前准备好的工具来直接操作

  1. 定义实体类
    实体类就是Repository操作的对象，
注解说明
@RedisHash与@Entity类似，用来定义Redis 的Repository操作的领域对象，其中的value定义了不同类型对象存储时使用的前缀，也叫做键空间 (keyspace)，默认是全限定类名，timeToLive 用来定义缓存的秒数
@Id定义对象的标识符
@Indexed定义二级索引，加在属性上可以将该属性定义为查询用的索引
@Reference缓存对象引用，一般引用的对象也会被展开存储在当前对象中，添加了该注解后会直接存储该对象在Redis中的引用
@RedisHash(value="orderList",timeToLive = 60)
public class Order1 {
    @Id
    UUID uuid;
    Money money;
    String orderName;
    public Order1() {
        uuid=UUID.randomUUID();
    }
    public Money getMoney() {
        return money;
    }
    public void setMoney(Money money) {
        this.money = money;
    }
    public String getOrderName() {
        return orderName;
    }
    public void setOrderName(String orderName) {
        this.orderName = orderName;
    }
}

2.定义接口


3. 定制某些特殊类的转换规则
有时候这些类自动被Repository操作时得到的结果是我们不满意的，如Joda Money类的自动转换，会多出很多不需要的属性

这时候除了像上一章一样为JodaMoney设置序列化器和反序列化器之外，还需要设置Converter来实现对象的转换。

BytesToMoney类

import com.fasterxml.jackson.databind.ObjectMapper;
import org.joda.money.Money;
import org.springframework.core.convert.converter.Converter;
import org.springframework.data.convert.ReadingConverter;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
@ReadingConverter
public class BytesToMoney implements Converter<byte[],Money> {

    private Jackson2JsonRedisSerializer<Money> serializer;

    public BytesToMoney(ObjectMapper mapper) {
        Jackson2JsonRedisSerializer serializer1=new Jackson2JsonRedisSerializer(Money.class);
        this.serializer = serializer1;
        this.serializer.setObjectMapper(mapper);
    }

    @Override
    public Money convert(byte[] bytes) {
        return serializer.deserialize(bytes);
    }
}

MoneyToBytes类

import com.fasterxml.jackson.databind.ObjectMapper;
import org.joda.money.Money;
import org.springframework.core.convert.converter.Converter;
import org.springframework.data.convert.ReadingConverter;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
@ReadingConverter
public class BytesToMoney implements Converter<byte[],Money> {

    private Jackson2JsonRedisSerializer<Money> serializer;

    public BytesToMoney(ObjectMapper mapper) {
        Jackson2JsonRedisSerializer serializer1=new Jackson2JsonRedisSerializer(Money.class);
        this.serializer = serializer1;
        this.serializer.setObjectMapper(mapper);
    }

    @Override
    public Money convert(byte[] bytes) {
        return serializer.deserialize(bytes);
    }
}

在设置完Converter之后还需要将两个Converter注册到RedisCustomConversions中去

  1. 开启对Repository的支持
@EnableRedisRepositories
@Configuration
public class RedisConfig {

    @Bean
    public RedisCustomConversions redisCustomConversions(ObjectMapper mapper){
        return new RedisCustomConversions(
                Arrays.asList(new MoneyToBytes(mapper),new BytesToMoney(mapper)));
    }
    @Bean(name="redisTemplate")
    public RedisTemplate initRedisTemplate(RedisConnectionFactory fac, ObjectMapper obj){
        Jackson2JsonRedisSerializer<Order> serializer=new Jackson2JsonRedisSerializer<>(Order.class);
        serializer.setObjectMapper(obj);
        RedisTemplate redisTemplate=new RedisTemplate();
        redisTemplate.setConnectionFactory(fac);
        redisTemplate.setKeySerializer(RedisSerializer.string());
        redisTemplate.setValueSerializer(serializer);
        return redisTemplate;
    }

}
  1. 操作Repository


Redis为存储的实体类创建了一个名为(@RedisHash中的value)的集合,其中所有对象的Id都存放在其中，而每个对象以 [集合名:Id]的格式，散列Hash的类型存放在Redis中；


littlepants718
关注
Spring整合redis
oLengNuanZiZhi12的博客
03-27 846
Spring整合redisRedis整合1>下载安装 Redis整合 Redis（Remote Dictionary Server）是一个开源（BSD许可），内存存储的数据结构服务器，可用作数据库，高速缓存和消息队列代理。它支持字符串、哈希表、列表、集合、有序集合，位图，hyperloglogs等数据类型，redis支持快照，依赖快照进行持久化。 1>下载安装 服务端下载 下载地址： 解压后对应机器位数运行32位或64位目录下的redis-server，直接双击即可 ...
在Spring中使用Redis
unber的博客
09-09 4524
在教程《在Java程序中使用Redis》中介绍了在没有封装情况下使用 Java API 的缺点，需要自己编写规则把 Java 对象和 Redis 的字符串进行相互转换，而在 Spring 中这些问题都可以轻松处理。
[Spring学习]Spring集成Redis
最新发布
weixin_44947767的博客
08-20 312
application-local.yml里面。Spring集成Redis。
在 Spring 中操作 Redis
2302_82270778的博客
07-08 855
在 Spring 中操作 Redis
Spring中Redis使用
len的博客
07-01 3951
RedisTemplate如何检查一个key是否存在？ return getRedisTemplate().hasKey(key); 由一个问题,复习了一下redis 抄自: https://www.jianshu.com/p/7bf5dc61ca06 大部分都试了一遍 Redis 数据结构简介 Redis可以存储键与5种不同数据结构类型之间的映射，这5种数据结构类型分别为String（字符串）、List（列表）、Set（集合）、Hash（散列）和 Zset（有序集合）。 下面..
spring-redis
06-11
这个`spring-redis-master`压缩包可能包含了一个示例项目，展示了如何在Spring 3和4中利用@Cacheable注解进行缓存操作。@Cacheable是Spring Cache抽象的一部分，它允许开发人员在方法级别声明缓存，从而提高应用程序...
spring-redis-session 自定义 key 和过期时间
08-25
Spring-Redis-Session 自定义 key 和过期时间 Spring-Redis-Session 是一个基于 Spring 框架的会话管理模块，它使用 Redis 作为会话存储介质，提供了灵活的会话管理机制。在本文中，我们将详细介绍 Spring-Redis-...
spring-data-redis-2.3.9.RELEASE-API文档-中文版.zip
07-13
赠送jar包：spring-data-redis-2.3.9.RELEASE.jar； 赠送原API文档：spring-data-redis-2.3.9.RELEASE-javadoc.jar； 赠送源代码：spring-data-redis-2.3.9.RELEASE-sources.jar； 赠送Maven依赖信息文件：spring-...
spring-data-redis-2.6.1-API文档-中文版.zip
05-09
赠送jar包：spring-data-redis-2.6.1.jar； 赠送原API文档：spring-data-redis-2.6.1-javadoc.jar； 赠送源代码：spring-data-redis-2.6.1-sources.jar； 赠送Maven依赖信息文件：spring-data-redis-2.6.1.pom； ...
spring-data-redis-2.5.5-API文档-中文版.zip
06-04
赠送jar包：spring-data-redis-2.5.5.jar； 赠送原API文档：spring-data-redis-2.5.5-javadoc.jar； 赠送源代码：spring-data-redis-2.5.5-sources.jar； 赠送Maven依赖信息文件：spring-data-redis-2.5.5.pom； ...
深入理解Spring Redis的使用 (一) Spring Redis基本使用
weixin_57907028的博客
08-10 7840
关于spring redis框架的使用，网上的例子很多很多。但是在自己最近一段时间的使用中，发现这些教程都是入门教程，包括很多的使用方法，与spring redis丰富的api大相径庭，真是浪费了这么优秀的一个框架。这里，我们就对比之前对spring orm中对hibernate的使用，来理解使用spring redis的使用。（本文章不做redis基本命令使用的讲解） 1. Redis使用场景 Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库
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...
通过 Spring 操作 Redis
q322359的博客
05-22 683
要想通过 Java 操作，首先要连接上 redis。
Spring整合Redis
weixin_42382758的博客
04-10 755
添加依赖到pom,xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> <version>2.6.6</version> </dependency> 在application.properti..
Redis的基础使用
飞奔的五花肉博客
05-29 862
Redis基础 Redis入门 Redis数据类型 Redis常用命令 在Java中操作Redis 1. 前言 1.1 什么是Redis Redis是一个基于内存的key-value结构数据库。Redis 是互联网技术领域使用最为广泛的存储中间件，它是「Remote Dictionary Service」的首字母缩写，也就是「远程字典服务」。 基于内存存储，读写性能高 适合存储热点数据（热点商品、资讯、新闻） 企业应用广泛 1.2 使用Redis能做什么 数据缓存 消息队列 注册中心 发布订阅
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值