Springboot整合lettuce并优化代码

最新推荐文章于 2024-03-01 16:28:49 发布
最新推荐文章于 2024-03-01 16:28:49 发布
阅读量1.8k 收藏
点赞数
分类专栏： redis 文章标签： redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdnleaderyang/article/details/107148866
版权

优化前

添加pom依赖

<!--        默认是lettuce客户端-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
<!--        redis依赖commons-pool-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>

修改yml文件

server:
  port: 8080
spring:
  redis:
    port: 6379
    #    password:
    host: 192.168.214.128
    lettuce:
      pool:
        max-active: 8  #连接池最大连接数（使用负数表示没有限制）
        max-idle: 6   #连接池最大空闲数
        min-idle: 2   #连接池最小空闲数
        max-wait: 1000 #连接池最大阻塞等待时间(使用负值表示没有限制)
      shutdown-timeout: 100 #关闭超时时间

添加实体类

package com.yang.pojo;

import java.io.Serializable;

/**
 * Description:
 * date: 2020/7/4 21:09
 *
 * @author Crille-g
 * @version 1.0
 */

public class User implements Serializable {
    private String name;
    private String id;
    private Integer age;

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", id='" + id + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

创建配置类(数据保存在redis中时，要进行序列化，默认使用JDK进行数据序列化)

package com.yang.config;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * Description:
 * date: 2020/7/4 21:55
 *
 * @author Crille-g
 * @version 1.0
 */
@Configuration
public class RedisConfig {
    /**
     * Spring data 提供了RedisTemplate模板
     * 模板封装了redis连接池管理的逻辑，业务代码不需要关心获取\释放连接逻辑;
     * spring redis 同时支持Jedis 客户端操作;
     *
     */
    @Bean
    public RedisTemplate<String,Object> redisTemplate(LettuceConnectionFactory factory){
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);

        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        //在使用注解@Bean返回RedisTemplate时，同时配置hashkey与hashvalue的序列化方式。
        //key序列化方式采用String
        template.setKeySerializer(stringRedisSerializer);
        //value序列化方式采用JACKSON
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //hash的key序列化方式采用String
        template.setHashKeySerializer(stringRedisSerializer);
        //hash的value序列化方式采用JACKSON
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

创建接口

package com.yang.service;

import com.yang.pojo.User;

/**
 * Description:
 * date: 2020/7/4 22:28
 *
 * @author Crille-g
 * @version 1.0
 */
public interface UserService {
    public String getString(String key);
    public User selectById(String id);
    public void expireStr(String key,String value);
}

实现接口

package com.yang.service.impl;

import com.yang.pojo.User;
import com.yang.service.UserService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

/**
 * Description:
 * date: 2020/7/4 22:29
 *
 * @author Crille-g
 * @version 1.0
 */
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private RedisTemplate<String,Object> redisTemplate;

    private Logger log=LoggerFactory.getLogger(UserServiceImpl.class);

    /**
     *测试String类型
     */
    @Override
    public String getString(String key) {
//        System.out.println(redisTemplate);
//        log.info("redistemplate测试");
        if (redisTemplate.hasKey(key)){//判断key是否存在
            log.info("redis中查询");
            return (String) redisTemplate.opsForValue().get(key);


        }else{
            String val="lettuce";
            log.info("mysql中查询");
            redisTemplate.opsForValue().set(key,val);
            log.info("存入redis中");
            return val;
        }

    }
    /**
     *测试String类型
     * 用户输入数据时，给key设置一个有效期
     */
    public void expireStr(String key,String value){
        redisTemplate.opsForValue().set(key,value);
        redisTemplate.expire(key,1, TimeUnit.HOURS);
    }

    /**
     * 测试hash类型
     * @param id
     * @return
     */

    @Override
    public User selectById(String id) {
//        redisTemplate.hasKey(key)  判断整个key是否存在;
        // user:id user:1 user:2
        if (redisTemplate.opsForHash().hasKey("user",id)){
            log.info("redis中查询");
            return (User)redisTemplate.opsForHash().get("user", id);
        }else{
             log.info("查询mysql");
             User user=new User();
             user.setAge(20);
             user.setName("网二");
             user.setId(id);
             /*
             @param h 用户实体
             @param hk 用户主键 id
             @param h 整个对象
              */
             redisTemplate.opsForHash().put("user",id,user);
             return user;
        }

    }
}

测试代码

package com.yang;

import com.yang.pojo.User;
import com.yang.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import javax.xml.ws.soap.Addressing;

@SpringBootTest
class BootLettuceApplicationTests {
    @Autowired
    private UserService userService;

    @Test
    void contextLoads() {
        userService.getString("aaaa");
    }

    @Test
    void t1() {
        System.out.println(userService.getString("redisTemplate")
        );
    }
    @Test
    void t2(){
        userService.expireStr("test","测试");
        System.out.println("操作成功");
    }
    @Test
    void t3(){
        User user=userService.selectById("1000");
        System.out.println("查询的结果"+user);
    }
}

代码出现的问题

问题1：代码在传递数据时出现了很多相同的字符串。//把重复使用的提取出来

//方案一：声明一个工具类，直接调用常量

public interface KeyNameUtil {
    public static  final String USER="user";

}

public User selectById(String id) {
//        redisTemplate.hasKey(key)  判断整个key是否存在;
        // user:id user:1 user:2
        if (redisTemplate.opsForHash().hasKey(KeyNameUtil.USER,id)){
            log.info("redis中查询");
            return (User)redisTemplate.opsForHash().get(KeyNameUtil.USER, id);
        }else{
             log.info("查询mysql");
             User user=new User();
             user.setAge(20);
             user.setName("网二");
             user.setId(id);
             /*
             @param h 用户实体
             @param hk 用户主键 id
             @param h 整个对象
              */
             redisTemplate.opsForHash().put(KeyNameUtil.USER,id,user);
             return user;
        }

    }

//方案二：在实体类中，声明方法获取常量

public class User implements Serializable {
    private String name;
    private String id;
    private Integer age;

    public static String getKeyName(){
        return "user";
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", id='" + id + '\'' +
                ", age=" + age +
                '}';
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }
}

public User selectById(String id) {
//        redisTemplate.hasKey(key)  判断整个key是否存在;
        // user:id user:1 user:2
        if (redisTemplate.opsForHash().hasKey(User.getKeyName(),id)){
            log.info("redis中查询");
            return (User)redisTemplate.opsForHash().get(User.getKeyName(), id);
        }else{
             log.info("查询mysql");
             User user=new User();
             user.setAge(20);
             user.setName("网二");
             user.setId(id);
             /*
             @param h 用户实体
             @param hk 用户主键 id
             @param h 整个对象
              */
             redisTemplate.opsForHash().put(User.getKeyName(),id,user);
             return user;
        }

    }

问题2：强制类型转换问题
问题3：RedisTemplate.opsFor**()写的很长一串

//解决方案：

@Resource(name = "redisTemplate")
private ValueOperations<String,String> string ;//相当于RedisTemplate.opsForValue();
@Resource(name = "redisTemplate")
private HashOperations<String,String,User> hash;//k:user; hk:id; hv:Object

//return (String) redisTemplate.opsForValue().get(key);
return string.get(key);
// redisTemplate.opsForValue().set(key,val);
string.set(key,val);
-----------------------------------
//return (User)redisTemplate.opsForHash().get(User.getKeyName(), id);
  return hash.get(User.getKeyName(),id);
// redisTemplate.opsForHash().put(User.getKeyName(),id,user);
   hash.put(User.getKeyName(),id,user);
来一只烤虾
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot 整合 Lettuce Redis的实现方法
08-25
主要介绍了SpringBoot 整合 Lettuce Redis的实现方法，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
springboot2配置Lettuce连接池完整代码
03-27
springboot2配置Lettuce连接池完整代码，采用common2-pool连接池，Lettuce为redis高级客户端，由于阅读官网文档太简单，无法完成配置，所有本示例是通过阅读源码后编写的
SpringBoot整合Redis(Lettuce)
最新发布
2302_76812487的博客
03-01 2395
spingboot3.0系列示例代码采用3.1.0版本，jdk版本使用17+Lettuce 简介：Lettuce 是 Redis 的一款高级 Java 客户端，与 Jedis 并列成为最热门的客户端之一。相比老牌 Jedis，Lettuce 属于后起之秀，不仅功能丰富，而且提供了很多新的功能特性，比如异步操作、响应式编程等等，同时还解决了 Jedis 中线程不安全的问题。Lettuce 和 Jedis 一样，都是连接 Redis Server 的客户端程序。Jedis 在实现上是直连 Redis Serve
SpringBoot整合Lettuce redis过程解析
08-25
主要介绍了SpringBoot整合Lettuce redis过程解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Springboot2.X集成redis集群(Lettuce)连接的方法
08-27
主要介绍了Springboot2.X集成redis集群(Lettuce)连接的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
springboot项目整合.zip
12-31
springboot学习总结，代码示例 个人博客 https://blog.csdn.net/hykwhjc 第一篇：构建第一个SpringBoot工程] 第二篇：SpringBoot配置详解] 第三篇：SpringBoot日志配置] 第四篇：整合Thymeleaf模板] 第五篇：使用JdbcTemplate访问数据库] 第六篇：整合SpringDataJpa] 第七篇：整合Mybatis] 第八篇：通用Mapper与分页插件的集成] 第九篇：整合Lettuce Redis] 第十篇：使用Spring Cache集成Redis] 第十一篇：集成Swagger在线调试] 第十二篇：初探RabbitMQ消息队列] 第十三篇：RabbitMQ延迟队列] 第十四篇：强大的 actuator 服务监控与管理] 第十五篇：actuator与spring-boot-admin 第十六篇：定时任务详解] 第十七篇：轻松搞定文件上传] 第十八篇：轻松搞定全局异常] 第十九篇：轻松搞定数据验证
SpringBoot整合Redis默认使用Lettuce连接池、推荐连接池参数配置规则，常用数据类型使用场景
hkl_Forever的博客
10-23 9637
1、max-active：大于cpu * 2，通常为(cpu * 2) + 2。2、合理配置 lettuce 连接池参数，一般不会出现过段时间就断开连接的现象。5、time-between-eviction-runs：1s(秒)String：存短信验证码、缓存、计数器、分布式session。HyperLogLog：在线用户数、统计访问量等。GeoHash：同城的人、同城的店等。BitMap：签到打卡、活跃用户等。1、方式一(推荐此方式)
spring默认redis连接库lettuce性能优化，突破性能天花板,获得官方建议方式2倍吞吐量
YiDaiQiongRen的专栏
01-12 4921
spring-data-redis性能优化，使用lettuce库连接池模式，比官方推荐方式性能翻倍。
Redis高级客户端Lettuce详解
m0_67698950的博客
05-26 2661
前提# Lettuce是一个Redis的Java驱动包，初识她的时候是使用RedisTemplate的时候遇到点问题Debug到底层的一些源码，发现spring-data-redis的驱动包在某个版本之后替换为Lettuce。Lettuce翻译为生菜，没错，就是吃的那种生菜，所以它的Logo长这样： 既然能被Spring生态所认可，Lettuce想必有过人之处，于是笔者花时间阅读她的官方文档，整理测试示例，写下这篇文章。编写本文时所使用的版本为Lettuce 5.1.8.RELEASE，Spring
redis 基础知识
Lyndon的专栏
09-07 2328
Redis是一款开源的、内存中的数据结构存储系统，它可以用作数据库、缓存、消息中间件。
Java21 + SpringBoot3整合Redis，使用Lettuce连接池，推荐连接池参数配置，封装Redis操作
zzcoder的博客
01-24 1662
近日心血来潮想做一个开源项目，目标是做一款可以适配多端、功能完备的模板工程，包含后台管理系统和前台系统，开发者基于此项目进行裁剪和扩展来完成自己的功能开发。本项目为前后端分离开发，后端基于Java21和开发，后端使用JWT等技术栈，前端提供了vueangularreactuniapp微信小程序等多种脚手架工程。本文主要介绍在项目中如何整合Redis，JDK版本是Java21。Redis。
性能调优
sj3913的博客
10-30 102
压测cpu压不上去 压测cpu使用率50%左右，有大量iowait，使用arthas追踪慢方法，发现lettuce耗时很长，联系redis中间件组，解决服务端的问题，cpu可达到90A% 查看慢方法 命令:trace 类路径 类方法名 示例：trace com.xxx.helper.impl.xxxxImpl useExchangeVoucher ...
springboot研究九：lettuce连接池很香，撸撸它的源代码
热门推荐
zjj2006的专栏
06-20 1万+
lettuce连接池源码解读
redis的lettuce连接池最佳实践
Clare Tung
01-31 6793
连接池最大连接数：2倍的CPU核数 连接池最大连接数（使用负值表示没有限制） spring.redis.lettuce.pool.max-active=2倍的CPU核数 线程池大小不同，性能对比测试 测试结论 lettuce连接池大小为 2倍的CPU核数 性能最好。 连接池越大，lettuce的性能会下降，不是越大越好。 以上结论只是基于以下的测试数据。 测试数据 ①连接池大小：CPU核数+1；压测线程：200；压测时间：30s。 ②连接池大小：CPU核数+1；压测线程：200；压测时间：60s。
redis lettuce 调优
u012693823的博客
07-26 2802
合理的参数设置可以为你的redis客户端保驾护航，下面将对lettuce使用的一些重要参数进行说明和建议 序号 参数名 含义 默认值 使用建议 序号 参数名 含义 默认值 使用建议 1 enableAllAdaptiveRefreshTriggers redis
redis-lettuce连接池
每天都充一点电
01-10 4530
redis lettuce连接池
springboot的 spring.redis.lettuce的max-active、max-idle、min-idle的搭配
qq_41045651的博客
08-17 4522
在Spring Boot中，使用Lettuce作为Redis客户端是一种常见的选择。Lettuce是一个高性能、可扩展的异步Redis客户端。下面是关于配置文件中和：配置Redis服务器的主机名和端口号。：选择要使用的数据库索引。默认情况下，Redis有16个数据库，索引从0到15。：指定连接池中的最大活动连接数。当连接数达到此值时，后续的连接请求将被阻塞，默认值为8。：指定连接池中的最大空闲连接数。超过此数目的空闲连接将被释放，默认值为8。：指定连接池中的最小空闲连接数。
springboot整合Redis中连接池jedis与lettuce的对比和实现
todoitbo的博客
09-15 3918
springboot整合Redis中连接池jedis与lettuce的对比和实现
springboot整合lettuce
08-11
对于Spring Boot整合Lettuce，你可以按照以下步骤进行操作： 1. 首先，在你的Spring Boot项目的pom.xml文件中添加Lettuce的依赖项。例如，你可以添加以下代码到标签中： ```xml <groupId>io.lettuce ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值