Springboot：通过lettuce整合redis

最新推荐文章于 2024-07-06 03:44:45 发布
最新推荐文章于 2024-07-06 03:44:45 发布
阅读量547 收藏 1
点赞数
分类专栏： springboot 文章标签： redis spring boot 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43296313/article/details/121702163
版权

Springboot：通过lettuce整合redis

一、lettuce介绍

Lettuce的连接是基于Netty的，连接实例（StatefulRedisConnection）可以在多个线程间并发访问，因为StatefulRedisConnection是线程安全的，所以一个连接实例（StatefulRedisConnection）就可以满足多线程环境下的并发访问，当然这个也是可伸缩的设计，一个连接实例不够的情况也可以按需增加连接实例。

二、导入依赖

       <!-- spring boot redis 缓存引入 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <!-- lettuce pool 缓存连接池 -->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>

        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.10.2</version>
        </dependency>

三、配置类

package com.hl.redisLettuce.config;


import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.interceptor.KeyGenerator;
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.RedisStandaloneConfiguration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.connection.lettuce.LettucePoolingClientConfiguration;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

import java.lang.reflect.Method;
import java.time.Duration;

@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    //配置redis的过期时间
    private static final Duration TIME_TO_LIVE = Duration.ZERO;
    private static final StringRedisSerializer STRING_SERIALIZER = new StringRedisSerializer();
    private static final GenericJackson2JsonRedisSerializer JSON_SERIALIZER = new GenericJackson2JsonRedisSerializer();

    @Bean
    public RedisTemplate<String, Object> redisTemplate(LettuceConnectionFactory lettuceConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(lettuceConnectionFactory);
        //key的序列方式
        template.setKeySerializer(STRING_SERIALIZER);
        //hashKey的序列方式
        template.setHashKeySerializer(STRING_SERIALIZER);
        //value的序列方式
        template.setValueSerializer(JSON_SERIALIZER);
        value hashmap序列化
        template.setHashValueSerializer(JSON_SERIALIZER);
        return template;
    }

    @Bean
    public GenericObjectPoolConfig poolConfig(){
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
        //控制一个pool可分配多少个jedis实例
        poolConfig.setMaxTotal(500);
        //最大空闲数
        poolConfig.setMaxIdle(200);
        //每次释放连接的最大数目，默认是3
        poolConfig.setNumTestsPerEvictionRun(1024);
        //逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1
        poolConfig.setTimeBetweenEvictionRunsMillis(30000);
        //连接的最小空闲时间 默认1800000毫秒(30分钟)
        poolConfig.setMinEvictableIdleTimeMillis(-1);
        poolConfig.setSoftMinEvictableIdleTimeMillis(10000);
        //最大建立连接等待时间。如果超过此时间将接到异常。设为-1表示无限制。
        poolConfig.setMaxWaitMillis(1500);
        poolConfig.setTestOnBorrow(true);
        poolConfig.setTestWhileIdle(true);
        poolConfig.setTestOnReturn(false);
        poolConfig.setJmxEnabled(true);
        poolConfig.setBlockWhenExhausted(false);
        return poolConfig;
    }

    @Bean
    public LettuceConnectionFactory lettuceConnectionFactory() {
        LettucePoolingClientConfiguration lettucePoolingClientConfiguration = LettucePoolingClientConfiguration.builder()
                .poolConfig(poolConfig())
                .build();
        // 单机redis
        RedisStandaloneConfiguration redisConfig = new RedisStandaloneConfiguration();
        redisConfig.setHostName("127.0.0.1");
        redisConfig.setPort(6379);


        // 哨兵redis
        //RedisSentinelConfiguration redisConfig = new RedisSentinelConfiguration();

        // 集群redis
//        RedisClusterConfiguration redisConfig = new RedisClusterConfiguration();
//        Set<RedisNode> nodeses = new HashSet<>();
//        String[] hostses = nodes.split("-");
//        for (String h : hostses) {
//            h = h.replaceAll("\\s", "").replaceAll("\n", "");
//            if (!"".equals(h)) {
//                String host = h.split(":")[0];
//                int port = Integer.valueOf(h.split(":")[1]);
//                nodeses.add(new RedisNode(host, port));
//            }
//        }
//        redisConfig.setClusterNodes(nodeses);
//        // 跨集群执行命令时要遵循的最大重定向数量
//        redisConfig.setMaxRedirects(3);
//        redisConfig.setPassword(password);

        return new LettuceConnectionFactory(redisConfig, lettucePoolingClientConfiguration);
    }

    /**
     * 缓存对象集合中，缓存是以key-value形式保存的,
     * 当不指定缓存的key时，SpringBoot会使用keyGenerator生成Key。
     */
    @Override
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... params) {
                StringBuilder sb = new StringBuilder();
                //类名+方法名
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : params) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }

    /**
     * 缓存管理器
     * @param lettuceConnectionFactory 连接工厂
     * @return  cacheManager
     */
    @Bean
    public CacheManager cacheManager(LettuceConnectionFactory lettuceConnectionFactory) {
        //新建一个Jackson2JsonRedis的redis存储的序列化方式
        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        //解决查询缓存转换异常的问题
        // 配置序列化（解决乱码的问题）
        //entryTtl设置过期时间
        //serializeValuesWith设置redis存储的序列化方式
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(TIME_TO_LIVE)
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(genericJackson2JsonRedisSerializer))
                .disableCachingNullValues();
        //定义要返回的redis缓存管理对象
        return RedisCacheManager.builder(lettuceConnectionFactory).cacheDefaults(config).build();
    }
}

四、工具类

package com.hl.redisLettuce.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.*;
import java.util.concurrent.TimeUnit;
 
@Component
public class RedisUtil {
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
 
    public void setRedisTemplate(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    //=============================common============================
    /**
     * 指定缓存失效时间
     * @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;
        }
    }
}
yololee_
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【SpringBoot】17、SpringBoot中整合Redis实现热点数据缓存
Asurplus
08-03 19万+
本次，我们以IDEA + SpringBoot作为 Java中整合Redis的使用 的测试环境，如果对创建SpringBoot项目有不清楚的地方，可以参考我的博客！！！ 首先，我们需要导入Redis的maven依赖 <!-- Redis的maven依赖包 --> <dependency> <groupId>org.springframework.b...
Spring Boot2.X 使用Lettuce连接Redis
hancc_824的博客
05-15 290
前言 Spring Boot2.x 不再使用Jedis，换成了Lettuce。Lettuce是基于 Netty 实现的，所以性能更好。 1.pom文件 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis-reactive</artifactId> </dep
2021-01-26
djdjbfbd的博客
01-26 90
java用Redis常用的存储方式 import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.stereotype.Service; import org.springframework.util.CollectionUtils; import java.util.Li
springboot redis集群 Lettuce 配置
最新发布
weixin_41756001的博客
07-06 121
配置相关视频讲解：C语言程序设计入门之环境安装Spring Boot Redis集群 Lettuce配置 在现代的微服务架构中，缓存是一个非常重要的组成部分，它可以提高系统的性能和可扩展性。而Redis作为一种高性能的内存数据库，被广泛应用于缓存、会话管理等场景。在Spring Boot应用中使用Redis，我们可以选择...
SpringBoot整合redis+lettuce
热门推荐
Venus's Blog
08-22 2万+
Spring Boot提供了与Redis的集成框架，可以使用Lettuce作为Redis客户端来进行整合。
SpringBoot整合redis（lettuce）
qq_42026590的博客
11-04 497
SpringBoot整合redis pom文件导入依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> application.yml配置 server: port: 8823 spring: #redis
基于Spring Boot2.x使用Redis(Lettuce)详细教程---Redis使用环境配置 (一)
jetty_welcome的博客
03-14 1783
1.1 maven配置 新建SpringBoot2.0.3的WEB工程，在MAVEN的pom.xml文件中加入如下依赖 pom文件： <dependencies> <!--默认是lettuce客户端--> <dependency> <groupId>org.springframework.boot&...
SpringBoot2.X整合redis连接lettuce增强版本，支持多数据库切换，主从集群，哨兵
03-22
基于`SpringBoot2.X + Lettuce`实现Redis集成和多库实时切换是一个非常实用的项目。以下是对该项目的一些重点说明: 1. **项目概述** 该项目的主要目标是在`SpringBoot`应用中集成`Lettuce`作为Redis客户端,实现对...
SpringBoot 整合 Lettuce Redis的实现方法
08-25
SpringBoot 整合 Lettuce Redis 的实现方法 Spring Boot 是为了简化 Spring 应用的创建、运行、调试、部署等一系列问题而诞生的产物，自动装配的特性让我们可以更好的关注业务本身而不是外部的 XML 配置。 Spring ...
SpringBoot整合Lettuce redis过程解析
08-25
SpringBoot整合Lettuce Redis过程解析 在本文中，我们将详细介绍SpringBoot整合Lettuce Redis的过程解析。Lettuce是Redis的客户端程序，与Jedis相比，Lettuce基于Netty的连接实例，可以在多个线程间并发访问，且...
springboot-redis:springboot redis演示
05-18
首先，让我们理解SpringBoot如何整合Redis。SpringBoot提供了`spring-boot-starter-data-redis`起步依赖，这使得与Redis的连接配置变得极为简单。只需要在`pom.xml`或`build.gradle`文件中添加该依赖，SpringBoot就...
springboot 配置redis Lettuce连接池
weixin_46266718的博客
02-16 713
Springboot 配置链接redis
SpringBoot整合Redis（Lettuce）
wejack的专栏
07-14 609
在SpringBoot 1.5.x版本默认的Redis客户端是Jedis实现的，SpringBoot 2.x版本默认客户端是用lettuce实现的。创建SpringBoot工程默认是application.propertis，但推荐使用.yml文件，所以我将其修改为.yml文件。因为默认的模板只能存储字符串类型的，所以我们需要自定义RedisTemplate，满足可以存放更多类型的数据。Jedis是直接连接Redis Server，在多线程环境下是非线程安全的，只有使用连接池。
Spring Boot Redis配置（默认Lettuce）
进击的小白
09-21 1万+
Springboot reids
在SpringBoot中集成Redis之Lettuce
wsdhla的专栏
06-29 490
在SpringBoot中集成Redis之Lettuce
SpringBoot集成Redis使用Lettuce
zq987654的博客
02-24 6892
Redis是最常用的KV数据库，Spring 通过模板方式（RedisTemplate）提供了对Redis的数据查询和操作功能。我们在谈基础数据结构时，讨论的是存储值的数据类型，主要包括常见的5种数据类型，分别是：String、List、Set、Zset、Hash。元素的排列顺序由分数的大小决定；包含方法有添加、获取、删除单个元素以及根据分值范围或成员来获取元素。Jedis：是Redis的Java实现客户端，提供了比较全面的Redis命令的支持。字符串的集合，包含基础的方法有看是否存在添加、获取、删除。
Redis 客户端之Lettuce配置使用（基于Spring Boot 2.x）
fendou_0123456789的博客
07-10 477
https://blog.csdn.net/lms1719/article/details/83653298 本人做笔记参考使用
Redis【8】-SpringBoot2.x中redis使用(lettuce)
listeningdu的博客
12-11 570
导致的重复提交，而其也不会出现浏览器表单重复提交的警告，也能消除按浏览器前进和后退按导致的同样问题。简言之，当用户提交了表单后，你去执行一个客户端的重定向，转到提交成功信息页面。将表单页面发给浏览器，用户录入信息后点击提交，在服务器端，获取表单中隐藏字段的值，与。页面发给浏览器，用户录入信息后点击提交，在服务器端，获取表单中隐藏字段的值，与。中的唯一标识符比较，相等说明是首次提交，就处理本次请求，然后将。一标识符比较，相等说明是首次提交，就处理本次请求，然后将。，同时将它写入表单的隐藏字段中，然后将表单。
springboot整合redis lettuce
06-28
### 回答1： Spring Boot可以通过Lettuce来整合Redis。Lettuce是一个高性能的Redis客户端，支持异步、响应式和线程安全的操作。在Spring Boot中，我们可以通过添加Lettuce的依赖来使用它。然后，我们需要在application.properties文件中配置Redis的连接信息，包括主机名、端口号、密码等。最后，我们可以通过注入LettuceConnectionFactory来获取Redis连接，然后使用RedisTemplate或者ReactiveRedisTemplate来进行Redis操作。 ### 回答2： Redis是一种高效的NoSQL数据库，通过使用SpringBoot框架与Redislettuce进行集成，我们可以轻松地在应用程序中使用Redis实现缓存，定时任务和消息队列等功能。 1. 添加Redislettuce依赖 我们需要在项目的pom.xml文件中添加redislettuce的依赖项，以便能够在应用程序中使用redislettuce客户端。 ``` <dependency> <groupId>io.lettuce</groupId> <artifactId>lettuce-core</artifactId> <version>x.x.x</version> </dependency> ``` 注：x为当前最新版本号 2. 配置redislettuce客户端 我们需要在应用程序中创建一个RedisConnectionFactory实例,通过该实例连接Redis数据库。我们可以使用LettuceConnectionFactory类来创建RedisConnectionFactory实例。 在我们的Spring Boot应用程序中，我们可以通过application.yml或application.properties文件配置Redis数据库的相关信息。 ``` spring.redis.host=localhost spring.redis.port=6379 spring.redis.password= ``` 我们可以通过配置类将redislettuce客户端注册到Spring容器中，以便在应用程序中使用。 ``` @Configuration @EnableCaching public class RedisLettuceConfig { @Autowired private Environment env; @Bean public RedisConnectionFactory redisConnectionFactory() { LettuceClientConfiguration clientConfig = LettuceClientConfiguration.builder() .useSsl().and() .commandTimeout(Duration.ofSeconds(2)) .shutdownTimeout(Duration.ZERO) .build(); RedisStandaloneConfiguration serverConfig = new RedisStandaloneConfiguration( env.getProperty("spring.redis.host"), Integer.parseInt(env.getProperty("spring.redis.port"))); return new LettuceConnectionFactory(serverConfig, clientConfig); } @Bean public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(redisConnectionFactory); template.setKeySerializer(new StringRedisSerializer()); template.setValueSerializer(new JdkSerializationRedisSerializer()); return template; } } ``` 3. 使用redislettuce 我们可以在我们的Java代码中使用Spring缓存抽象缓存结果，Spring会根据其缓存配置自动缓存和加载数据。我们可以使用Spring的CacheAbstraction为存储在Redis中的数据创建缓存注解。 ``` @Cacheable(value="Category", key="‘category_cache_’+#root.args[0]") public Category getCategoryById(Long id) { // fetch category by id // if not found, return null return category; } @CachePut(value="Category", key="‘category_cache’+#root.args[0].id") public Category updateCategory(Category category) { // update category // return updated category } @CacheEvict(value="Category", key="‘category_cache’+#root.args[0]") public void deleteCategoryById(Long id) { // delete category by id } ``` 我们可以通过以下方式操作redis: ``` @Autowired private RedisTemplate<String,Object> redisTemplate; public void add(String key, Object value) { redisTemplate.opsForValue().set(key, value); } public Object get(String key) { return redisTemplate.opsForValue().get(key); } public void delete(String key) { redisTemplate.delete(key); } ``` 总结 使用Spring Boot框架与Redislettuce进行集成，我们可以轻松地在应用程序中使用Redis实现缓存，定时任务和消息队列等功能。步骤如下： 1. 添加Redislettuce依赖 2. 配置redislettuce客户端 3. 使用redislettuce 该应用程序允许简单的操作redis数据库。无论是在单个节点还是在集群中，redis集成都将非常实用。使用redislettuce的标准连接池大小和异步API支持，可以轻松地处理高负载、高并发的场景。 ### 回答3： Spring Boot是一个开源框架，用于构建可扩展和可配置的Java应用程序。它提供了一组流行的功能，在开发人员中广泛使用。Redis是一种基于内存的高性能键值数据存储系统，可以用于缓存和持久化数据。 Lettuce是一个高级的Redis客户端库，支持异步、可扩展、非阻塞、事件驱动模型。它还支持集群、TLS、Redis Sentinel等强大功能。在Spring Boot中，可以通过使用Lettuce来集成Redis。 下面是使用Spring Boot整合Redis Lettuce的步骤： 第一步是添加依赖项。在Maven项目中，我们需要添加以下依赖项： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>io.lettuce</groupId> <artifactId>lettuce-core</artifactId> <version>X.Y.Z</version> </dependency> ``` 请注意，`X.Y.Z`应替换为所需的Lettuce版本。 第二步是配置Redis连接。我们可以使用application.properties或application.yml文件来配置Redis连接。下面是一个简单的例子： ```yaml spring.redis.host=localhost spring.redis.port=6379 ``` 这里我们指定Redis服务器的主机和端口。 第三步是在应用程序中使用Redis。我们可以使用Spring Boot提供的`RedisTemplate`类来访问Redis。在以下示例中，我们向Redis中设置字符串，并在稍后检索它： ```java @Autowired private RedisTemplate<String, String> redisTemplate; public void setKey(String key, String value) { redisTemplate.opsForValue().set(key, value); } public String getKey(String key) { return redisTemplate.opsForValue().get(key); } ``` 请注意，`RedisTemplate`类使用Spring Boot自动配置中指定的Redis连接。我们可以通过调用`opsForValue()`方法来访问Redis字符串。 最后，我们需要确保Redis服务器已启动，并在应用程序启动时连接。 总之，通过上述步骤，我们可以轻松地在Spring Boot中集成Redis Lettuce，并使用Spring Boot提供的RedisTemplate来访问Redis。这些步骤可以提高应用程序的性能和可伸缩性，以满足不同业务场景的需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值