springboot集成redis（springboot集成es）

本篇文章给大家谈谈springboot集成redis，以及springboot集成es对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。

本文目录一览：

• 1、springboot项目集成 redis详解
• 2、springboot 集成redis 和http请求
• 3、3分钟搞定springboot整合redis
• 4、SpringBoot集成redisson操作redis
• 5、Spring Boot如何整合Redis

springboot项目集成 redis详解

遵循我们springboot 开发三板斧

这里我们使自己的redis配置类，里面已经对默认的序列化方式做了修改

可以直接用于工作使用

指定我们写好的redisTemplate即可，一把工作中redis的api会封装成工具类让碧贺使用

到这里，慧或我们就可以在坦派项目中使用redis了

springboot 集成redis 和http请求

springboot 集成redis ，使用原生的jedis ，有点繁琐，本身springboot 已经集成了 redis并有 redisTemplate 可以使用，不过还是多少有点坑，需要提前说明的

首先要引入jar包依赖

然后在 application 配置文件中 配置redis 的连接项

接着最简单的使用就是

或者

如果你配置环境对的话，redis 就可以使用了

springboot 在启动会自己初始化 RedisConnectionFactory redisConnectionFactory

这个对象，然后注入 ，并初始化化一个 RedisTemplate 对象，这样感觉无缝连接到redis了，但是吧，平时没问题，一旦时间久了就会出问题派陪闹，就是redis 的序列化和反序列化问题，之前没有在log 里捕捉 这个反序列化的异常，后来捕捉到这个异常，

springboot在反序列话 redis，有点bug

如何破解 ，就是在初始化 RedisTemplate 这个bean 的时候就配置一下序列化和反序列化的属性，

声明一个 RedisService 公共类，并加 @Component 注解， 在这个里面初始化化 RedisTemplate，需要注意的是 就是你的key 对应的value存的是什么类型，如果是String

，就用new StringRedisSerializer（），如果是对象类 json ，就使用

new Jackson2JsonRedisSerializer(Object.class);或者

new GenericJackson2JsonRedisSerializer())，不然这个还会报错，

然后我们在这个里面 声明 get set exist remove redis key 的乱铅操作

最后使用 redis 的时候 ，直接尘罩注入 RedisService 就可以了

RedisService

另外 springboot 请求外部http的时候使用 RestTemplate 也有一个坑，就是默认的request buffer不释放，导致时间越久，请求头巨大，最后 就无法请求外部了，所以 可以这样使用

3分钟搞定springboot整合redis

不多说直接上代码：

!-- redis --

dependency

groupIdorg.springframework.boot/groupId

artifactIdspring-boot-starter-data-redis/artifactId

exclusions

exclusion

groupIdredis.clients/groupId

artifactIdjedis/artifactId

/exclusion

exclusion

groupIdio.lettuce/groupId

artifactIdlettuce-core/artifactId

/exclusion

/exclusions

/dependency

!-- 添加jedis客户端 --

dependency

groupIdredis.clients/groupId

artifactIdjedis/artifactId

/dependency

!--spring2.0集成redis所需common-pool2--

!-- 必须加上，jedis依赖此 --

dependency

groupIdorg.apache.commons枯卖/groupId

artifactIdcommons-pool2/artifactId

version2.5.0/version

/dependency

!-- 将作为Redis对象序列化器 --

dependency

groupIdcom.alibaba/groupId

artifactIdfastjson/artifactId

version1.2.47/version

/dependency

#Matser的ip地址

redis.hostName=172.16.44.148

#端口号

redis.port=6379

#如果有密码

redis.password=

#客户端超时时间单位是毫秒 默认是2000

redis.timeout=10000

#最大空闲数

redis.maxIdle=300

#连接池的最大数据库连接数。设为0表示无限制,如果是jedis 2.4以后用redis.maxTotal

#redis.maxActive=600

#控制一个pool可分配多少个jedis实例,用来替换上面的redis.maxActive,如果是jedis 2.4以后用该属性

redis.maxTotal=1000

#最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。

redis.maxWaitMillis=1000

#连接的最小空闲卖没时间没配逗 默认1800000毫秒(30分钟)

redis.minEvictableIdleTimeMillis=300000

#每次释放连接的最大数目,默认3

redis.numTestsPerEvictionRun=1024

#逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1

redis.timeBetweenEvictionRunsMillis=30000

#是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个

redis.testOnBorrow=true

#在空闲时检查有效性, 默认false

redis.testWhileIdle=true

package com.junsi.demo.config;

import org.springframework.beans.factory.annotation.Value;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import org.springframework.context.annotation.PropertySource;

import org.springframework.data.redis.connection.RedisConnectionFactory;

import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;

import org.springframework.data.redis.core.RedisTemplate;

import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;

import org.springframework.data.redis.serializer.StringRedisSerializer;

import com.junsi.demo.utils.RedisUtil;

import redis.clients.jedis.JedisPoolConfig;

/**

* Redis配置类

* @author pzx

* 2019年6月8日

*/

@Configuration

@PropertySource("classpath:redis.properties")

public class RedisConfig {

@Value("${redis.maxIdle}")

private Integer maxIdle;

@Value("${redis.maxTotal}")

private Integer maxTotal;

@Value("${redis.maxWaitMillis}")

private Integer maxWaitMillis;

@Value("${redis.minEvictableIdleTimeMillis}")

private Integer minEvictableIdleTimeMillis;

@Value("${redis.numTestsPerEvictionRun}")

private Integer numTestsPerEvictionRun;

@Value("${redis.timeBetweenEvictionRunsMillis}")

private long timeBetweenEvictionRunsMillis;

@Value("${redis.testOnBorrow}")

private boolean testOnBorrow;

@Value("${redis.testWhileIdle}")

private boolean testWhileIdle;

@Value("${spring.redis.cluster.nodes}")

private String clusterNodes;

@Value("${spring.redis.cluster.max-redirects}")

private Integer mmaxRedirectsac;

/**

* JedisPoolConfig 连接池

* @return

*/

@Bean

public JedisPoolConfig jedisPoolConfig() {

JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();

// 最大空闲数

jedisPoolConfig.setMaxIdle(maxIdle);

// 连接池的最大数据库连接数

jedisPoolConfig.setMaxTotal(maxTotal);

// 最大建立连接等待时间

jedisPoolConfig.setMaxWaitMillis(maxWaitMillis);

// 逐出连接的最小空闲时间 默认1800000毫秒(30分钟)

jedisPoolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);

// 每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3

jedisPoolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);

// 逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1

jedisPoolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);

// 是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个

jedisPoolConfig.setTestOnBorrow(testOnBorrow);

// 在空闲时检查有效性, 默认false

jedisPoolConfig.setTestWhileIdle(testWhileIdle);

return jedisPoolConfig;

}

/**

* @param jedisPoolConfig

* @return

*/

@Bean

public JedisConnectionFactory JedisConnectionFactory(JedisPoolConfig jedisPoolConfig){

JedisConnectionFactory JedisConnectionFactory = new JedisConnectionFactory(jedisPoolConfig);

//连接池

JedisConnectionFactory.setPoolConfig(jedisPoolConfig);

//IP地址

JedisConnectionFactory.setHostName("172.16.44.148");

//端口号

JedisConnectionFactory.setPort(6379);

//如果Redis设置有密码

//JedisConnectionFactory.setPassword(password);

//客户端超时时间单位是毫秒

JedisConnectionFactory.setTimeout(5000);

return JedisConnectionFactory;

}

/**

* 实例化 RedisTemplate 对象

*

* @return

*/

@Bean

public RedisTemplateString, Object functionDomainRedisTemplate(RedisConnectionFactory redisConnectionFactory) {

RedisTemplateString, Object redisTemplate = new RedisTemplate();

initDomainRedisTemplate(redisTemplate, redisConnectionFactory);

return redisTemplate;

}

/**

* 设置数据存入 redis 的序列化方式,并开启事务

*

* @param redisTemplate

* @param factory

*/

private void initDomainRedisTemplate(RedisTemplateString, Object redisTemplate, RedisConnectionFactory factory) {

//如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！

redisTemplate.setKeySerializer(new StringRedisSerializer());

redisTemplate.setHashKeySerializer(new StringRedisSerializer());

redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());

redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());

// 开启事务

redisTemplate.setEnableTransactionSupport(true);

redisTemplate.setConnectionFactory(factory);

}

@Bean(name = "redisUtil")

public RedisUtil redisUtil(RedisTemplateString, Object redisTemplate) {

RedisUtil redisUtil = new RedisUtil();

redisUtil.setRedisTemplate(redisTemplate);

return redisUtil;

}

}

SpringBoot集成redisson操作redis

每个Redisson对象实例都会有一个与之对应的Redis数据实例，可以通过调用getName方法来取得redis数据实例的名称(key)，所有于Redis key相关的操作都归纳在RKeys这个接口里。

具体demo

其中，getKeysByPattern是基于redis的scan命令实现型册。

Redisson的分布式RBucket Java对象是一种通用对象桶，可以用来存放任意类型的对象。除了同步接口外，还提供异步(Async)、反射式(Reactive)和RxJava2标准的接口。还可以通过RBuckets接口实现批量操作多个RBucket对象。

基于Redisson的分布式映射结构的RMap Java对象实现了java.util.concurrent.ConcurrentMap和java.util.Map接口，与HashMap不同的是，RMap 保持了元素的插入顺序。该对象的最大容量受Redis限制，最大元素数量是4294967295个卜薯宏。

基于Redisson的分布式Set结构的RSet Java对象实现了java.util.Set接口，通过元素的互相状态比较保证了每个元素的唯一性，该对象的最大容量受Redis限制，最大元素数量是4294967295个。

基于Redisson的分布式列表 List 结构的RList Java对象在实现了java.util.List接口的同时，确保了元素插手迟入时的顺序，该对象的最大容量受Redis限制，最大元素数量是4294967295个。

将上述demo放入一个API中，快速测试：

参考：

[img]

Spring Boot如何整合Redis

Spring Boot是目前非常流行的Java Web开发框架，Redis是非关系型数据库的一种，以键值对的形式存储。Spring对Redis的支持是通过Spring Data Redis来实现的，给我们提供了RedisTemplate和StringRedisTemplate两种模板来操作数据。Spring Boot框架也提供了对Redis的支持，下面我们来讲一下Spring Boot框架整合Redis的步骤。

工具/材料

IntelliJ IDEA

Spring Boot整合Redis我们需要添加依赖的jar包，spring-boot-starter-data-redis中包含spring和redis相关的jar包，jedis作为redis的客户端也需要添加到工程中，Spring Boot的版本信息在父pom中已指定，子模块中的spring相关的jar包无需另外指定。

dependency

groupIdorg.springframework.boot/groupId

artifactIdspring-boot-starter-data-redis/artifactId

/dependency

dependency

groupIdredis.clients/groupId

artifactIdjedis/artifactId

version3.0.0-m1/version

/dependency

Spring Boot会根据application.properties中的配置对Redis的属性进行自动配置，并注入到RedisProperties类中。在application.properties配置文件燃桐宴中这些属性都是以spring.redis为前缀的，值得注意的是在Spring Boot 1.5.x版本中默认的Redis客户端是jedis，因此在配置文件中无需指定，如下图所示。

Spring Boot 1.5.x版本的整合配置网上可以搜索大量的文章，然而Spring Boot 2.x版本的整合资料却非常少，甚至提供的配置不能正常使用，因此本文主要讲解Spring Boot 2.x整合Redis以及Redis的使用情况。spring-boot 2.x版本有jedis和lettuce两种客户端，因此我们必须要去指定使用哪一种客户端，两个客户端的配置如下图所示，本文使用的是Jedis客户端连接池，具体的配置如下。

# Redis数据库索引（默认为0）

spring.redis.database=0

# Redis服务器地址

spring.redis.host=127.0.0.1

# Redis服务器连接端口

spring.redis.port=6379

# Redis服务器连接密码（默认为空）

spring.redis.password=xylx1.t!@#

# 配置jedis连接池

# 连接池最大连接数（使用负值表示没有限制）

spring.redis.jedis.pool.max-active=8

# 连接池最大阻塞等待时间（使用负值表示没有限制）

spring.redis.jedis.pool.max-wait=-1ms

# 连接池中的最大空闲连接

spring.redis.jedis.pool.max-idle=8

# 连接池中的最小空闲连接

spring.redis.jedis.pool.min-idle=0

# 连接超时时间（毫秒）

spring.redis.timeout=5000ms

由配置我们可以看到spring-boot 2.x版本时间设置需要加单位ms，因为参数的类型为Duration。另外spring.redis.timeout尽轮陵量不要皮银配置0，否则可能会出现io.lettuce.core.RedisCommandTimeoutException: Command timed out超时错误。

配置文件编辑完成后，我们开始编写代码实现Redis数据的存储和读取。我们创建一个RedisUtil工具类，该类使用@Component注解表示交由Spring管理，StringRedisTemplate是Spring提供的，可以使用@Autowired注解直接注入，接下来便可以书写存和取的代码了。

@Component

public class RedisUtil {

@Autowired

private StringRedisTemplate redisTemplate;

/**

* 存字符串

* @param key 缓存键

* @param value 缓存值

* @param expireTime过期时间(s)

*/

public void setString(String key, String value, int expireTime){

ValueOperationsString, String ops = redisTemplate.opsForValue();

if (expireTime != 0) {

ops.set(key, value, expireTime, TimeUnit.SECONDS);

} else {

ops.set(key,value);

}

}

/**

* 取字符串

* @param key 缓存键

* @return缓存值

*/

public String getString(String key){

ValueOperationsString, String ops = this.redisTemplate.opsForValue();

return ops.get(key);

}

接下来我们编写Controller层代码去调用RedisUtil工具类，实现数据的存储和读取，代码比较简单可以参考下图。若想验证Redis是否可用，还需要编写启动类，如下图所示。

由上图可看到我们编写了一个post请求用于存储字符串，get请求用于取出字符串。启动类通过main方法启动应用，接下来我们使用postman去模拟浏览器调用post和get请求，由下图可以看到Redis存储的数据成功被取出。

接下来我们介绍Jedis，这是一个封装了Redis的客户端，在Spring Boot整合Redis的基础上，可以提供更简单的API操作。因此我们需要配置JedisPool的Bean，代码如下，其中@Configuration注解表明这是一个配置类，我们在该类中注入RedisProperties，并且使用@Bean注解指定JedisPool。

@Configuration

public class RedisConfiguration {

@Autowired

private RedisProperties properties;

@Bean

public JedisPool getJedisPool(){

JedisPoolConfig config = new JedisPoolConfig();

config.setMaxIdle(properties.getJedis().getPool().getMaxIdle());

config.setMaxTotal(properties.getJedis().getPool().getMaxActive());

config.setMaxWaitMillis(properties.getJedis().getPool().getMaxWait().toMillis());

JedisPool pool = new JedisPool(config,properties.getHost(),

properties.getPort(),100,

properties.getPassword(), properties.getDatabase());

return pool;

}

}

接下来我们编辑JedisUtil工具类，通过SpringBoot容器的@Component注解来自动创建，并且注入JedisPool，使用jedisPool.getResource()方法来获取Jedis，并最终实现操作redis数据库，其代码如下。

@Component

public class JedisUtil {

@Autowired

JedisPool jedisPool;

//获取key的value值

public String get(String key) {

Jedis jedis = jedisPool.getResource();

String str = "";

try {

str = jedis.get(key);

} finally {

try {

jedis.close();

} catch (Exception e) {

e.printStackTrace();

}

}

return str;

}

public String set(String key, String value) {

Jedis jedis = jedisPool.getResource();

String str = "";

try {

str = jedis.set(key, value);

} finally {

try {

jedis.close();

} catch (Exception e) {

e.printStackTrace();

}

}

return str;

}

}

JedisUtil工具类编写完成后，我们修改之前的RedisController，并注入JedisUtil，代码如下图所示。然后再用postman分别调用post和get接口，我们可以看到成功取到了新的key的value值。

特别提示

在Spring Boot整合Redis前本机需安装Redis，另外可以使用RedisDesktopManager这个Redis这个桌面管理工具查看Redis中的数据。

关于springboot集成redis和springboot集成es的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。