Redis

最新推荐文章于 2022-02-14 09:19:40 发布
最新推荐文章于 2022-02-14 09:19:40 发布
阅读量125 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/FUKEXIN_xiaojiang/article/details/99632528
版权

1、Redis 数据类型：

String（字符串）：简单的key-value键值对，value不仅可以是String，也可以是数字，当遇到incr\decr等操作转为数字，此时redis Object的encoding字段为int

List（列表）：是简单的字符串列表，简单说就是一个链表或者一个队列，实现为一个双向链表，即可以支持反向查找和遍历，更方便操作，不过带来了部分额外的内存开销

Hash（字典）：Hash对应value内部实际就是一个hashmap，两种不同实现，hash的成员比较少时redis为了节省内存会采用类似一维数组的方式来紧凑存储，而不会用真正的hashmap结构，对应的value redis object的encoding为zipmap,此时encoding为int

Set（集合）：可以理解为值不重复的列表，类似数学领域中的集合概念，且redis也提供了对集合的交际、并集、差集

Sorted Set（有序集合）：有序集合

2、Redis 配置文件（Spring Boot）

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

#redis缓存服务器配置 
  redis:
    database: 0 #Redis数据库索引（默认为0）
    host: 192.168.2.101   #Redis服务器地址
    port: 6379 #Redis服务器连接端口
    password: 1C&M70T2Zv3SU&9J #Redis服务器连接密码（默认为空）
    jedis:
      pool: 
        max-active: 8 #连接池最大连接数（使用负值表示没有限制））
        max-wait: -1 #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 8 #连接池中的最大空闲连接
        min-idle: 0 #连接池中的最小空闲连接
    timeout: 5000   #连接超时时间（毫秒）

3、Redis 配置类

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

/**
 * redis配置类
 * @Date: 2019/1/25 15:20
 * @Description:
 */
@Configuration
@EnableCaching //开启注解
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * retemplate相关配置
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(om);

        // 值采用json序列化
        template.setValueSerializer(jacksonSeial);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());

        // 设置hash key 和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jacksonSeial);
        template.afterPropertiesSet();

        return template;
    }

    /**
     * 对hash类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForHash();
    }

    /**
     * 对redis字符串类型数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForValue();
    }

    /**
     * 对链表类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForList();
    }

    /**
     * 对无序集合类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForSet();
    }

    /**
     * 对有序集合类型的数据操作
     *
     * @param redisTemplate
     * @return
     */
    @Bean
    public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
        return redisTemplate.opsForZSet();
    }

}

4、Redis 工具类

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

import javax.annotation.Resource;

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

/**
 * @Description redis工具类
 * @ClassName RedisConfig
 */
@Service
public class RedisUtils {

    @Resource
    private RedisTemplate<String,Object> redisTemplate ;

    /**
     * 制定緩存失效時間
     * @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
     * @return
     */
    public long getExpire(String key){
        return redisTemplate.getExpire(key);
    }
    /**
     * 判断key是否存在
     * @param key
     * @return
     */
    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=============================  

    /**
     * 模糊查询key
     * @Title: keys
     * @param @param key
     * @return Set<String> key的集合
     */
    public Set<String> keys(String key) {
        return redisTemplate.keys(key);
    }

    /** 
     * 普通缓存获取 
     * @param key 键 
     * @return 值 
     */  
    public Object get(String key){  
        return key==null? null:redisTemplate.opsForValue().get(key);  
    }  

    /**
     * 普通缓存多个获取
     * @Title: mGet
     * @param key  String类型，以","号分割的多个键
     * @return Object   值
     */
    public Object mGet(String key){
        if (null == key || key.isEmpty()) {
            return null;
        }
        String[] keys = key.split(",");
        return mGet(keys);
    }
    /**
     * 普通缓存多个获取
     * @Title: mGet
     * @param key  String数组类型的多个键
     * @return Object   值
     */
    public Object mGet(String[] keys){
        if (null == keys || 0 == keys.length) {
            return null;
        }
        return mGet(Arrays.asList(keys));
    }
    /**
     * 普通缓存多个获取
     * @Title: mGet
     * @param key  List类型的多个键
     * @return Object   值
     */
    public Object mGet(List<String> keys){
        if (null == keys || 0 == keys.size()) {
            return null;
        }
        return redisTemplate.opsForValue().multiGet(keys);
    }  

    /** 
     * 普通缓存放入 
     * @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;  
        }  

    }  

    /**
     * 设置key,如果不存在则设置并返回true,如果存在则不设置,返回false
     * @param key
     * @param value
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return
     */
    public boolean setnx(String key, String value, Integer time) {
        try {
            if (!hasKey(key)) {
                //time 时间(秒) time要大于0 如果time小于等于0 将设置无限期 
                set(key, value, time);
                return true;
            }
            return false;
        } 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 @param map 多个键值对
     * @return true成功 false 失败 
     */
    public boolean mSet(Map<String,Object> map){  
        try {
            redisTemplate.opsForValue().multiSet(map);
            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<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 值 
     * @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<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;  
        }  
    } 
}

 

 

 

 

FUKEXIN_xiaojiang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
SpringBoot项目集成Redis
qq_30401609的博客
08-02 1525
一、在pom文件中添加依赖 &lt;!-- 集成redis --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-data-redis&lt;/artifactId&gt; &lt;/dep...
Windows 下 Redis 安装与配置 教程
热门推荐
小青龍 的博客
06-14 16万+
Windows下Redis安装与配置教程，Windows下安装Redis的几种方式，msi安装包安装，zip安装包安装。使用SC命令，手动创建Redis服务及注册表服务项，实现Redis服务后台运行及服务自启动。Redis服务配置查看及修改，Redis服务各配置项简要说明。
Springboot项目整合Redis
༺࿈无关痛痒࿈༻的博客
11-21 492
  老早就想记录一下Springboot项目中如何整合Redis，今天终于对它下手了（在整合Redis之前，需确保redis处于启动状态）    废话不多说，直接新建Springboot项目。 Springboot整合Redis 1.创建项目选择依赖 ![在这里插入图片描述](https://img-blog.csdnimg.cn/20191121095803814.png?x-oss-p...
springboot项目整合redis
卫辰的博客
07-30 238
1.首先需要在本地安装redis服务，官网下载，并启动。 2.在pom文件中引入以下依赖 <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring...
springBoot项目技术集成redis
boy_10的博客
02-14 786
一、集成阿里云数据连接池 Druid：Druid不仅是一个数据库连接池，还包含一个ProxyDriver（代理程序）、一系列内置的JDBC组件库、一个SQL 可以看到具体的一条sql语句运行时间 1.pom依赖 <dependency> <groupId> com.alibaba </groupId> <artifactId> druid-spring-boot-starter </artifactId> <versi...
若依前后端分离版去redis版/无redis版本
11-07
基于前后端分离的应用，无论是否使用Redis，都需要考虑如何进行数据的存储和缓存。下面我将分别介绍基于Redis和无Redis的两种版本的特点。 基于Redis的版本 特点 缓存处理：Redis作为内存数据库可以用来缓存频繁访问...
redis-windows-7.0.11
05-05
Redis是一种开源的内存数据结构存储系统，它支持多种数据结构，如字符串、哈希、列表、集合、有序集合等。Redis可以用作数据库、缓存和消息中间件。Redis在性能、可扩展性和灵活性方面表现出色，因此被广泛应用于Web...
redis-windows-7.2.3.zip
最新发布
11-09
Redis，全称Remote Dictionary Server，是一款开源的、高性能的键值存储系统，广泛应用于缓存、消息队列、数据持久化等多个场景。它以其高效的数据处理能力，丰富的数据结构以及简单易用的API赢得了广大开发者青睐。...
redis-windows-7.2.1.zip
09-13
Redis，全称Remote Dictionary Server，是一款开源的、高性能的键值对存储系统，常用于数据缓存、消息队列和数据库等场景。在Windows环境下安装和使用Redis，可以通过下载对应的二进制压缩包来实现，比如"redis-...
idea下springboot整合redis例子
07-20
这个是我自己搭建的springboot整合redis，由于网上的部分例子，有错误，深感不解，于是动手搭建，自己测试过了，可以使用，而且简单易懂，适合新手，容易理解，可以作为自己的第一个demo
spring boot整合redis demo代码
12-26
在spring boot中集成redis，包括redis的链接配置，操作方法以及Controller的使用，直接修改properties的链接即可运行
SpringBoot整合Redis
tobeng的博客
06-29 657
1、Springboot整合Redis，首先在项目中加入依赖：&lt;!-- redis依赖 --&gt; &lt;dependency&gt; &lt;groupId&gt;org.springframework.boot&lt;/groupId&gt; &lt;artifactId&gt;spring-boot-starter-data-redis&lt;/artifactId...
【实战】SpringBoot项目整合Redis
小李的博客
08-22 345
Redis是什么？ 1.1 存储结构 Redis是REmote DIctionary Server(远程字典服务器)的缩写，它以字典结构存储数据，并允许其他应用通过TCP协议读写字典中的内容。到目前为止Redis支持的键值数据类型如下： 字符串类型 散列类型 列表类型 集合类型 有序集合类型 字典结构： 字典，在其他语言中也称 map，使用 键-值对（key-value）存储，查找速度快。 字典是无序的对象集合，元素是通过键来存取的，而不是通过索引值存取。 字典是可变数据类型 通俗易懂的讲就是：你们使
Redis-SpringBoot
careyliang的博客
03-26 85
集成SpringBoot 1. 引入坐标 2. 设置 application.yml 3. 测试工具类RedisTemplate 解析： 1. Jedis是Java对redis的封装 2. RedisTemplate 是Spring对redis的封装 3. 两者的API不同，但功能大致相同 技术扩展 集成AOP ...
springboot整合redis并在项目中使用
x-dragon8899的博客
07-05 3830
推荐文章： redis学习 springboot+mybatis+vue实战——旅游网站(一) 完成登录注册、验证码、省份增删改查功能 目录一、下载安装并启动redis二、springboot项目整合redis1、pom.xml引入redis依赖2、在application.properties中加入配置3、新建`RedisCache.java`4、新建工具类`ApplicationContextUtils.java`5、在实体类中实现`Serializable`接口6、在对应的Mapper.xml中.
springboot 整合 redis开发
m0_38053092的博客
10-23 190
redis:REmote DIctionary Server（远程字典服务器）。是完全开源免费的，用C语言编写的， 遵守BCD协议。是一个高性能的(key/value)分布式内存数据库。 (1) redis搭建(window10)： 下载地址：https://github.com/MSOpenTech/redis/releases (2) 安装Redis-x64-3.0.504.exe，通过redis页面安装引导完成安装； (3) cmd 运行如下命令，启动redis： redis-server.e
Spring Boot集成Redis
坤哥的博客
06-02 3663
去年第一次真正接触Redis的时候是做短信的验证码功能，这里主要是用到其时间的有效性，其结构有三个字段：key,value,expire。以expire中设置的时间来使存储的验证码失效。当时也有集成一般数据的新增、删除和查询功能，这时key为String（符合redis中虽有key的标准），value为Object，所以理论上来说可以满足我所有需要处理的数据通过字符串的key-value存储方式存到
SpringBoot使用Redis
qq_53678217的博客
04-26 3651
SpringBoot使用Redis 1、SpringBoot链接Redis   使用redisTemplate该类可以存放任意类型的数据，但是该类型的数据必须实现序列，获取redis中对应的数据时，会进行反序列化。 如果使用RedisTemplate建议大家指定key，value，以及hashkey的序列化方式。 锁都是多线程的，所以普通方式是不能测试出来的，此时需要用软件【点这里】，使用压力测试，测试多线程。 1、1 配置application.properties文件 #Redis服务器IP地址 spr
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值