好兔宠物网
您的当前位置：首页正文

springboot整合redis

来源：好兔宠物网
springboot整合redis

简介：

在SpringBoot中⼀般使⽤RedisTemplate提供的⽅法来操作Redis。那么使⽤SpringBoot整合Redis需要 那些步骤呢。

JedisPoolConfig (这个是配置连接池)

RedisConnectionFactory 这个是配置连接信息，这⾥的RedisConnectionFactory是⼀个接 ⼝，我们需要使⽤它的实现类，在SpringD Data Redis⽅案中提供了以下四种⼯⼚模型：JredisConnectionFactoryJedisConnectionFactoryLettuceConnectionFactorySrpConnectionFactory

RedisTemplate 基本操作

导⼊依赖

org.springframework.boot

spring-boot-starter-data-redis

yml配置

spring: redis:

host: 127.0.0.1 port: 6379

password: 123456 jedis: pool:

max-active: 8 max-wait: -1ms max-idle: 500 min-idle: 0 lettuce:

shutdown-timeout: 0ms

测试

@SpringBootTest

class SpringbootRedisApplicationTests { @Autowired

private RedisTemplate redisTemplate;

@Test

void contextLoads() {

redisTemplate.opsForValue().set(\"myKey\

System.out.println(redisTemplate.opsForValue().get(\"myKey\")); }}

分析 RedisAutoConfiguration ⾃动配置类

@Configuration(proxyBeanMethods = false)@ConditionalOnClass(RedisOperations.class)

@EnableConfigurationProperties(RedisProperties.class)

@Import({LettuceConnectionConfiguration.class, JedisConnectionConfiguration.class})public class RedisAutoConfiguration { @Bean

@ConditionalOnMissingBean(name = \"redisTemplate\")

public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {

RedisTemplate template = new RedisTemplate<>(); template.setConnectionFactory(redisConnectionFactory); return template; }

@Bean

@ConditionalOnMissingBean

public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory

redisConnectionFactory) throws UnknownHostException { StringRedisTemplate template = new StringRedisTemplate(); template.setConnectionFactory(redisConnectionFactory); return template; }}

通过源码可以看出，SpringBoot⾃动帮我们在容器中⽣成了⼀个RedisTemplate和⼀个 StringRedisTemplate。

但是，这个RedisTemplate的泛型是，写代码不⽅便，需要写好多类型转换的代码；我 们需要⼀个泛型为形式的RedisTemplate。并且，这个RedisTemplate没有设置数据存在Redis时，key及value的序列化⽅式。

看到这个@ConditionalOnMissingBean注解后，就知道如果Spring容器中有了RedisTemplate对象了， 这个⾃动配置的RedisTemplate不会实例化。因此我们可以直接⾃⼰写个配置类，配置 RedisTemplate。

既然⾃动配置不好⽤，就重新配置⼀个RedisTemplate

package com.kuang.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;import com.fasterxml.jackson.annotation.PropertyAccessor;import com.fasterxml.jackson.databind.ObjectMapper;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;

@Configuration

public class RedisConfig { @Bean

@SuppressWarnings(\"all\")

public RedisTemplate redisTemplate(RedisConnectionFactory factory) { RedisTemplate template = new RedisTemplate(); template.setConnectionFactory(factory);

Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class); ObjectMapper om = new ObjectMapper();

om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY); om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL); jackson2JsonRedisSerializer.setObjectMapper(om); StringRedisSerializer stringRedisSerializer = new StringRedisSerializer(); // key采⽤String的序列化⽅式

template.setKeySerializer(stringRedisSerializer); // hash的key也采⽤String的序列化⽅式

template.setHashKeySerializer(stringRedisSerializer); // value序列化⽅式采⽤jackson

template.setValueSerializer(jackson2JsonRedisSerializer); // hash的value序列化⽅式采⽤jackson

template.setHashValueSerializer(jackson2JsonRedisSerializer); template.afterPropertiesSet(); return template; }}

写⼀个Redis⼯具类（直接⽤RedisTemplate操作Redis，需要很多⾏代码，因此直接封装好⼀个 RedisUtils，这样写代码更⽅便点。这个RedisUtils交给Spring容器实例化，使⽤时直接注解注⼊。）

package com.kuang.utils;

import org.springframework.beans.factory.annotation.Autowired;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.stereotype.Component;import org.springframework.util.CollectionUtils;import java.util.List;import java.util.Map;import java.util.Set;

import java.util.concurrent.TimeUnit;

@Component

public final class RedisUtil { @Autowired

private RedisTemplate redisTemplate;

// =============================common============================ /**

* 指定缓存失效时间 *

* @param key 键

* @param time 时间(秒) */

public boolean expire(String key, long time) { try {

if (time > 0) {

redisTemplate.expire(key, time, TimeUnit.SECONDS); }

return true;

} catch (Exception e) { e.printStackTrace(); return false; } }

/**

/**

* 根据key 获取过期时间 *

* @param key 键 不能为null

* @return 时间(秒) 返回0代表为永久有效 */

public long getExpire(String key) {

return redisTemplate.getExpire(key, TimeUnit.SECONDS); }

/**

* 判断key是否存在 *

* @param key 键

* @return true 存在 false不存在 */

public boolean hasKey(String key) { try {

return redisTemplate.hasKey(key); } catch (Exception e) { e.printStackTrace(); return false; } }

/**

* 删除缓存 *

* @param key 可以传⼀个值 或多个 */

@SuppressWarnings(\"unchecked\") public void del(String... key) {

if (key != null && key.length > 0) { if (key.length == 1) {

redisTemplate.delete(key[0]); } else {

redisTemplate.delete(CollectionUtils.arrayToList(key)); } } }

// ============================String============================= /**

* 普通缓存获取 *

* @param key 键 * @return 值 */

public Object get(String key) {

return key == null ? null : redisTemplate.opsForValue().get(key); }

/**

* 普通缓存放⼊ *

* @param key 键 * @param value 值

* @return true成功 false失败 */

public boolean set(String key, Object value) { try {

redisTemplate.opsForValue().set(key, value); return true;

} catch (Exception e) { e.printStackTrace(); return false; } }

/**

* 普通缓存放⼊并设置时间 *

* @param key 键 * @param value 值

* @param time 时间(秒) time要⼤于0 如果time⼩于等于0 将设置⽆限期 * @return true成功 false 失败 */

public boolean set(String key, Object value, long time) { try {

if (time > 0) {

redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS); } else {

set(key, value); }

return true;

} catch (Exception e) { e.printStackTrace(); return false; }

} }

/** * 递增 *

* @param key 键

* @param delta 要增加⼏(⼤于0) */

public long incr(String key, long delta) { if (delta < 0) {

throw new RuntimeException(\"递增因⼦必须⼤于0\"); }

return redisTemplate.opsForValue().increment(key, delta); }

/** * 递减 *

* @param key 键

* @param delta 要减少⼏(⼩于0) */

public long decr(String key, long delta) { if (delta < 0) {

throw new RuntimeException(\"递减因⼦必须⼤于0\"); }

return redisTemplate.opsForValue().increment(key, -delta); }

// ================================Map================================= /**

* HashGet *

* @param key 键 不能为null * @param item 项 不能为null */

public Object hget(String key, String item) {

return redisTemplate.opsForHash().get(key, item); }

/**

* 获取hashKey对应的所有键值 *

* @param key 键

* @return 对应的多个键值 */

public Map hmget(String key) { return redisTemplate.opsForHash().entries(key); }

/**

* HashSet *

* @param key 键

* @param map 对应多个键值 */

public boolean hmset(String key, Map map) { try {

redisTemplate.opsForHash().putAll(key, map); return true;

} catch (Exception e) { e.printStackTrace(); return false; } }

/**

* HashSet 并设置时间 *

* @param key 键

* @param map 对应多个键值 * @param time 时间(秒)

* @return true成功 false失败 */

public boolean hmset(String key, Map map, long time) { try {

redisTemplate.opsForHash().putAll(key, map); if (time > 0) {

expire(key, time); }

return true;

} catch (Exception e) { e.printStackTrace(); return false; } }

/**

* 向⼀张hash表中放⼊数据,如果不存在将创建 *

*

* @param key 键 * @param item 项 * @param value 值

* @return true 成功 false失败 */

public boolean hset(String key, String item, Object value) { try {

redisTemplate.opsForHash().put(key, item, value); return true;

} catch (Exception e) { e.printStackTrace(); return false; } }

/**

* 向⼀张hash表中放⼊数据,如果不存在将创建 *

* @param key 键 * @param item 项 * @param value 值

* @param time 时间(秒) 注意:如果已存在的hash表有时间,这⾥将会替换原有的时间 * @return true 成功 false失败 */

public boolean hset(String key, String item, Object value, long time) { try {

redisTemplate.opsForHash().put(key, item, value); if (time > 0) {

expire(key, time); }

return true;

} catch (Exception e) { e.printStackTrace(); return false; } }

/**

* 删除hash表中的值 *

* @param key 键 不能为null

* @param item 项 可以使多个 不能为null */

public void hdel(String key, Object... item) {

redisTemplate.opsForHash().delete(key, item); }

/**

* 判断hash表中是否有该项的值 *

* @param key 键 不能为null * @param item 项 不能为null * @return true 存在 false不存在 */

public boolean hHasKey(String key, String item) {

return redisTemplate.opsForHash().hasKey(key, item); }

/**

* hash递增 如果不存在,就会创建⼀个 并把新增后的值返回 *

* @param key 键 * @param item 项

* @param by 要增加⼏(⼤于0) */

public double hincr(String key, String item, double by) {

return redisTemplate.opsForHash().increment(key, item, by); }

/**

* hash递减 *

* @param key 键 * @param item 项

* @param by 要减少记(⼩于0) */

public double hdecr(String key, String item, double by) {

return redisTemplate.opsForHash().increment(key, item, -by); }

// ============================set============================= /**

* 根据key获取Set中的所有值 *

* @param key 键 */

public Set sGet(String key) { try {

return redisTemplate.opsForSet().members(key);

return redisTemplate.opsForSet().members(key); } catch (Exception e) { e.printStackTrace(); return null; } }

/**

* 根据value从⼀个set中查询,是否存在 *

* @param key 键 * @param value 值

* @return true 存在 false不存在 */

public boolean sHasKey(String key, Object value) { try {

return redisTemplate.opsForSet().isMember(key, value); } catch (Exception e) { e.printStackTrace(); return false; } }

/**

* 将数据放⼊set缓存 *

* @param key 键

* @param values 值 可以是多个 * @return 成功个数 */

public long sSet(String key, Object... values) { try {

return redisTemplate.opsForSet().add(key, values); } catch (Exception e) { e.printStackTrace(); return 0; } }

/**

* 将set数据放⼊缓存 *

* @param key 键

* @param time 时间(秒)

* @param values 值 可以是多个 * @return 成功个数 */

public long sSetAndTime(String key, long time, Object... values) { try {

Long count = redisTemplate.opsForSet().add(key, values); if (time > 0)

expire(key, time); return count;

} catch (Exception e) { e.printStackTrace(); return 0; } }

/**

* 获取set缓存的长度 *

* @param key 键 */

public long sGetSetSize(String key) { try {

return redisTemplate.opsForSet().size(key); } catch (Exception e) { e.printStackTrace(); return 0; } }

/**

* 移除值为value的 *

* @param key 键

* @param values 值 可以是多个 * @return 移除的个数 */

public long setRemove(String key, Object... values) { try {

Long count = redisTemplate.opsForSet().remove(key, values); return count;

} catch (Exception e) { e.printStackTrace(); return 0; } }

// ===============================list=================================

// ===============================list================================= /**

* 获取list缓存的内容 *

* @param key 键 * @param start 开始

* @param end 结束 0 到 -1代表所有值 */

public List lGet(String key, long start, long end) { try {

return redisTemplate.opsForList().range(key, start, end); } catch (Exception e) { e.printStackTrace(); return null; } }

/**

* 获取list缓存的长度 *

* @param key 键 */

public long sGetSetSize(String key) { try {

return redisTemplate.opsForSet().size(key); } catch (Exception e) { e.printStackTrace(); return 0; } }

/**

* 移除值为value的 *

* @param key 键

* @param values 值 可以是多个 * @return 移除的个数 */

public long setRemove(String key, Object... values) { try {

Long count = redisTemplate.opsForSet().remove(key, values); return count;

} catch (Exception e) { e.printStackTrace(); return 0; } }

// ===============================list================================= /**

* 获取list缓存的内容 *

* @param key 键 * @param start 开始

* @param end 结束 0 到 -1代表所有值 */

public List lGet(String key, long start, long end) { try {

return redisTemplate.opsForList().range(key, start, end); } catch (Exception e) { e.printStackTrace(); return null; } }

/**

* 获取list缓存的长度 *

* @param key 键 */

public long lGetListSize(String key) { try {

return redisTemplate.opsForList().size(key); } catch (Exception e) { e.printStackTrace(); return 0; } }

/**

* 移除值为value的 *

* @param key 键

* @param values 值 可以是多个 * @return 移除的个数 */

public long setRemove(String key, Object... values) { try {

Long count = redisTemplate.opsForSet().remove(key, values);

Long count = redisTemplate.opsForSet().remove(key, values); return count;

} catch (Exception e) { e.printStackTrace(); return 0; } }

// ===============================list================================= /**

* 获取list缓存的内容 *

* @param key 键 * @param start 开始

* @param end 结束 0 到 -1代表所有值 */

public List lGet(String key, long start, long end) { try {

return redisTemplate.opsForList().range(key, start, end); } catch (Exception e) { e.printStackTrace(); return null; } }

/**

* 获取list缓存的长度 *

* @param key 键 */

public long lGetListSize(String key) { try {

return redisTemplate.opsForList().size(key); } catch (Exception e) { e.printStackTrace(); return 0; } }

/**

* 通过索引 获取list中的值 *

* @param key 键

* @param index 索引 index>=0时， 0 表头，1 第⼆个元素，依次类推；index<0 * 时，-1，表尾，-2倒数第⼆个元素，依次类推 */

public Object lGetIndex(String key, long index) { try {

return redisTemplate.opsForList().index(key, index); } catch (Exception e) { e.printStackTrace(); return null; } }

/**

* 将list放⼊缓存 *

* @param key 键 * @param value 值 */

public boolean lSet(String key, Object value) { try {

redisTemplate.opsForList().rightPush(key, value); return true;

} catch (Exception e) { e.printStackTrace(); return false; } }

/**

* 将list放⼊缓存 *

* @param key 键 * @param value 值

* @param time 时间(秒) */

public boolean lSet(String key, Object value, long time) { try {

redisTemplate.opsForList().rightPush(key, value); if (time > 0)

expire(key, time); return true;

} catch (Exception e) { e.printStackTrace(); return false; } }

/**

* 将list放⼊缓存 *

* @param key 键 * @param value 值 * @return */

public boolean lSet(String key, List value) { try {

redisTemplate.opsForList().rightPushAll(key, value); return true;

} catch (Exception e) { e.printStackTrace(); return false; } }

/**

* 将list放⼊缓存 *

* @param key 键 * @param value 值

* @param time 时间(秒) * @return */

public boolean lSet(String key, List value, long time) { try {

redisTemplate.opsForList().rightPushAll(key, value); if (time > 0)

expire(key, time); return true;

} catch (Exception e) { e.printStackTrace(); return false; } }

/**

* 根据索引修改list中的某条数据 *

* @param key 键 * @param index 索引 * @param value 值 * @return */

public boolean lUpdateIndex(String key, long index, Object value) { try {

redisTemplate.opsForList().set(key, index, value); return true;

} catch (Exception e) { e.printStackTrace(); return false; } }

/**

* 移除N个值为value *

* @param key 键

* @param count 移除多少个 * @param value 值 * @return 移除的个数 */

public long lRemove(String key, long count, Object value) { try {

Long remove = redisTemplate.opsForList().remove(key, count, value); return remove;

} catch (Exception e) { e.printStackTrace(); return 0; } }}

声明：摘录狂神说笔记

因篇幅问题不能全部显示，请点此查看更多更全内容

查看全文

Copyright © 2019- howto1234.com 版权所有
湘ICP备2023017662号-2

Top