RELATEED CONSULTING
相关咨询
选择下列产品马上在线沟通
服务时间：8:30-17:00
你可能遇到了下面的问题
关闭右侧工具栏

新闻中心

这里有您想知道的互联网营销解决方案
SpringBoot整合Redis完整步骤

本文在介绍关于SpringBoot整合redis的基础上，重点探讨了其具体步骤，步骤简单易上手操作，文章内容步步紧凑，希望大家根据这篇文章可以有所收获。

创新互联专注为客户提供全方位的互联网综合服务，包含不限于成都网站制作、成都网站建设、德兴网络推广、小程序制作、德兴网络营销、德兴企业策划、德兴品牌公关、搜索引擎seo、人物专访、企业宣传片、企业代运营等，从售前售中售后，我们都将竭诚为您服务，您的肯定，是我们最大的嘉奖；创新互联为所有大学生创业者提供德兴建站搭建服务，24小时服务热线：18982081108，官方网址：www.cdcxhl.com

1. pom.xml添加Redis支持



        org.springframework.boot
        spring-boot-starter-data-redis

2. application.properties添加Redis配置信息

# ----------------Redis配置---------------
## Redis数据库索引(默认为 0)
spring.redis.database=2
## Redis服务器地址
spring.redis.host=127.0.0.1
## Redis服务器连接端口
spring.redis.port=6379
## Redis 密码
spring.redis.password=
## 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=2000
## 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=30000
## 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=500
## 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=10
## 连接超时时间（毫秒）
spring.redis.timeout=3000

3. 添加redis配置文件

import org.springframework.cache.annotation.EnableCaching;
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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

@Configuration
@EnableCaching
public class RedisConfig {

    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {

        RedisTemplate redisTemplate = new RedisTemplate();

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
        redisTemplate.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        redisTemplate.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());

        //使用StringRedisSerializer来序列化和反序列化redis的ke
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());

        redisTemplate.setConnectionFactory(redisConnectionFactory);

        return redisTemplate;
    }
}

4. 添加redis工具类(service),待完善...

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

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

/**
 * 
功能:redis工具类

 *   基于spring和redis的redisTemplate工具类 针对所有的hash都是以h开头的方法
 *   针对所有的Set都是以s开头的方法, 不含通用方法,针对所有的List,都是以l开头的方法
 */
@Component
public class ToolRedis {
    // 默认有效期30天
    private static long TTL_EXP = 3600 * 24 * 30;

    @Autowired
    private RedisTemplate redisTemplate;

    public void setRedisTemplate(RedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    // =============================common============================
    /**
     * 指定缓存失效时间
     * 
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        boolean flag = true;
        try {
            if (time > 0) {
                flag = redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
        } catch (Exception e) {
            e.printStackTrace();
            flag = false;
        }
        return flag;
    }

    /**
     * 根据key 获取过期时间
     * 
     * @param key 键 不能为null
     * @return 时间(秒) -1:永久有效 -2:键不存在
     */
    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) {
        Object obj = key == null ? null : redisTemplate.opsForValue().get(key);
        if (null != obj) {
            expire(key, TTL_EXP);
        }
        return obj;
    }

    /**
     * 
功能:获取String值

     * 
     * @param key
     * @return 
     */
    public String getString(String key){
        Object ojb = get(key);
        return null == ojb ? null: String.valueOf(ojb);
    }

    /**
     * 
功能:获取int值

     * 
     * @param paramMap
     * @param key
     * @return 
     */
    public int getInt(String key){
        String value = getString(key);
        try {
            return null == value ? 0 : Integer.parseInt(value);
        } catch (Exception e) {
            return 0;
        }
    }

    /**
     * 
功能:获取long值

     * 
     * @param key
     * @return 
     */
    public long getLong(String key){
        String value = getString(key);
        try {
            return null == value ? 0L : Long.parseLong(value);
        } catch (Exception e) {
            return 0L;
        }
    }

    /**
     * 
功能:获取float值

     * 
     * @param key
     * @return 
     */
    public float getFloat(String key){
        String value = getString(key);
        try {
            return null == value ? 0.0F : Float.parseFloat(value);
        } catch (Exception e) {
            return 0.0F;
        }
    }

    /**
     * 
功能:获取double值

     * 
     * @param key
     * @return 
     */
    public double getDouble(String key){
        String value = getString(key);
        try {
            return null == value ? 0.0D : Double.parseDouble(value);
        } catch (Exception e) {
            return 0.0D;
        }
    }

    /**
     * 
功能:添加一个对象信息到redis

     * 永久有效
     * @param key
     * @param value
     * @return 
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 
功能:添加一个对象信息到redis

     * 默认有效期30天
     * @param key
     * @param value
     * @return 
     */
    public boolean setExt(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value, TTL_EXP, TimeUnit.SECONDS);
            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 by  要增加几(大于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 by  要减少几(小于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 hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     * 
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    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)
     * @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 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缓存的内容(0 到 -1代表所有值)
     * 
     * @param key   键
     * @param start 开始
     * @param end   结束
     * @return
     */
    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 键
     * @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 值
     * @param time  时间(秒)
     * @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 值
     * @param time  时间(秒)
     * @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;
        }
    }
}
5. 编写一个测试API文件
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.alibaba.fastjson.JSONObject;
import com.qfx.modules.common.util.ToolRedis;

@RestController
@RequestMapping("test")
public class TestCtl {
    private static int ExpireTime = 60;   // redis中存储的过期时间60s

    @Autowired
    private ToolRedis toolRedis;

    /**
     * 
功能:新增

     * 
     * @param key
     * @param value
     * @return 
     */
    @RequestMapping("set")
    public String redisSet(String key, String value){
        return String.valueOf(toolRedis.set(key,value, 300));
    }

    /**
     * 
功能:获取

     * 
     * @param key
     * @return 
     */
    @RequestMapping("get")
    public String redisGet(String key){
        return JSONObject.toJSONString(toolRedis.get(key));
    }

    /**
     * 
功能:设置有效期

     * 
     * @param key
     * @return 
     */
    @RequestMapping("expire")
    public String expire(String key){
        return String.valueOf(toolRedis.expire(key,ExpireTime));
    }

    /**
     * 
功能:获取有效期

     *  时间(秒) -1:永久有效 -2:键不存在
     * @param key
     * @return 
     */
    @RequestMapping("getExpire")
    public String getExpire(String key){
        return String.valueOf(toolRedis.getExpire(key));
    }
}
6. 测试
http://127.0.0.1/qfxSpringbootRedisDemo/test/set?key=aa&value=11
http://127.0.0.1/qfxSpringbootRedisDemo/test/get?key=aa
6.1 新增缓存
SpringBoot整合Redis完整步骤
redis库
SpringBoot整合Redis完整步骤
6.2 获取缓存
SpringBoot整合Redis完整步骤
7. 项目完整目录
SpringBoot整合Redis完整步骤
关于SpringBoot整合Redis就分享到这里了，希望以上内容可以对大家有一定的帮助，可以学到更多知识。如果喜欢这篇文章，不如把它分享出去让更多的人看到。
            
            
                                                            

                                                新闻名称：SpringBoot整合Redis完整步骤                                                

                                                转载注明：http://lswzjz.com/article/jpohjd.html
                                            
                                            

                                                

                                                    
其他资讯

                                                

                                                

                                                    
                                                

                                            

                                        
                                    
                                
                            
                        
                    
                
            
        
    





    

        

            

                

                    

                        

                            

                                
                            

                            

                                

                                    
快速导航

                                    
                                

                            

                        

                    

                    

                        

                            

                                
友情链接

                                
                                
网站建设

                                
                            

                        

                    

                    

                        

                            

                                
联系方式

                                
    
                                    
  • 企业：青羊区大橙子信息咨询工作室
    • 
                                    
  • 地址：成都市青羊区太升南路288号
    • 
                                    
  • 电话：18980820575
    • 
                                    
  • 网址：www.lswzjz.com
    • 
                                

                            

                        

                    

                

            

            

                
公司名称：青羊区大橙子信息咨询工作室   联系电话：18980820575

                
网站备案号：蜀ICP备2022028542号-13

                
乐山大橙子建站 乐山网站建设 乐山网站设计 乐山网站制作 成都做网站