SrpingBoot集成Redis

拼搏现实的明天。 2022-12-10 15:55 76阅读 0赞

**目录**

前言

环境准备

1、springBoot环境搭建

2、安装Redis

集成Redis到SpringBoot

1、pom文件中导入依赖包

2、自定义redisTemplate配置类

3、定义Redis工具类

4、自定义Json工具类

5、使用Redis

--------------------

# 前言 #

本篇博客主要描述了基于SpringBoot2.0环境，集成Redis3.2

完成SpringBoot环境下的数据往Redis数据库中的持久化功能。

# 环境准备 #

## 1、springBoot环境搭建 ##

搭建好一个SpringBoot环境，这里不细说，不懂的看springboot官网或找度娘，很容易实现。

## 2、安装Redis ##

我是在win10环境下安装的redis,直接下载redis

![20200927112115553.png][]

下载后解压，到期目录下，直接双击redis-server.exe即可启动

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l5ajEwODMxNw_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l5ajEwODMxNw_size_16_color_FFFFFF_t_70 1][]

redis默认端口6379，无密码，默认0号数据库，当然，这些都可以在配置文件中配置，这里不做深入。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l5ajEwODMxNw_size_16_color_FFFFFF_t_70 2][]

#  集成Redis到SpringBoot #

## 1、pom文件中导入依赖包 ##

*      spring-boot-starter-data-redis

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

## 2、自定义redisTemplate配置类 ##

因为牵扯到序列化等原因，因此这里需要自定义，可根据实际情况处理，当然，你也可以不做这一步。

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;
 
 import java.net.UnknownHostException;
 import java.text.SimpleDateFormat;
 
 /**
 * redis配置类
 *
 */
 @Configuration
 public class RedisConfig {
 
 //不指定id的话bean 的id就是方法名
 //返回结果就是spring中管理的bean
 @Bean
 public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
 throws UnknownHostException {
 RedisTemplate<String, Object> template = new RedisTemplate<>();
 
 //ObjectMapper 指定在转成json的时候的一些转换规则
 ObjectMapper objectMapper = new ObjectMapper();
 objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
 
 template.setConnectionFactory(redisConnectionFactory);
 Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
 //把自定义objectMapper设置到jackson2JsonRedisSerializer中（可以不设置，使用默认规则）
 jackson2JsonRedisSerializer.setObjectMapper(objectMapper);
 
 //RedisTemplate默认的序列化方式使用的是JDK的序列化
 //设置了key的序列化方式
 template.setKeySerializer(new StringRedisSerializer());
 //设置了value的序列化方式
 template.setValueSerializer(jackson2JsonRedisSerializer);
 template.setHashValueSerializer(jackson2JsonRedisSerializer);
 return template;
 }
 }

##  3、定义Redis工具类 ##

原因很简单，RedisTemplate提供了很多增、删、改、查等等的API接口，可是对于实际开发中，使用起来还是不够简洁，因而，正常的正式环境都会对其接口进行二次封装。这一步也可根据实际情况处理。

import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.data.redis.RedisConnectionFailureException;
 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;
 /**
 *
 * 基于spring和redis的redisTemplate工具类
 * 针对所有的hash 都是以h开头的方法
 * 针对所有的Set 都是以s开头的方法
 * 针对所有的List 都是以l开头的方法
 */
 @Component
 public class RedisUtil{
 Logger logger = LoggerFactory.getLogger(RedisUtil.class);
 @Autowired
 private RedisTemplate<String, Object> redisTemplate;
 //=============================common============================
 
 /**
 * 测试redis是否连接正常
 * @return true:连接正常；false：连接不正常
 */
 public boolean isConnection(){
 try {
 redisTemplate.opsForValue().set("sjtest", "123", 3, TimeUnit.SECONDS);
 } catch (RedisConnectionFailureException e) {
 logger.error("Unable to connect to Redis");
 return false;
 }
 return true;
 }
 /**
 * 指定缓存失效时间
 * @param key 键
 * @param time 时间(秒)
 * @return
 */
 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)
 * @return
 */
 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)
 * @return
 */
 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
 * @return 值
 */
 public Object hget(String key,String item){
 return redisTemplate.opsForHash().get(key, item);
 }
 
 /**
 * 获取hashKey对应的所有键值
 * @param key 键
 * @return 对应的多个键值
 */
 public Map<Object,Object> hmget(String key){
 return redisTemplate.opsForHash().entries(key);
 }
 
 /**
 * HashSet
 * @param key 键
 * @param map 对应多个键值
 * @return true 成功 false 失败
 */
 public boolean hmset(String key, Map<String,Object> 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<String,Object> 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)
 * @return
 */
 public double hincr(String key, String item,double by){
 return redisTemplate.opsForHash().increment(key, item, by);
 }
 
 /**
 * hash递减
 * @param key 键
 * @param item 项
 * @param by 要减少记(小于0)
 * @return
 */
 public double hdecr(String key, String item,double by){
 return redisTemplate.opsForHash().increment(key, item,-by);
 }
 
 //============================set=============================
 /**
 * 根据key获取Set中的所有值
 * @param key 键
 * @return
 */
 public Set<Object> sGet(String key){
 try {
 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 键
 * @return
 */
 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代表所有值
 * @return
 */
 public List<Object> 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 键
 * @return
 */
 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倒数第二个元素，依次类推
 * @return
 */
 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 值
 * @return
 */
 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 时间(秒)
 * @return
 */
 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<Object> 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<Object> 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;
 }
 }
 
 }

## 4、自定义Json工具类 ##

因为我这里的java对象均采用json格式存储，因此定义了此工具类

import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.JavaType;
 import com.fasterxml.jackson.databind.ObjectMapper;
 
 import java.util.List;
 
 public class JsonUtils {
 
 // 定义jackson对象
 private static final ObjectMapper MAPPER = new ObjectMapper();
 
 /**
 * 将对象转换成json字符串。
 * Title: pojoToJson
 * Description: 
 *
 * @param data
 * @return
 */
 public static String objectToJson(Object data) {
 try {
 String string = MAPPER.writeValueAsString(data);
 return string;
 } catch (JsonProcessingException e) {
 e.printStackTrace();
 }
 return null;
 }
 
 /**
 * 将json结果集转化为对象
 *
 * @param jsonData json数据
 * @param beanType 对象中的object类型
 * @return
 */
 public static <T> T jsonToPojo(String jsonData, Class<T> beanType) {
 try {
 T t = MAPPER.readValue(jsonData, beanType);
 return t;
 } catch (Exception e) {
 e.printStackTrace();
 }
 return null;
 }
 
 /**
 * 将json数据转换成pojo对象list
 * Title: jsonToList
 * Description: 
 *
 * @param jsonData
 * @param beanType
 * @return
 */
 public static <T> List<T> jsonToList(String jsonData, Class<T> beanType) {
 JavaType javaType = MAPPER.getTypeFactory().constructParametricType(List.class, beanType);
 try {
 List<T> list = MAPPER.readValue(jsonData, javaType);
 return list;
 } catch (Exception e) {
 e.printStackTrace();
 }
 
 return null;
 }
 
 }

## 5、使用Redis ##

完成前面4步后，redis其实已经集成进springBoot中了，剩下的就是使用了，给各简单的例子。

@Controller
    @RequestMapping("/test")
    public class TestController {
    
        @Autowired
        private RedisUtil redisUtil;
    
        // test
        @RequestMapping(value = "/add")
        private void getUserInfoByOpenid(String openid) throws Exception {
            redisUtil.set("mykey", "myvalue");
        }
    
    }

[20200927112115553.png]: /images/20221123/a49f4d9f158f42e48b6cd7d92ccd30b4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l5ajEwODMxNw_size_16_color_FFFFFF_t_70]: /images/20221123/971b487c81fd4b16a4602db8ef7d986d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l5ajEwODMxNw_size_16_color_FFFFFF_t_70 1]: /images/20221123/e5df433555984f868e1ffceb800da986.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3l5ajEwODMxNw_size_16_color_FFFFFF_t_70 2]: /images/20221123/6cc634451f5f4d0b88273b0a48fca5c6.png