springboot2.1.1 集成 redis

最新推荐文章于 2023-09-29 22:02:57 发布
最新推荐文章于 2023-09-29 22:02:57 发布
阅读量524 收藏
点赞数
分类专栏： # SpringBoot # redis 文章标签： springboot集成redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010520146/article/details/84550769
版权
一.poml文件
	<!-- spring boot redis 缓存引入 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
			<version>2.0.4.RELEASE</version>
		</dependency>
		<!-- lettuce pool 缓存连接池 -->
		<dependency>
			<groupId>org.apache.commons</groupId>
			<artifactId>commons-pool2</artifactId>
			<version>2.5.0</version>
		</dependency>
		<!-- jackson json 优化缓存对象序列化 -->
		<dependency>
			<groupId>com.fasterxml.jackson.core</groupId>
			<artifactId>jackson-databind</artifactId>
			<version>2.9.6</version>
		</dependency>
二.application.yml配置
  redis:
    host: 127.0.0.1
    port: 6379
    password: 888888
    timeout: 10000
    jedis:
      pool:
        max-idle: 8
        min-idle: 10
        max-active: 100
        max-wait: -1
三.redisConfig配置
package cn.qzzg.sso_server.redis.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.cache.interceptor.SimpleKeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.lang.reflect.Method;
import java.time.Duration;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * @Description reid配置
 * @Author lss0555
 * @Date 2019/1/4/004 15:50
 **/
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
    /**
     * json序列化
     * @return
     */
    @Bean
    public RedisSerializer<Object> jackson2JsonRedisSerializer() {
        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值
        Jackson2JsonRedisSerializer serializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);
        return serializer;
    }

    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
        //StringRedisTemplate的构造方法中默认设置了stringSerializer
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        //set key serializer key与value序列化
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setValueSerializer(stringRedisSerializer);
        template.setHashKeySerializer(stringRedisSerializer);
        template.setHashValueSerializer(stringRedisSerializer);

        template.setConnectionFactory(lettuceConnectionFactory);
        template.afterPropertiesSet();
        return template;
    }

    @Bean
    public StringRedisTemplate stringRedisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(lettuceConnectionFactory);
        return template;
    }
    /**
     * 在使用@Cacheable时，如果不指定key，则使用找个默认的key生成器生成的key
     */
    @Override
    @Bean
    public KeyGenerator keyGenerator() {
        return new SimpleKeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(".").append(method.getName());

                StringBuilder paramsSb = new StringBuilder();
                for (Object param : params) {
                    // 如果不指定，默认生成包含到键值中
                    if (param != null) {
                        paramsSb.append(param.toString());
                    }
                }

                if (paramsSb.length() > 0) {
                    sb.append("_").append(paramsSb);
                }
                return sb.toString();
            }

        };

    }

    /**
     * 管理缓存
     * @param lettuceConnectionFactory
     * @return
     */
    //缓存管理器
    @Bean
    public CacheManager cacheManager(LettuceConnectionFactory lettuceConnectionFactory) {
        // 生成一个默认配置，通过config对象即可对缓存进行自定义配置
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();

        // 设置缓存的默认过期时间，也是使用Duration设置
        config = config.entryTtl(Duration.ofMinutes(1))
                // 设置 key为string序列化
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(new StringRedisSerializer()))
                // 设置value为json序列化
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer() ))
                // 不缓存空值
                .disableCachingNullValues();

        // 设置一个初始化的缓存空间set集合
        Set<String> cacheNames = new HashSet<>();
        cacheNames.add("company_goods_info");

        // 对每个缓存空间应用不同的配置
        Map<String, RedisCacheConfiguration> configMap = new HashMap<>();
        configMap.put("company_goods_info", config);

        // 使用自定义的缓存配置初始化一个cacheManager
        RedisCacheManager cacheManager = RedisCacheManager.builder(lettuceConnectionFactory)
                // 一定要先调用该方法设置初始化的缓存名，再初始化相关的配置
                .initialCacheNames(cacheNames)
                .withInitialCacheConfigurations(configMap)
                .build();
        return cacheManager;
    }
}
四.redis操作接口与实现

1.redisServerInter

public interface RedisServiceInter {
    //指定缓存失效时间
    boolean expire(String key,long time);
    //根据key 获取过期时间
    long getExpire(String key);

    //判断key是否存在
    boolean hasKey(String key);

    //删除缓存
    void delKey(String ... key);

    //普通缓存放入
    boolean set(String key,Object value);
    //普通缓存获取
    Object get(String key);
    //普通缓存放入并设置时间
    boolean set(String key,Object value,long time);
    //递增 delta要大于0
    long incr(String key, long delta);
    //递减
    long decr(String key, long delta);

    //hash  操作
    boolean hmset(String key, Map<String,Object> map);
    //通过key获取map集合
    Map<Object,Object> hmget(String key);
    //通过key item获取
    Object hget(String key,String item);
    //hash  设置key,map,时间
    boolean hmset(String key, Map<String,Object> map, long time);
    boolean hset(String key,String item,Object value);
    boolean hset(String key,String item,Object value,long time);
    void hdel(String key, Object... item);
    //判断有误存在该key,value
    boolean hHasKey(String key, String item);
    //hash递增 如果不存在,就会创建一个 并把新增后的值返回
    double hincr(String key, String item,double by);
    //hash递减
    double hdecr(String key, String item,double by);


    //set  操作
    //获取key的set
    Set<Object> sGet(String key);
    //根据value从一个set中查询,是否存在
    boolean sHasKey(String key,Object value);
    //将数据放入set缓存
    long sSet(String key, Object...values);
    long sSetAndTime(String key,long time,Object...values);
    long sGetSetSize(String key);
    long setRemove(String key, Object ...values);


    //list操作
    List<Object> lGet(String key, long start, long end);
    long lGetListSize(String key);
    //将list放入缓存
    boolean lSet(String key, Object value);
    //将list放入缓存.并设置时间
    boolean lSet(String key, Object value, long time);
    boolean lSet(String key, List<Object> value);
    boolean lSet(String key, List<Object> value, long time);
    Object lGetIndex(String key,long index);
    boolean lUpdateIndex(String key, long index,Object value);
    long lRemove(String key,long count,Object value);
}

2.redisServerImpl

/**
 * Description redis实现类  <br/>
 */
@Service("redisService")
public class RedisServiceImpl implements RedisServiceInter {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;

    /**
     * 指定缓存失效时间
     * @param key 键
     * @param time 时间(秒)
     * @return
     */
    @Override
    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代表为永久有效
     */
    @Override
    public long getExpire(String key) {
        return redisTemplate.getExpire(key,TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     * @param key 键
     * @return true 存在 false不存在
     */
    @Override
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除缓存
     * @param key 可以传一个值 或多个
     */
    @Override
    public void delKey(String... key) {
        if(key!=null&&key.length>0){
            if(key.length==1){
                redisTemplate.delete(key[0]);
            }else{
                redisTemplate.delete(CollectionUtils.arrayToList(key));
            }
        }
    }


    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    @Override
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

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

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    @Override
    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
     */
    @Override
    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
     */
    @Override
    public long decr(String key, long delta) {
        if(delta<0){
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    /**
     * HashSet
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    @Override
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    @Override
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * 获取hashKey对应的所有键值
     * @param key 键
     * @return 对应的多个键值
     */
    @Override
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * HashSet 并设置时间
     * @param key 键
     * @param map 对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    @Override
    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失败
     */
    @Override
    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失败
     */
    @Override
    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
     */

    @Override
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key,item);
    }

    /**
     * 判断hash表中是否有该项的值
     * @param key 键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    @Override
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     * @param key 键
     * @param item 项
     * @param by 要增加几(大于0)
     * @return
     */
    @Override
    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
     */
    @Override
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item,-by);
    }

    /**
     * 根据key获取Set中的所有值
     * @param key 键
     * @return
     */
    @Override
    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不存在
     */
    @Override
    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 成功个数
     */
    @Override
    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 成功个数
     */
    @Override
    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
     */
    @Override
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     * @param key 键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    @Override
    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缓存的内容
     * @param key 键
     * @param start 开始
     * @param end 结束  0 到 -1代表所有值
     * @return
     */
    @Override
    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
     */
    @Override
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将list放入缓存
     * @param key 键
     * @param value 值
     * @return
     */
    @Override
    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
     */
    @Override
    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
     */
    @Override
    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
     */
    @Override
    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 索引  index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    @Override
    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 index 索引
     * @param value 值
     * @return
     */
    @Override
    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 移除的个数
     */
    @Override
    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;
        }
    }
}
lss0555
关注
专栏目录
spring boot 2.1学习笔记【十】SpringBoot 2 集成redis多数据源
刘本龙的专栏
01-14 4744
spring boot 2.1 集成 redis 多数据源
【redis】--springboot集成redisson
寻梦友的博客
11-13 1721
Redisson 是一个在 Redis 的基础上实现的 Java 驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的 Java 常用对象，还提供了许多分布式服务。
Springboot2.1.0集成Redis
暴躁兔子的记录
11-22 5490
步骤： 引入pom依赖 配置文件 注解@EnableCaching 开始使用 下面开始实现 引入pom 使用的是IDEA，新建一个全新的工程： 直接在创建的时候引入： 在springboot2之后，redis默认集成的是lettuce，如果要使用jedis，需要使用第二个xml配置 第一种： &amp;lt;dependency&amp;gt; &amp;lt;groupId&amp;gt;org.spri...
springBoot 2.1+springDataRedis2.x+spring 5.1集成本地包
12-19
springBoot2.1集成redis，spring使用5.1版本。 redis采用支持集群模式，资源只是jar包整合
Spring Boot 2.1整合Redis
weixin_34080903的博客
01-08 952
1.普通字符串存储 1.引入spring-boot-starter-data-redisjar包,注意spring boot 2.1 没有对应的spring-boot-starter-redis版本，改名为spring-boot-starter-data-redis。 <dependency> <groupId&...
SpringBoot2.0整合Redis
和我一起学习吧
03-26 4万+
首先引入POM依赖 &lt;!--nosql数据库--&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;/dependenc...
springboot2.1.x redis笔记
nuoqing的博客
08-28 130
1.RedisTemplate中定义了对5种数据结构操作 redisTemplate.opsForValue();//操作字符串 redisTemplate.opsForHash();//操作hash redisTemplate.opsForList();//操作list redisTemplate.opsForSet();//操作set redisTemplate.opsForZSet();/...
springboot集成redis (单个redis或多个redis)
haifei0926的专栏
05-16 1929
目标： 1、springboot集成单个redis，并通过代码操作redis； 2、springboot集成多个redis，并通过代码操作redis； 一、springboot集成单个redis 1、引入maven依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifa
spring boot 2.1学习笔记【九】SpringBoot 2 集成redis
刘本龙的专栏
01-11 4951
springboot2.X 集成redis非常简单，只需要引入依赖包，配置数据源连接池，就可以直接使用redisTemplate了。 注意：springboot 2.X 版本使用lettuce连接池来替换jedis。Lettuce和Jedis都是连接Redis Server的客户端程序，Jedis在实现上是直连redis server，多线...
springboot集成redis cluster集群
Mr_Dai的博客
01-18 559
搭建一个springboot项目，整合redis cluster集群配置。 项目pom.xml &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instan...
spring boot 集成 redis spring-boot-starter-data-redis 2.1.7.RELEASE jedis: pool: #连接池配置 及踩坑经验
银河系天城知识宝库_技术专家蒋浩宇
12-24 2004
目录 先上一些踩坑报错，各类报错 @org.springframework.beans.factory.annotation.Autowired(required=true) Error creating bean with name 'redisUtil': Unsatisfied dependency expressed through field 'redisTemplate'; ERROR org.apache.catalina.core.ContainerBase. Comman...
在Spring Boot项目中使用Redisson
最新发布
Go_ahead_forever的博客
09-29 3965
Redission是一个基于Java的分布式缓存和分布式任务调度框架，用于处理分布式系统中的缓存和任务队列。它是一个开源项目，旨在简化分布式系统的开发和管理。：Redission支持分布式缓存，可以将数据存储在分布式环境中，以提高性能和可用性。它提供了各种数据结构，如分布式Map、Set、List、Queue等，可以用来存储和操作数据。：Redission提供了分布式锁的功能，允许多个线程或多个应用程序在分布式环境中协调对共享资源的访问，以避免竞态条件。
Springboot集成Redis
shyany的博客
11-02 199
文章目录一、Windows安装Redis启动临时服务自定义安装设置密码二、Springboot项目集成Redis1.在springboot项目的pom.xml文件里加入redis的jar依赖2.在application.properties中配置redis参数3.RedisConfig.java类4.RedisUtil.java5.UserEntity.java6.RedisController.java7.测试总结 提示：以下是本篇文章正文内容，下面案例可供参考 一、Windows安装Redis Re.
springboot2.0整合redis
请叫我猿叔叔的博客
09-01 3307
一. 简介            redis搭建请参照笔者的另一篇文章：  linux下安装redis4.0.11            RedisUtil的封装方法待完善...... 二. 代码 2.1 pom.xml 需要引入： spring-boot-starter-data-redis 和 jackson-databind &lt;?xml version="1.0" enc...
spring boot 整合redis
深存少年梦
02-13 6981
1.简介spring boot提供了spring-data-redis库来整合redis的操作，并通过简单的配置信息实现与redis的整合。2.准备工作安装redis缓存数据库，安装可视化工具，推荐使用:rdm。3.redis简介REmote DIctionary Server(Redis) 是一个由Salvatore Sanfilippo写的key-value存储系统。 Redis是一个开源的使
2.1 springboot2整合redis的基本操作
weixin_45974277的博客
02-17 702
添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <gr
SpringBoot 操作 Redis 数据
热门推荐
Java Pro
11-14 19万+
SpringBoot2.x【七】整合 Redis 入门 首先，Redis是什么？ Redis是一个开源的，基于内存的键值数据存储，用作数据库，缓存和消息代理。在实现方面，Key-Value存储代表NoSQL空间中最大和最老的成员之一。Redis支持数据结构，如字符串，散列，列表，集和带范围查询的有序集。 在spring data redis的框架，可以很容易地编写，通过提供一个抽象的数据存储使用...
SpingBoot2.1.3集成Redis SpingBoot2.x+redis
K One
02-20 3126
SpingBoot2.x+redis 配置jedis SpingBoot2.1.3集成Redis 配置jedis SpingBoot2.x集成redis springboot2.x引入jedis
SpringBoot 2.1.1整合Redis
天道酬勤 厚积薄发
10-29 1772
添加依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> 配置appli...
SpringBoot 2.1.1.RELEASE 官方参考指南
"Spring Boot参考指南2.1.1.RELEASE" Spring Boot是现代Java应用程序开发的一个强大框架，它简化了创建独立、生产级的Spring应用。这个官方文档提供了全面的指导，帮助开发者快速上手并深入理解Spring Boot的核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值