Spring-data-redis: 事务与pipeline

最新推荐文章于 2025-06-12 11:48:04 发布
转载 最新推荐文章于 2025-06-12 11:48:04 发布 · 8.1k 阅读 · 3

本文介绍如何使用Spring Data Redis实现事务和Pipeline操作，包括配置文件设置、事务处理及Pipeline命令执行示例。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

  1.

    本文主要展示如何使用spring-data-redis编写事务和pipeline：

    1.配置文件：

    <beans xmlns="http://www.springframework.org/schema/beans" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd" default-autowire="byName">
  <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
    <property name="maxActive" value="32"></property>
    <property name="maxIdle" value="6"></property>
    <property name="maxWait" value="15000"></property>
    <property name="minEvictableIdleTimeMillis" value="300000"></property>
    <property name="numTestsPerEvictionRun" value="3"></property>
    <property name="timeBetweenEvictionRunsMillis" value="60000"></property>
    <property name="whenExhaustedAction" value="1"></property>
  </bean>
  <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy">
    <property name="poolConfig" ref="jedisPoolConfig"></property>
    <property name="hostName" value="127.0.0.1"></property>
    <property name="port" value="6379"></property>
    <property name="password" value="0123456"></property>
    <property name="timeout" value="15000"></property>
    <property name="usePool" value="true"></property>
  </bean>
  <bean id="jedisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
    <property name="connectionFactory" ref="jedisConnectionFactory"></property>
    <property name="keySerializer">
      <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
    </property>
  </bean>
</beans>
  <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
    <property name="maxActive" value="32"></property>
    <property name="maxIdle" value="6"></property>
    <property name="maxWait" value="15000"></property>
    <property name="minEvictableIdleTimeMillis" value="300000"></property>
    <property name="numTestsPerEvictionRun" value="3"></property>
    <property name="timeBetweenEvictionRunsMillis" value="60000"></property>
    <property name="whenExhaustedAction" value="1"></property>
  </bean>
  <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy">
    <property name="poolConfig" ref="jedisPoolConfig"></property>
    <property name="hostName" value="127.0.0.1"></property>
    <property name="port" value="6379"></property>
    <property name="password" value="0123456"></property>
    <property name="timeout" value="15000"></property>
    <property name="usePool" value="true"></property>
  </bean>
  <bean id="jedisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
    <property name="connectionFactory" ref="jedisConnectionFactory"></property>
    <property name="keySerializer">
      <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
    </property>
  </bean>
</beans>

    2. 程序实例：

    package com.sample.redis.sdr;
public class RedisClientTest {

  //private JsonRedisSeriaziler seriaziler;
  
  private RedisTemplate redisTemplate;

  public void setRedisTemplate(RedisTemplate redisTemplate) {
    this.redisTemplate = redisTemplate;
  }
  
  public void valueOperationSample(){
    ValueOperations<String, User> valueOper = redisTemplate.opsForValue();
    User suser = new User(1,"zhangsan",12);
    valueOper.set("user:" + suser.getId(),suser);
    System.out.println(valueOper.get("user:" + suser.getId()).getName());
  }
  
  public void listOperationSample(){
    User suser = new User(1,"zhangsan",12);
    ListOperations<String, User> listOper = redisTemplate.opsForList();
    listOper.leftPush("user:list", suser);//lpush,head
    listOper.rightPush("user:list", suser);//rpush,tail
  } com.sample.redis.sdr;
public class RedisClientTest {

  //private JsonRedisSeriaziler seriaziler;
  
  private RedisTemplate redisTemplate;

  public void setRedisTemplate(RedisTemplate redisTemplate) {
    this.redisTemplate = redisTemplate;
  }
  
  public void valueOperationSample(){
    ValueOperations<String, User> valueOper = redisTemplate.opsForValue();
    User suser = new User(1,"zhangsan",12);
    valueOper.set("user:" + suser.getId(),suser);
    System.out.println(valueOper.get("user:" + suser.getId()).getName());
  }
  
  public void listOperationSample(){
    User suser = new User(1,"zhangsan",12);
    ListOperations<String, User> listOper = redisTemplate.opsForList();
    listOper.leftPush("user:list", suser);//lpush,head
    listOper.rightPush("user:list", suser);//rpush,tail
  }
      
      
  public void boundValueOperationSample(){
    User suser = new User(1,"zhangsan",12);
    BoundValueOperations<String, User> bvo = redisTemplate.boundValueOps("user:" + suser.getId());
    bvo.set(suser);
    bvo.expire(60, TimeUnit.MINUTES);
  }
  
  /**
   * 非连接池环境下，事务操作；对于sdr而言，每次操作(例如，get，set)都有会从pool中获取connection；
   * 因此在连接池环境下，使用事务需要注意。
   */
  public void txUnusedPoolSample(){
    User suser = new User(1,"zhangsan",12);
    redisTemplate.watch("user:" + suser.getId());
    redisTemplate.multi();
    ValueOperations<String, User> tvo = redisTemplate.opsForValue();
    tvo.set("user:" + suser.getId(), suser);
    redisTemplate.exec();
  }
  
  /**
   * 在连接池环境中，需要借助sessionCallback来绑定connection
   */
  public void txUsedPoolSample(){
    SessionCallback<User> sessionCallback = new SessionCallback<User>() {
      @Override
      public User execute(RedisOperations operations) throws DataAccessException {
        operations.multi();
        User user = new User(2,"lisi",32);
        String key = "user:" + user.getId();
        BoundValueOperations<String, User> oper = operations.boundValueOps(key);
        oper.set(user);
        oper.expire(60, TimeUnit.MINUTES);
        operations.exec();
        return user;
      }
    };
    redisTemplate.execute(sessionCallback);
  }
  
  /**
   * pipeline : 1，正确使用方式
   */
  public void pipelineSample(){
    final byte[] rawKey = redisTemplate.getKeySerializer().serialize("user_total");
    //pipeline
    RedisCallback<List<Object>> pipelineCallback = new RedisCallback<List<Object>>() {
      @Override
      public List<Object> doInRedis(RedisConnection connection) throws DataAccessException {
        connection.openPipeline();
        connection.incr(rawKey);
        connection.incr(rawKey);
        return connection.closePipeline();
      }
      
    };
    
    List<Object> results = (List<Object>)redisTemplate.execute(pipelineCallback);
    for(Object item : results){
      System.out.println(item.toString());
    }
  }
  //pipeline:备用方式
  public void pipelineSampleX(){
    byte[] rawKey = redisTemplate.getKeySerializer().serialize("user_total");
    RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
    RedisConnection redisConnection = factory.getConnection();
    List<Object> results;
    try{
      redisConnection.openPipeline();
      redisConnection.incr(rawKey);
      results = redisConnection.closePipeline();
    }finally{
      RedisConnectionUtils.releaseConnection(redisConnection, factory);
    }
    if(results == null){
      return;
    }
    for(Object item : results){
      System.out.println(item.toString());
    }

  }
}
  public void boundValueOperationSample(){
    User suser = new User(1,"zhangsan",12);
    BoundValueOperations<String, User> bvo = redisTemplate.boundValueOps("user:" + suser.getId());
    bvo.set(suser);
    bvo.expire(60, TimeUnit.MINUTES);
  }
  
  /**
   * 非连接池环境下，事务操作；对于sdr而言，每次操作(例如，get，set)都有会从pool中获取connection；
   * 因此在连接池环境下，使用事务需要注意。
   */
  public void txUnusedPoolSample(){
    User suser = new User(1,"zhangsan",12);
    redisTemplate.watch("user:" + suser.getId());
    redisTemplate.multi();
    ValueOperations<String, User> tvo = redisTemplate.opsForValue();
    tvo.set("user:" + suser.getId(), suser);
    redisTemplate.exec();
  }
  
  /**
   * 在连接池环境中，需要借助sessionCallback来绑定connection
   */
  public void txUsedPoolSample(){
    SessionCallback<User> sessionCallback = new SessionCallback<User>() {
      @Override
      public User execute(RedisOperations operations) throws DataAccessException {
        operations.multi();
        User user = new User(2,"lisi",32);
        String key = "user:" + user.getId();
        BoundValueOperations<String, User> oper = operations.boundValueOps(key);
        oper.set(user);
        oper.expire(60, TimeUnit.MINUTES);
        operations.exec();
        return user;
      }
    };
    redisTemplate.execute(sessionCallback);
  }
  
  /**
   * pipeline : 1，正确使用方式
   */
  public void pipelineSample(){
    final byte[] rawKey = redisTemplate.getKeySerializer().serialize("user_total");
    //pipeline
    RedisCallback<List<Object>> pipelineCallback = new RedisCallback<List<Object>>() {
      @Override
      public List<Object> doInRedis(RedisConnection connection) throws DataAccessException {
        connection.openPipeline();
        connection.incr(rawKey);
        connection.incr(rawKey);
        return connection.closePipeline();
      }
      
    };
    
    List<Object> results = (List<Object>)redisTemplate.execute(pipelineCallback);
    for(Object item : results){
      System.out.println(item.toString());
    }
  }
  //pipeline:备用方式
  public void pipelineSampleX(){
    byte[] rawKey = redisTemplate.getKeySerializer().serialize("user_total");
    RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
    RedisConnection redisConnection = factory.getConnection();
    List<Object> results;
    try{
      redisConnection.openPipeline();
      redisConnection.incr(rawKey);
      results = redisConnection.closePipeline();
    }finally{
      RedisConnectionUtils.releaseConnection(redisConnection, factory);
    }
    if(results == null){
      return;
    }
    for(Object item : results){
      System.out.println(item.toString());
    }

  }
}
  2.  
  
  public void boundValueOperationSample(){
    User suser = new User(1,"zhangsan",12);
    BoundValueOperations<String, User> bvo = redisTemplate.boundValueOps("user:" + suser.getId());
    bvo.set(suser);
    bvo.expire(60, TimeUnit.MINUTES);
  }
  
  /**
   * 非连接池环境下，事务操作；对于sdr而言，每次操作(例如，get，set)都有会从pool中获取connection；
   * 因此在连接池环境下，使用事务需要注意。
   */
  public void txUnusedPoolSample(){
    User suser = new User(1,"zhangsan",12);
    redisTemplate.watch("user:" + suser.getId());
    redisTemplate.multi();
    ValueOperations<String, User> tvo = redisTemplate.opsForValue();
    tvo.set("user:" + suser.getId(), suser);
    redisTemplate.exec();
  }
  
  /**
   * 在连接池环境中，需要借助sessionCallback来绑定connection
   */
  public void txUsedPoolSample(){
    SessionCallback<User> sessionCallback = new SessionCallback<User>() {
      @Override
      public User execute(RedisOperations operations) throws DataAccessException {
        operations.multi();
        User user = new User(2,"lisi",32);
        String key = "user:" + user.getId();
        BoundValueOperations<String, User> oper = operations.boundValueOps(key);
        oper.set(user);
        oper.expire(60, TimeUnit.MINUTES);
        operations.exec();
        return user;
      }
    };
    redisTemplate.execute(sessionCallback);
  }
  
  /**
   * pipeline : 1，正确使用方式
   */
  public void pipelineSample(){
    final byte[] rawKey = redisTemplate.getKeySerializer().serialize("user_total");
    //pipeline
    RedisCallback<List<Object>> pipelineCallback = new RedisCallback<List<Object>>() {
      @Override
      public List<Object> doInRedis(RedisConnection connection) throws DataAccessException {
        connection.openPipeline();
        connection.incr(rawKey);
        connection.incr(rawKey);
        return connection.closePipeline();
      }
      
    };
    
    List<Object> results = (List<Object>)redisTemplate.execute(pipelineCallback);
    for(Object item : results){
      System.out.println(item.toString());
    }
  }
  //pipeline:备用方式
  public void pipelineSampleX(){
    byte[] rawKey = redisTemplate.getKeySerializer().serialize("user_total");
    RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
    RedisConnection redisConnection = factory.getConnection();
    List<Object> results;
    try{
      redisConnection.openPipeline();
      redisConnection.incr(rawKey);
      results = redisConnection.closePipeline();
    }finally{
      RedisConnectionUtils.releaseConnection(redisConnection, factory);
    }
    if(results == null){
      return;
    }
    for(Object item : results){
      System.out.println(item.toString());
    }

  }
}
  public void boundValueOperationSample(){
    User suser = new User(1,"zhangsan",12);
    BoundValueOperations<String, User> bvo = redisTemplate.boundValueOps("user:" + suser.getId());
    bvo.set(suser);
    bvo.expire(60, TimeUnit.MINUTES);
  }
  
  /**
   * 非连接池环境下，事务操作；对于sdr而言，每次操作(例如，get，set)都有会从pool中获取connection；
   * 因此在连接池环境下，使用事务需要注意。
   */
  public void txUnusedPoolSample(){
    User suser = new User(1,"zhangsan",12);
    redisTemplate.watch("user:" + suser.getId());
    redisTemplate.multi();
    ValueOperations<String, User> tvo = redisTemplate.opsForValue();
    tvo.set("user:" + suser.getId(), suser);
    redisTemplate.exec();
  }
  
  /**
   * 在连接池环境中，需要借助sessionCallback来绑定connection
   */
  public void txUsedPoolSample(){
    SessionCallback<User> sessionCallback = new SessionCallback<User>() {
      @Override
      public User execute(RedisOperations operations) throws DataAccessException {
        operations.multi();
        User user = new User(2,"lisi",32);
        String key = "user:" + user.getId();
        BoundValueOperations<String, User> oper = operations.boundValueOps(key);
        oper.set(user);
        oper.expire(60, TimeUnit.MINUTES);
        operations.exec();
        return user;
      }
    };
    redisTemplate.execute(sessionCallback);
  }
  
  /**
   * pipeline : 1，正确使用方式
   */
  public void pipelineSample(){
    final byte[] rawKey = redisTemplate.getKeySerializer().serialize("user_total");
    //pipeline
    RedisCallback<List<Object>> pipelineCallback = new RedisCallback<List<Object>>() {
      @Override
      public List<Object> doInRedis(RedisConnection connection) throws DataAccessException {
        connection.openPipeline();
        connection.incr(rawKey);
        connection.incr(rawKey);
        return connection.closePipeline();
      }
      
    };
    
    List<Object> results = (List<Object>)redisTemplate.execute(pipelineCallback);
    for(Object item : results){
      System.out.println(item.toString());
    }
  }
  //pipeline:备用方式
  public void pipelineSampleX(){
    byte[] rawKey = redisTemplate.getKeySerializer().serialize("user_total");
    RedisConnectionFactory factory = redisTemplate.getConnectionFactory();
    RedisConnection redisConnection = factory.getConnection();
    List<Object> results;
    try{
      redisConnection.openPipeline();
      redisConnection.incr(rawKey);
      results = redisConnection.closePipeline();
    }finally{
      RedisConnectionUtils.releaseConnection(redisConnection, factory);
    }
    if(results == null){
      return;
    }
    for(Object item : results){
      System.out.println(item.toString());
    }

  }
}

【性能优化】记录一次利用Spring Data Redis操作Pipelined，启动时加载大数据量到缓存的方法。
爱摸鱼的小河马
02-13 248
项目启动时，需要初始化相关角色的数据权限资源信息到内存中，避免重复DB查询，利用Redis优化查询速度。
深入学习 Redis - 基于 Spring Data Redis 操作 Redis
CYK_byte的博客
07-30 2365
RedisTemplate 是把 Redis 的方法，分成了几个类别来进行组织，和原生的 Redis 命令有一定的差异~ 作者的初心是希望通过上述封装，让接口看起来更简单，但在我看来，并没有达成，反而因为与 Redis 原生命令差异，提高了使用者的学习成本.之前使用 Jedis 是通过 Jedis 对象里的各种方法来操作 redis 的，此处 Spring 则是通过 SpringRedisTemplate 来操作 redis.
【Redis】Spring Data Redis使用Pipeline
后端研发工程师Marion的博客
02-14 1001
一、参考资料 Spring Data Redis的execute和executePipelined的区别
Java 中使用 Redis 注解版缓存——补充
m0_73941339的博客
06-12 929
通过 @EnableCaching 注解和 Spring 的缓存抽象，我们可以非常方便地在 Java 应用中集成 Redis 缓存。这种声明式的缓存方式大大简化了代码，使我们能够专注于业务逻辑而不是缓存实现细节。在实际应用中，我们需要根据业务特点合理配置缓存策略，注意缓存一致性问题，并采取措施防止缓存穿透、击穿和雪崩等常见问题。
spring data redis pipeline
Andy's Blog
04-11 1598
import org.apache.commons.pool2.impl.GenericObjectPoolConfig; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframewor...
spring-data-redis-客户端，配置，序列化，Pipeline管道
存在,即合理
07-07 890
Rdis是一种基于客户端-服务端模型以及请求/响应协议的TCP服务。当请求进来以后，都是经过服务器进行返回，那如果服务器没有响应时，那么其他请求进入等待。这时服务器也无法处理新请求，那有没有办法解决呢？使用管道就能解决，即：将多个命令发送到服务器，而不用等待回复，最后在一个步骤中读取该答复。这种技术应用非常广泛比如MySQL的批量插入就如此。Spring Data Redis 版本 Jedis 版本。2. 默认使用的JDK的序列化。1. 对象必须实现序列化接口。
Spring-data-redis 第三天（Pipeline）
zhanghaj011的专栏
04-18 480
1.我们首先来说下pipeline（我只是 一个想自学的小人物，很多地方说的不对 请一定要一定要说一下，谢谢）       Pipeline 也就是管道，也是一种设计思想，在很多web 服务器设计上都有体现，比如很出名的Netty（这是下一个学习任务） tomcat 还有Struts2 框架。所以说Pipeline 是什么呢，     在我看来，我觉得用一个词很容易描述，工作流，一个re...
【SpringBoot】整合Redis（使用spring-boot-starter-data-redis）
qq_27579471的博客
08-03 1万+
前言 Jedis是Redis官方推荐的面向Java的操作Redis的客户端，而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端，比Jedis多了自动管理连接池的特性，方便与其他Spring框架进行搭配使用如：SpringCache。 Lettuce 和 Jedis 的都是连接Redis Server的客户端程序。Jedis在实现上是直连redis server，多线程环境下非线
使用spring-data-redis对redis集群进行KEY模糊删除的几种方式
敲代码真难呀。。
11-28 2534
环境：虚拟机3主3从 准备工作： 向redis cluster写入100W条数据 public void multiSet() { long start = System.currentTimeMillis(); //定义key对应的value Consumer consumer = new Consumer(); ...
spring-data-redis连接操作redis
热门推荐
雪水
08-02 2万+
Java连接redis的客户端有很多，其中比较常用的是Jedis. (参考：redis client) spring-data-redis则是对Jedis进行了高度封装，使用起来非常方便。下面就以代码为例说明spring-data-redis的使用。 整个项目使用maven管理jar包，pom文件如下： <project xmlns="http://maven.apache.org/PO
spring-data-redis 连接泄漏，我 TM 人傻了
java111112313213的博客
09-05 808
最近线上又出事儿了，新上线了一个微服务系统，上线之后就开始报各种发往这个系统的请求超时，这是咋回事呢？ 还是经典的通过 JFR 去定位（可以参考我的其他系列文章，经常用到 JFR），对于历史某些请求响应慢，我一般按照如下流程去看： 是否有 STW（Stop-the-world，参考我的另一篇文章：JVM相关 - SafePoint 与 Stop The World 全解）: 是否有 GC 导致的长时间 STW 是否有其他原因导致进程所有线程进入 safepoint 导致 STW 是否 IO 花
spring-data-redis支持批量操作
11-08
1、基于1.8.0的基础上提供批量的数据操作包括get set del hmget hmset方法 2、使用方法如下： public List pipelineGet(Set keys){ return rt.opsForPipeline().get(keys); } public void pipelineSet(Map valueMap){ redisTemplate.opsForPipeline().set(valueMap); } public void pipelineDel(Set keys){ redisTemplate.opsForPipeline().del(keys); } public List<Map<Object,Object>> pipelineHmget(Set keys){ redisTemplate.opsForPipeline().hmget(keys); } public void pipelineHmset(Map<K, Map<Object, Object>> valuesMap){ redisTemplate.opsForPipeline().hmset(valuesMap); }
Spring Data Redis(Pipeling)
秀才的专栏
07-16 5715
Pipelining 管道Redis 提供了对pipelining 管道的支持。管道作用于两点：发送多个命令到服务端而不用等回应；在一个单独的步骤里读取所有的应答。当需要连续发送多个命令时，如连续添加多个元素到同一个集合，使用管道可以提高性能。Spring Data Redis 提供了多个RedisTemplate 方法，使得可以使用管道来执行命令。如果你不关心管道操作的结果，你可以使用标准的ex
Spring data redis 使用 pipelined 批量操作
https://gitee.com/hello-piper/PiperChat
09-25 2432
需求说明 当用到数据的时候，将项目中数据放到redis中，这些数据预计会达到十几万。 方案一 // 这样最简单 list.forEach(s -> redisTemplate.opsForSet().add("key", s)); 如上代码很简单，遍历集合放入redis，但是这样效率低，每次都要获取一次连接，十几万的连接，大部分时间都在创建销毁连接了，真正执行任务的时间相对来说要少很多。 ...
spring-data-redis下 lettuce的pipeline正确配置，（符合redis的pipeline 定义）
getIt的博客
07-03 659
redis的pipeline 定义：一次发送批量操作，再统一解析全部返回结果。减少RTT，提高性能。
Redis及Spring-Data-Redis入门学习
weixin_34257076的博客
09-25 162
2019独角兽企业重金招聘Python工程师标准>>> ...
Springboot下使用Redis管道(pipeline)进行批量操作
weixin_45817985的博客
06-29 1338
Springboot下使用Redis管道(pipeline)进行批量操作
Spring集成redis（pipeline方式）
liuguidongliuguidong的专栏
12-26 3952
1.maven添加spring、redis、log4j依赖 properties设置 &lt;properties&gt; &lt;project.build.sourceEncoding&gt;UTF-8&lt;/project.build.sourceEncoding&gt; &lt;spring.version&gt;4.3.0.RELEASE...
org.springframework.data:spring-data-redis:2.1.2.RELEASE RedisTemplate 设置链接池配置，并举例使用
最新发布
07-03
<think>我们正在配置RedisTemplate的连接池。首先，我们需要配置连接池参数，然后配置Redis连接工厂，再配置RedisTemplate，最后封装一个工具类。根据引用[1]，我们需要配置Redis连接池和RedisTemplate，并建议封装一个RedisUtil类。引用[2]提到Spring-Data-Redis是操作Redis的面向对象方式。引用[3]展示了RedisTemplate针对不同数据结构的操作方法。引用[4]列出了所需的jar包。步骤：1.添加依赖：在pom.xml中添加Spring DataRedis和Jedis（或Lettuce）的依赖。2.配置连接池：使用Jedis连接池，配置参数如最大连接数、最大空闲连接等。3.配置RedisConnectionFactory：设置连接池和Redis服务器地址。4.配置RedisTemplate：设置key和value的序列化方式（通常使用StringRedisSerializer）。5.封装RedisUtil：提供常用的操作方法。下面详细说明：第一步：添加依赖（以Maven为例）```xml<dependencies><!--Spring DataRedis --><dependency><groupId>org.springframework.data</groupId><artifactId>spring-data-redis</artifactId><version>2.5.4</version><!--请根据实际情况选择版本--></dependency><!-- Jedis客户端--><dependency><groupId>redis.clients</groupId><artifactId>jedis</artifactId><version>3.6.0</version><!--请根据实际情况选择版本 --></dependency><!--连接池依赖 --><dependency><groupId>org.apache.commons</groupId><artifactId>commons-pool2</artifactId><version>2.9.0</version></dependency></dependencies>```第二步：配置连接池和Redis连接工厂（以Java配置为例）创建一个配置类，例如RedisConfig.java： ```javaimport org.springframework.context.annotation.Bean;import org.springframework.context.annotation.Configuration; importorg.springframework.data.redis.connection.RedisStandaloneConfiguration; importorg.springframework.data.redis.connection.jedis.JedisConnectionFactory;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.data.redis.serializer.StringRedisSerializer; importredis.clients.jedis.JedisPoolConfig;@Configurationpublicclass RedisConfig {@BeanpublicJedisPoolConfigjedisPoolConfig() {JedisPoolConfig poolConfig =new JedisPoolConfig();//最大连接数poolConfig.setMaxTotal(100);//最大空闲连接数poolConfig.setMaxIdle(50);//最小空闲连接数poolConfig.setMinIdle(20);//当连接池资源耗尽时，等待时间，超出则抛异常，默认为-1（永不超时）poolConfig.setMaxWaitMillis(2000);//从连接池获取连接时，是否进行有效性检查（ping）poolConfig.setTestOnBorrow(true);//向连接池归还连接时，是否进行有效性检查poolConfig.setTestOnReturn(true);//连接空闲时是否进行有效性检查poolConfig.setTestWhileIdle(true);returnpoolConfig;}@Beanpublic JedisConnectionFactory jedisConnectionFactory(JedisPoolConfigjedisPoolConfig) {RedisStandaloneConfiguration config= newRedisStandaloneConfiguration();config.setHostName("localhost");config.setPort(6379);config.setPassword("yourpassword");//如果有密码config.setDatabase(0);//选择数据库JedisConnectionFactory factory= newJedisConnectionFactory(config);factory.setPoolConfig(jedisPoolConfig);return factory;}@BeanpublicRedisTemplate<String,Object>redisTemplate(JedisConnectionFactory jedisConnectionFactory){RedisTemplate<String,Object>template =new RedisTemplate<>();template.setConnectionFactory(jedisConnectionFactory);//设置key的序列化器template.setKeySerializer(new StringRedisSerializer());template.setHashKeySerializer(newStringRedisSerializer());//设置value的序列化器，这里使用Jackson2JsonRedisSerializer来序列化对象//注意：使用Jackson2JsonRedisSerializer需要添加相关依赖（如jackson-databind）//如果只是存储字符串，可以使用StringRedisSerializer//template.setValueSerializer(new StringRedisSerializer());// template.setHashValueSerializer(new StringRedisSerializer());//为了简化，这里value也使用字符串序列化器template.setValueSerializer(newStringRedisSerializer());template.setHashValueSerializer(new StringRedisSerializer());template.afterPropertiesSet();returntemplate;}} ```第三步：封装RedisUtil工具类引用[1]中建议封装RedisUtil类，提供一些常用方法。 ```javaimport org.springframework.data.redis.core.RedisTemplate;import org.springframework.stereotype.Component;import javax.annotation.Resource; importjava.util.concurrent.TimeUnit;@Componentpublic classRedisUtil{@Resourceprivate RedisTemplate<String, Object> redisTemplate;//设置字符串值public voidset(Stringkey,Objectvalue){redisTemplate.opsForValue().set(key,value);}//设置字符串值并设置过期时间（单位：秒）public voidset(Stringkey,Object value, longtimeout){redisTemplate.opsForValue().set(key,value,timeout,TimeUnit.SECONDS);}//获取字符串值publicObject get(String key) {returnredisTemplate.opsForValue().get(key);}//删除keypublic Booleandelete(Stringkey){return redisTemplate.delete(key);}//设置过期时间publicBoolean expire(String key, longtimeout){return redisTemplate.expire(key, timeout, TimeUnit.SECONDS);}//其他方法，如操作Hash、List、Set等，根据需求封装}```第四步：使用示例在Service中注入RedisUtil并使用： ```javaimport org.springframework.stereotype.Service;import javax.annotation.Resource; @Servicepublicclass ExampleService {@ResourceprivateRedisUtilredisUtil;public voidexample(){//存储字符串redisUtil.set("name","JohnDoe",60);//60秒后过期//获取Stringname =(String) redisUtil.get("name");System.out.println(name);//输出:John Doe//删除redisUtil.delete("name");} }```注意事项：1.序列化方式：根据实际存储的数据类型选择合适的序列化方式。如果存储对象，建议使用Jackson2JsonRedisSerializer（需要添加jackson依赖）并配置ObjectMapper。2.连接池参数：根据实际需求调整连接池参数。3.密码：如果Redis服务器设置了密码，务必在配置中设置。这样，我们就完成了RedisTemplate的连接池配置和使用示例。相关问题：1.如何选择RedisTemplate的序列化方式？2.Redis连接池参数如何调优？3.除了Jedis，还有哪些Redis客户端可以使用？</think>### 在Spring Data Redis中配置RedisTemplate连接池 #### 1. **添加依赖** 在`pom.xml`中添加以下依赖： ```xml <dependencies> <!-- Spring Data Redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- Jedis客户端（连接池实现） --> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> </dependency> </dependencies> ``` #### 2. **配置连接池参数** 在`application.yml`中配置连接池参数： ```yaml spring: redis: host: localhost port: 6379 password: yourpassword # 若无密码可省略 jedis: pool: max-active: 20 # 最大连接数 max-idle: 10 # 最大空闲连接 min-idle: 5 # 最小空闲连接 max-wait: 2000ms # 获取连接的最大等待时间 ``` #### 3. **配置RedisTemplate** 创建Java配置类`RedisConfig.java`： ```java import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.data.redis.connection.RedisConnectionFactory; import org.springframework.data.redis.connection.jedis.JedisConnectionFactory; import org.springframework.data.redis.core.RedisTemplate; import org.springframework.data.redis.serializer.StringRedisSerializer; @Configuration public class RedisConfig { @Bean public JedisConnectionFactory jedisConnectionFactory() { return new JedisConnectionFactory(); // 自动读取application.yml配置 } @Bean public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory connectionFactory) { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(connectionFactory); // 设置Key的序列化方式（防止乱码） template.setKeySerializer(new StringRedisSerializer()); template.setHashKeySerializer(new StringRedisSerializer()); // 建议Value使用JSON序列化（需额外配置Jackson） // template.setValueSerializer(new GenericJackson2JsonRedisSerializer()); return template; } } ``` #### 4. **封装RedisUtil工具类** 建议封装工具类简化操作（引用[^1]）： ```java import org.springframework.data.redis.core.RedisTemplate; import org.springframework.stereotype.Component; import java.util.concurrent.TimeUnit; @Component public class RedisUtil { private final RedisTemplate<String, Object> redisTemplate; public RedisUtil(RedisTemplate<String, Object> redisTemplate) { this.redisTemplate = redisTemplate; } // 存储字符串（带过期时间） public void set(String key, Object value, long timeout) { redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS); } // 获取字符串 public Object get(String key) { return redisTemplate.opsForValue().get(key); } // 操作Hash public void hPut(String key, String field, Object value) { redisTemplate.opsForHash().put(key, field, value); } // 其他操作：List/Set/ZSet等（引用[^3]） // redisTemplate.opsForList(), redisTemplate.opsForSet()... } ``` #### 5. **使用示例** 在Service中注入工具类： ```java import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; @Service public class UserService { @Autowired private RedisUtil redisUtil; public void cacheUserData(String userId, User user) { // 缓存用户数据（30分钟过期） redisUtil.set("user:" + userId, user, 1800); } public User getCachedUser(String userId) { return (User) redisUtil.get("user:" + userId); } } ``` #### 关键配置说明 | **参数** | **作用** | **推荐值** | |------------------|----------------------------------|-----------| | `max-active` | 最大连接数（避免资源耗尽） | 20 | | `max-idle` | 最大空闲连接（提高复用率） | 10 | | `min-idle` | 最小空闲连接（防止突发流量） | 5 | | `max-wait` | 获取连接等待时间（避免阻塞） | 2000ms | > **注意**：序列化方式需根据数据类型选择： > - `StringRedisSerializer`：字符串类型（推荐Key使用） > - `GenericJackson2JsonRedisSerializer`：对象类型（需添加Jackson依赖） > - `JdkSerializationRedisSerializer`：Java原生序列化（有安全风险） --- ### 相关问题 1. **如何优化RedisTemplate在高并发场景下的性能？** - 连接池参数调优（如`max-active`）、Pipeline批量操作、异步API使用等。 2. **RedisTemplate的序列化方式有哪些优缺点？** - 对比`StringRedisSerializer`、`Jackson2JsonRedisSerializer`、`JdkSerializationRedisSerializer`的效率和安全性。 3. **Spring Data Redis如何实现分布式锁？** - 结合`SETNX`命令和Lua脚本实现原子操作（需处理超时和续约问题）。 4. **连接池配置不当会导致哪些问题？** - 连接泄漏（未及时释放）、资源耗尽（`max-active`过小）、长尾延迟（`max-wait`不合理）等。 5. **如何监控Redis连接池状态？** - 通过`JedisPool`的`getNumActive()`等方法或集成Micrometer暴露指标[^3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值