Spring boot整合redis

最新推荐文章于 2022-07-29 11:26:52 发布
最新推荐文章于 2022-07-29 11:26:52 发布
阅读量157 收藏
点赞数 1
分类专栏： Redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40149557/article/details/88936134
版权
  1. pom文件引入redis客户端，springboot对jedis和lettuce进行了封装。springboot2.x以前的版本默认使用jedis，2.x以后的版本默认使用lettuce。
//  pom文件
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
  1. redis配置
# Redis配置
# 连接URL
spring.redis.host=192.168.216.128
# 端口号
spring.redis.port=6379
# 以毫秒为单位的连接超时。
spring.redis.timeout=1000
# Redis默认情况下有16个分片，这里配置具体使用的分片，默认是0
spring.redis.database=0
# 池在给定时间可以分配的最大连接数。使用负值无限制。
spring.redis.pool.max-active=40
# 池中“空闲”连接的最大数量。使用负值表示无限数量的空闲连接。
spring.redis.pool.max-idle=20
# 连接分配在池被耗尽时抛出异常之前应该阻塞的最长时间量（以毫秒为单位）。使用负值可以无限期地阻止。
spring.redis.pool.max-wait=1000
# 目标为保持在池中的最小空闲连接数。这个设置只有在正面的情况下才有效果。
spring.redis.pool.min-idle=10
  1. redis配置类
package com.honeybee.common.configure;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.AutoConfigureAfter;
import org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration;
import org.springframework.cache.annotation.CachingConfigurerSupport;
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.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * redis配置类
 * @author HXY
 */
@Configuration
@AutoConfigureAfter(RedisAutoConfiguration.class)  //redis自动配置
public class RedisConfigure extends CachingConfigurerSupport {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        // 配置连接工厂
        redisTemplate.setConnectionFactory(factory);
        // key的序列化类型
        redisTemplate.setKeySerializer(new StringRedisSerializer());

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        // PropertyAccessor.ALL指定要序列化的域，field,get和set
        // JsonAutoDetect.Visibility.ANY表示修饰符范围，ANY是包括private和public
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        /**
         * 序列化策略：
         * 1.  默认使用JdkSerializationRedisSerializer序列化，存储的是字节数组，无法阅读，但空间小
         * 2.  StringRedisSerializer：Key或者value为字符串的场景，对：new String(bytes, charset)和string.getBytes(charset)进行封装。轻量级和高效的策略。
         * 3.  JacksonJsonRedisSerializer：将java对象序列化成json格式存储在redis中，也可以将json格式的数据转换成java对象。
         * 4.  jackson2JsonRedisSerializer： 和JacksonJsonRedisSerializer差不多
         * 5.  OxmSerializer：提供了将javabean与xml之间的转换能力
         *
         */
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);

        return redisTemplate;
    }

}
  1. redis工具类，这里封装了对key和Sring类型的操作。后续补充。
package com.honeybee.utils;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

/**
 * redis工具类
 * @author HXY
 * @version 1.0
 */
@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate redisTemplate;
    
    // 默认过期时间 单位：秒
    public static final long DEFAULT_EXPIRE_TIME = 24 * 60 * 60;
    /**************************key的操作**************************/

    /**
     * del
     * @param key
     */
    public void delete(String key) {
        redisTemplate.delete(key);
    }

    /**
     * del
     * @param keys key集合
     */
    public void delete(Collection<String> keys) {
        redisTemplate.delete(keys);
    }

    /**
     * exists
     * @param key key
     * @return 判断结果
     */
    public boolean exists(String key) {
        return redisTemplate.hasKey(key);
    }

    /**
     * expire
     * @param key key
     * @param timeout 过期时间
     * @param unit 时间粒度
     * @return 结果
     */
    public boolean expire(String key, long timeout, TimeUnit unit) {
        return redisTemplate.expire(key, timeout, unit);
    }

    /**
     * ttl
     * @param key key
     * @return 结果
     */
    public Long ttl(String key) {
        return redisTemplate.getExpire(key);
    }

    /**
     * persist
     * @param key
     * @return 结果
     */
    public boolean persist(String key) {
        return redisTemplate.persist(key);
    }

    /**
     * keys
     * @param pattern
     * @return values
     */
    public Set<String> keys(String pattern) {
        return redisTemplate.keys(pattern);
    }

    /**************************String的操作**************************/

    /**
     * set
     * @param key
     * @param value
     */
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * get
     * @param key key
     * @return value
     */
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * mGet
     * @param keys keys
     * @return values
     */
    public List<String> mGet(Collection<String> keys) {
        return redisTemplate.opsForValue().multiGet(keys);
    }

    /**
     * getRange
     * @param key key
     * @param start 起始偏移量
     * @param end 结束偏移量
     * @return value
     */
    public String getRange(String key, long start, long end) {
        return redisTemplate.opsForValue().get(key, start, end);
    }

    /**
     * strLen
     * @param key key
     * @return 长度
     */
    public Long strLen(String key) {
        return redisTemplate.opsForValue().size(key);
    }

    /**
     * incrby
     * @param key key
     * @param increment 增长量
     * @return 增长后的value
     */
    public Long incrBy(String key, long increment) {
        return redisTemplate.opsForValue().increment(key, increment);
    }

    /**
     * append
     * @param key
     * @param value
     * @return
     */
    public Integer append(String key, String value) {
        return redisTemplate.opsForValue().append(key, value);
    }

    /**************************Hash的操作**************************/

    /**
     * hSet
     * @param key key
     * @param field field
     */
    public void hSet(String key, Object field, Object value) {
        redisTemplate.opsForHash().put(key, field, value);
    }

    /**
     * hmSet
     * @param key key
     * @param field field-value
     */
    public void hmSet(String key, Map<String, String> field) {
        redisTemplate.opsForHash().putAll(key, field);
    }

    /**
     * hGet
     * @param key key
     * @param field field
     * @return value
     */
    public Object hGet(String key, String field) {
        return redisTemplate.opsForHash().get(key, field);
    }

    /**
     * hGetAll
     * @param key key
     * @param fields fields
     * @return values
     */
    public List<Object> hGetAll(String key, Collection<Object> fields) {
        return redisTemplate.opsForHash().multiGet(key, fields);
    }

    /**
     * hDel
     * @param key key
     */
    public void hDel(String key, Object... fields) {
        redisTemplate.opsForHash().delete(key, fields);
    }

    /**
     * hKeys
     * @param key
     * @return fields
     */
    public Set<Object> hKeys(String key) {
        return redisTemplate.opsForHash().keys(key);
    }

    /**
     * hVals
     * @param key key
     * @return values
     */
    public List<Object> hVals(String key) {
        return redisTemplate.opsForHash().values(key);
    }

    /**
     * hExists
     * @param key key
     * @param field field
     * @return 结果
     */
    public boolean hExists(String key, Object field) {
        return redisTemplate.opsForHash().hasKey(key, field);
    }

    /**
     * hLen
     * @param key key
     * @return length
     */
    public Long hLen(String key) {
        return redisTemplate.opsForHash().size(key);
    }
}

文章有部分参考自网上博客和代码。这里的代码全部托管在github：(https://github.com/HXY-0227/honeybee)，测试可行，欢迎批评指正。

半__夏
关注
专栏目录
spring boot 整合 Redis
m0_47360542的博客
07-24 1106
spring boot 整合 Redis及其注意点
Spring Boot整合redis
08-24
以上就是Spring Boot整合Redis的相关知识点，包括配置、数据操作、模板引擎Thymeleaf、数据源Druid、声明式事务管理和Redis事务的使用。通过这些知识，你可以构建一个具备数据缓存能力的Web应用。
关于springboot和spring整合redis
weixin_45390688的博客
06-03 166
扩展：关于redis如何设置密码 1.可以在redis.windows.conf中设置requirepass参数，例如将密码设置为foobared 2.在启动的时候将redis的配置文件加载启动，例如在window中的redis服务器，redis-server.exe redis.windows.conf 一、关于springboot整合redis 1.在pom文件中引入依赖 <dependency> <groupId>org.springframewo
applicationContext-redis
weixin_43292547的博客
04-22 440
/xml配置文件/redis的配置/applicationContext-redis.xml<?xmlversion="1.0"encoding="UTF-8"?> <beansxmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSche...
applicationContext-redis-cluster
weixin_43292547的博客
05-05 198
/xml配置文件/其他配置/linux集群配置/redis-cluster配置/applicationContext-redis-cluster.xml<?xmlversion="1.0"encoding="UTF-8"?> <beansxmlns="http://www.springframework.org/schema/beans" xmlns:xsi="ht...
redis操作数据(2) applicationContext-redis.xml
ninth_spring的博客
12-25 278
<?xml version="1.0" encoding="UTF-8"?> <context:property-placeholder location="classpath*:*.properties" /> <!-- redis 相关配置 --> <bean id="poolConfig" class="redis.clients.jedis.Je...
redis与Spring集成
提炼技能，形成智慧
05-22 3383
redis与Spring集成比较简单，本文不涉及Spring的一些基本概念，读都需先具备Spring的相关知识。 先在maven中添加依赖 pom.xml redis.clients jedis 2.0.0 applicationContext-redis.xml加入你的Spring context <beans xmlns="http://www
Spring boot 整合 redis
06-15
Spring boot 整合 redis 在redis 中填写配置信息，就可以测试存取值
Spring Boot整合Redis实现发布/订阅功能教程配套源码
06-10
Redis作为一个高性能的内存数据存储，除了支持缓存和持久化数据，它还有很多功能，如：在博主分享的上一篇文章中，我们介绍了使用Redis实现的延迟队列功能 【Spring Boot整合Redis通过Zset数据类型+定时任务实现延迟...
Spring Boot 整合 Redis.docx
11-20
以下是如何在Spring Boot中整合Redis的详细步骤： ### 1. 安装Redis 首先，你需要在本地安装Redis服务器。你可以从官方下载页面（https://redis.io/download）获取最新版本的Redis。安装过程非常简单，通常包括...
applicationContext-redis.xml配置文件
aikong3218的博客
09-24 858
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springfra...
Spring集成Redis
weixin_43781108的博客
03-05 446
properties配置文件 redis.host = 127.0.0.1 redis.port = 6379 redis.pass = 123456 redis.maxIdle = 200 redis.maxActive = 1024 redis.maxWait = 10000 redis.testOnBorrow = true spring配置 &lt;beans xmlns="ht...
Spring-data-redis配置及使用示例
Flyer的后花园
05-22 4581
Spring-data-redis配置及使用示例 一、添加maven依赖 org.springframework.data spring-data-redis 1.5.0.RELEASE provided redis.clients jedis 2.6.3 provided org.apache.commons commons-pool2 2.3 provided org.
springboot+redisson启动报错
weixin_43598996的博客
07-29 1036
springboot+redisson启动报错
19.Elasticsearch更新文档5---局部更新4---官方文档翻译
IT云清
05-31 2154
由于网上没有找到5.5版本的资料，很多资料都是2.x版本的，更新时语法差异较大，所以我这里翻译一下官方文档的这一部分内容。翻译时，示例代码均替换为我实践中的真实代码，这样确保了本文档的准确性。 - 本文版本：5.5 - 官方文档原文路径：Elasticsearch Reference [5.5] » Document APIs » Update API - 官方文档原文地址：点击跳转 以下...
深入浅出spring-data-elasticsearch系列 – 概述及入门(二).md
凌晨四点的洛杉矶
10-01 291
spring-data-elasticsearch 是什么？ Spring Data：Spring Data 基于 Spring 为数据访问提供一种相似且一致性的编程模型，并保存底层数据存储的。 Spring Data Elasticsearch：spring-data-elasticsearch 是 Spring Data 的 Community modules 之一，是 S...
redis如何配置standAlone版的jedisPool
gezilan的博客
08-27 6066
从JedisConnectionFactory的构造函数看 public JedisConnectionFactory(RedisStandaloneConfiguration standaloneConfig) { this((RedisStandaloneConfiguration)standaloneConfig, (JedisClientConfiguration)(new J...
5.C-Demo-排序
最新发布
09-20
5.C-Demo-排序_快速排序
java-ssm942基于ssm的保险公司营销管理系统+jsp程序源码数据库含论文.rar
09-20
本系统基于SSM(Spring+SpringMVC+MyBatis)框架,适用于毕业设计， 基于B/S模式, mysql数据库,感兴趣的朋友们可以下载研究一下。 后端采用java语言，ssm框架，mybatis操作数据源，使用软件：idea,eclipse、MySQL。完成了用户登录管理等模块的设计与实现。完成了系统数据库的设计，并基于MySQL数据库管理系统 jdk版本:jdk1.8+ 前端：jsp 开发工具：IDEA 或者eclipse都支持 编程语言: java 框架支持：ssm 数据库: mysql 版本不限 数据库工具：Navicat/SQLyog都可以 详细技术：java+ssm+jsp+MYSQL+MAVEN
Spring Boot整合Redis实战指南
"本文档详细介绍了如何在Spring Boot项目中集成Redis，...Spring Boot整合Redis不仅可以提升应用性能，还能利用Redis丰富的数据结构和特性来解决复杂的应用场景。正确配置和使用Redis，可以显著优化应用的架构和性能。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

半__夏

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

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

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

打赏作者

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

抵扣说明：

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

余额充值