SpringBoot中使用redis事务-低调大师

SpringBoot中使用redis事务

2021-06-22 595

首先从使用springboot+redis碰到的一个问题说起。在前几篇文章中介绍了用SpringBoot+redis构建了一个个人博客。在刚开始远行的时候发现发了几个请求操作了几次redis之后，后面的就被阻塞了，请求一直在等待返回，我们重现一下问题。

[注意] 该问题只会出现在springboot 2.0之前的版本;2.0之后springboot连接Redis改成了lettuce，并重新实现，问题已经不存在

打开Template的事务支持

POM配置：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.github.springboot</groupId>
    <artifactId>redis-tx-demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>jar</packaging>

    <name>SpringBoot redis TX demo</name>
    <description>Demo project for Spring Boot with Redis transaction</description>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-rest</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>


</project>

Redis configuration (EnbaleTransactionSupport设为true):

@Configuration
public class RedisConfiguration {

    @Bean
    public StringRedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        template.setEnableTransactionSupport(true); //打开事务支持
        return template;
    }
}

Controller就是简单的set一个key到redis:

@RestController
public class DemoController {
    
    private StringRedisTemplate template;
    
    public DemoController(StringRedisTemplate template) {
        this.template = template;
    }
    
    @GetMapping("/put")
    public String redisSet() {
        int i = (int)(Math.random() * 100);
        template.opsForValue().set("key"+i, "value"+i, 300, TimeUnit.SECONDS);
        return "success "+"key"+i;
    }

}

启动后，我们使用RestClient发送请求http://localhost:8080/put，发送8次之后就会发现没有返回了。这个时候我们查看redis的链接数，发现已经超过8个，springboot对于jedis连接池默认的最大活跃连接数是8，所以看出来是连接池被耗光了。

127.0.0.1:6379> info clients
# Clients
connected_clients:9
client_longest_output_list:0
client_biggest_input_buf:0
blocked_clients:0
127.0.0.1:6379>

还有查看程序的日志可以发现，RedisConnectionUtils只有Opening RedisConnection而没有close。

2018-08-11 11:00:48.889 [DEBUG][http-nio-8080-exec-8]:o.s.data.redis.core.RedisConnectionUtils [doGetConnection:126] Opening RedisConnection
2018-08-11 11:00:50.169 [DEBUG][http-nio-8080-exec-8]:o.s.w.s.m.m.a.RequestResponseBodyMethodProcessor [writeWithMessageConverters:249] Written [success key39] as "text/plain" using [org.springframework.http.converter.StringHttpMessageConverter@766a49c7]
2018-08-11 11:00:50.170 [DEBUG][http-nio-8080-exec-8]:org.springframework.web.servlet.DispatcherServlet [processDispatchResult:1044] Null ModelAndView returned to DispatcherServlet with name 'dispatcherServlet': assuming HandlerAdapter completed request handling
2018-08-11 11:00:50.170 [DEBUG][http-nio-8080-exec-8]:org.springframework.web.servlet.DispatcherServlet [proce***equest:1000] Successfully completed request
2018-08-11 11:00:50.170 [DEBUG][http-nio-8080-exec-8]:o.s.boot.web.filter.OrderedRequestContextFilter [doFilterInternal:104] Cleared thread-bound request context: org.apache.catalina.connector.RequestFacade@c03b2d8
2018-08-11 11:00:53.854 [DEBUG][http-nio-8080-exec-9]:o.s.boot.web.filter.OrderedRequestContextFilter [initContextHolders:114] Bound request context to thread: org.apache.catalina.connector.RequestFacade@c03b2d8
2018-08-11 11:00:53.856 [DEBUG][http-nio-8080-exec-9]:org.springframework.web.servlet.DispatcherServlet [doService:865] DispatcherServlet with name 'dispatcherServlet' processing GET request for [/put]
2018-08-11 11:00:53.857 [DEBUG][http-nio-8080-exec-9]:o.s.w.s.m.m.a.RequestMappingHandlerMapping [getHandlerInternal:310] Looking up handler method for path /put
2018-08-11 11:00:53.857 [DEBUG][http-nio-8080-exec-9]:o.s.w.s.m.m.a.RequestMappingHandlerMapping [getHandlerInternal:317] Returning handler method [public java.lang.String com.github.springboot.demo.DemoController.redisSet()]
2018-08-11 11:00:53.858 [DEBUG][http-nio-8080-exec-9]:o.s.b.factory.support.DefaultListableBeanFactory [doGetBean:251] Returning cached instance of singleton bean 'demoController'
2018-08-11 11:00:53.858 [DEBUG][http-nio-8080-exec-9]:org.springframework.web.servlet.DispatcherServlet [doDispatch:951] Last-Modified value for [/put] is: -1
2018-08-11 11:00:53.861 [DEBUG][http-nio-8080-exec-9]:o.s.data.redis.core.RedisConnectionUtils [doGetConnection:126] Opening RedisConnection

关闭template的事务支持接下来我们修改一下RedisConfiguration的配置，不启用事务管理，

@Bean
public StringRedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
    StringRedisTemplate template = new StringRedisTemplate();
    template.setConnectionFactory(redisConnectionFactory);
//  template.setEnableTransactionSupport(true);   //禁用事务支持
    return template;
}

重新测试一下，发现是正常的，redis的client链接数一直保持在2。程序日志里的也可以看到Redis Connection关闭的日志。

2018-08-11 15:55:19.975 [DEBUG][http-nio-8080-exec-1]:o.s.data.redis.core.RedisConnectionUtils [doGetConnection:126] Opening RedisConnection
2018-08-11 15:55:20.029 [DEBUG][http-nio-8080-exec-1]:o.s.data.redis.core.RedisConnectionUtils [releaseConnection:210] Closing Redis Connection
2018-08-11 15:55:20.056 [DEBUG][http-nio-8080-exec-1]:o.s.w.s.m.m.a.RequestResponseBodyMethodProcessor [writeWithMessageConverters:249] Written [success key72] as "text/plain" using [org.springframework.http.converter.StringHttpMessageConverter@51ab1ee3]

也就是说，如果我们把事务的支持打开，spring在每次操作之后是不会主动关闭连接的。我们去RedisTemplate的源码中找下原因。

public ValueOperations<K, V> opsForValue() {
        if (valueOps == null) {
            valueOps = new DefaultValueOperations<K, V>(this);
        }
        return valueOps;
}

可以发现template.opsForValue().set()操作最终是调用的DefaultValueOperations中的set()方法，继续跟进去最终调用的RedisTemplate中的execute(RedisCallback<T> action, boolean exposeConnection, boolean pipeline)方法。

public <T> T execute(RedisCallback<T> action, boolean exposeConnection, boolean pipeline) {
        Assert.isTrue(initialized, "template not initialized; call afterPropertiesSet() before using it");
        Assert.notNull(action, "Callback object must not be null");

        RedisConnectionFactory factory = getConnectionFactory();
        RedisConnection conn = null;
        try {

            if (enableTransactionSupport) {
                // only bind resources in case of potential transaction synchronization
                conn = RedisConnectionUtils.bindConnection(factory, enableTransactionSupport);
            } else {
                conn = RedisConnectionUtils.getConnection(factory);
            }

            boolean existingConnection = TransactionSynchronizationManager.hasResource(factory);

            RedisConnection connToUse = preProcessConnection(conn, existingConnection);

            boolean pipelineStatus = connToUse.isPipelined();
            if (pipeline && !pipelineStatus) {
                connToUse.openPipeline();
            }

            RedisConnection connToExpose = (exposeConnection ? connToUse : createRedisConnectionProxy(connToUse));
            T result = action.doInRedis(connToExpose);

            // close pipeline
            if (pipeline && !pipelineStatus) {
                connToUse.closePipeline();
            }

            // TODO: any other connection processing?
            return postProce***esult(result, connToUse, existingConnection);
        } finally {
            RedisConnectionUtils.releaseConnection(conn, factory);
        }
    }

可以看到获取连接的操作也针对打开事务支持的template有特殊的处理逻辑。这里我们先跳过，先看看最终肯定会走到的RedisConnectionUtils.releaseConnection(conn, factory)这一步。

/**
     * Closes the given connection, created via the given factory if not managed externally (i.e. not bound to the
     * thread).
     * 
     * @param conn the Redis connection to close
     * @param factory the Redis factory that the connection was created with
     */
    public static void releaseConnection(RedisConnection conn, RedisConnectionFactory factory) {

        if (conn == null) {
            return;
        }

        RedisConnectionHolder connHolder = (RedisConnectionHolder) TransactionSynchronizationManager.getResource(factory);

        if (connHolder != null && connHolder.isTransactionSyncronisationActive()) {
            if (log.isDebugEnabled()) {
                log.debug("Redis Connection will be closed when transaction finished.");
            }
            return;
        }

        // release transactional/read-only and non-transactional/non-bound connections.
        // transactional connections for read-only transactions get no synchronizer registered
        if (isConnectionTransactional(conn, factory)
                && TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
            unbindConnection(factory);
        } else if (!isConnectionTransactional(conn, factory)) {
            if (log.isDebugEnabled()) {
                log.debug("Closing Redis Connection");
            }
            conn.close();
        }
    }

可以看到针对打开事务支持的template,只是解绑了连接，根本没有做close的操作。关于什么是解绑，其实这个方法的注释中已经说的比较清楚了，对于开启了事务的Template，由于已经绑定了线程中连接，所以这里是不会关闭的，只是做了解绑的操作。

到这里原因就很清楚了，就是只要template开启了事务支持，spring就认为只要使用这个template就会包含在事务当中，因为一个事务中的操作必须在同一个连接中完成，所以在每次get/set之后，template是不会关闭链接的，因为它不知道事务有没有结束。

使用@Transanctional注解支持Redis事务

既然RedisTemlate在setEnableTransactionSupport会造成连接不关闭，那怎么样才能正常关闭呢？我们将事务支持开关和@Transanctional结合起来用看看会怎么样。

spring中要使用@Transanctional首先要配transactionManager，但是spring没有专门针对Redis的事务管理器实现，而是所有调用RedisTemplate的方法最终都会调用到RedisConnctionUtils这个类的方法上面，在这个类里面会判断是不是进入到事务里面，也就是说Redis的事务管理的功能是由RedisConnctionUtils内部实现的。

根据官方文档，我只想用Redis事务，也必须把JDBC捎上。当然反过来讲，不依赖数据的项目确实不多，貌似这么实现影响也不大。下面我们先根据官方文档配置一下看看效果。

首先修改POM配置，添加两个依赖。如果项目里本来已经使用了数据库，那这一步就不需要了。

<dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
        <groupId>com.h2database</groupId>
        <artifactId>h2</artifactId>
        <scope>runtime</scope>
</dependency>

然后修改RedisConfiguration

@Bean
    public StringRedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        StringRedisTemplate template = new StringRedisTemplate();
        template.setConnectionFactory(redisConnectionFactory);
        template.setEnableTransactionSupport(true);//打开事务支持
        return template;
    }

    //配置事务管理器
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) throws SQLException {
        return new DataSourceTransactionManager(dataSource);
    }

我们新建一个RedisService，将原来的数据操作移到service里面。同时将Service方法加上@Transactional注解。

@Service
public class RedisService {
    
    private StringRedisTemplate template;
    
    public RedisService(StringRedisTemplate template) {
        this.template = template;
    }

    @Transactional
    public String put() {
        int i = (int)(Math.random() * 100);
        template.opsForValue().set("key"+i, "value"+i, 300, TimeUnit.SECONDS);
        return "success "+"key"+i;
    }
}

//-----------------------------------------------------------
//controller里面加一个新的方法，调用Service
@GetMapping("/puttx")
public String redisTxSet() {
    return redisService.put();
}

完成这些工作之后，再往http://localhost:8080/puttx发送请求，无论点多少次，Redis的连接数始终维持在1个不变。在看程序的输出日志里面我们也发现了，事务结束后连接被正常释放。因为使用了JDBC的事务管理器，所以还顺便做了一次数据库事务的开启和提交。还有一点值得注意的是，跟数据库一样，使用注解来做事务管理，spring也会主动管理redis事务的提交和回滚，也就是在之前发送一条MULTI命令，成功后发送EXEC，失败后发送DISCARD。

2018-08-11 20:57:04.990 [DEBUG][http-nio-8080-exec-1]:o.s.data.redis.core.RedisConnectionUtils [doGetConnection:126] Opening RedisConnection
2018-08-11 20:57:04.990 [DEBUG][http-nio-8080-exec-1]:o.springframework.aop.framework.JdkDynamicAopProxy [getProxy:118] Creating JDK dynamic proxy: target source is SingletonTargetSource for target object [org.springframework.data.redis.connection.jedis.JedisConnection@20f2be3c]
2018-08-11 20:57:04.990 [DEBUG][http-nio-8080-exec-1]:o.s.data.redis.core.RedisConnectionUtils [intercept:337] Invoke 'multi' on bound conneciton
2018-08-11 20:57:04.991 [DEBUG][http-nio-8080-exec-1]:o.s.data.redis.core.RedisConnectionUtils [intercept:337] Invoke 'isPipelined' on bound conneciton
2018-08-11 20:57:04.991 [DEBUG][http-nio-8080-exec-1]:o.s.data.redis.core.RedisConnectionUtils [intercept:337] Invoke 'setEx' on bound conneciton
2018-08-11 20:57:04.991 [DEBUG][http-nio-8080-exec-1]:o.s.data.redis.core.RedisConnectionUtils [releaseConnection:198] Redis Connection will be closed when transaction finished.
2018-08-11 20:57:04.991 [DEBUG][http-nio-8080-exec-1]:o.s.jdbc.datasource.DataSourceTransactionManager [processCommit:759] Initiating transaction commit
2018-08-11 20:57:04.991 [DEBUG][http-nio-8080-exec-1]:o.s.jdbc.datasource.DataSourceTransactionManager [doCommit:310] Committing JDBC transaction on Connection [ProxyConnection[PooledConnection[conn9: url=jdbc:h2:mem:testdb user=SA]]]
2018-08-11 20:57:04.992 [DEBUG][http-nio-8080-exec-1]:o.s.data.redis.core.RedisConnectionUtils [intercept:337] Invoke 'exec' on bound conneciton
2018-08-11 20:57:04.992 [DEBUG][http-nio-8080-exec-1]:o.s.data.redis.core.RedisConnectionUtils [afterCompletion:306] Closing bound connection after transaction completed with 0
2018-08-11 20:57:04.992 [DEBUG][http-nio-8080-exec-1]:o.s.data.redis.core.RedisConnectionUtils [intercept:337] Invoke 'close' on bound conneciton
2018-08-11 20:57:04.993 [DEBUG][http-nio-8080-exec-1]:o.s.jdbc.datasource.DataSourceTransactionManager [doCleanupAfterCompletion:368] Releasing JDBC Connection [ProxyConnection[PooledConnection[conn9: url=jdbc:h2:mem:testdb user=SA]]] after transaction
2018-08-11 20:57:04.993 [DEBUG][http-nio-8080-exec-1]:o.springframework.jdbc.datasource.DataSourceUtils [doReleaseConnection:327] Returning JDBC Connection to DataSource

总结

在spring中要使用Redis注解式事务，首先要设置RedisTemplate的enableTransactionSupport属性为true，然后配置一个jdbc的事务管理器。这里有一点非常重要，一旦这样配置，所有使用这个template的redis操作都必须走注解式事务，要不然会导致连接一直占用，不关闭。

建议

升级到springboot 2.0以上版本，如果因为项目原因无法升级看下面的建议
如果使用Redis事务的场景不多，完全可以自己管理，不需要使用spring的注解式事务。如下面这样使用：

List<Object> txResults = redisTemplate.execute(new SessionCallback<List<Object>>() {
  public List<Object> execute(RedisOperations operations) throws DataAccessException {
    operations.multi();
    operations.opsForSet().add("key", "value1");
    // This will contain the results of all ops in the transaction
    return operations.exec();
  }
});

如果一定要使用spring提供的注解式事务，建议初始化两个RedisTemplate Bean，分别设置enableTransactionSupport属性为true和false。针对需要事务和不需要事务的操作使用不同的template。
从个人角度，我不建议使用redis事务，因为redis对于事务的支持并不是关系型数据库那样满足ACID。Redis事务只能保证ACID中的隔离性和一致性，无法保证原子性和持久性。而我们使用事务最重要的一个理由就是原子性，这一点无法保证，事务的意义就去掉一大半了。所以事务的场景可以尝试通过业务代码来实现。

想要更多干货、技术猛料的孩子，快点拿起手机扫码关注我，我在这里等你哦~

林老师带你学编程：https://wolzq.com

微信关注我们

原文链接：https://blog.51cto.com/u_8865295/2938703

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

【Computer Organization笔记11】多周期CPU

2 --> 本次笔记内容：P21 计算机组成原理（21）P22 计算机组成原理（22）本节课对应幻灯片：组成原理25 multicycle.pptx 文章目录本讲提要单周期CPU特点单周期CPU的性能单周期CPU其他问题多周期CPU 多周期CPU控制器控制器的组成两种不同类型的控制器硬连线控制器组成与实现微程序控制器组成与实现多周期的CPU控制器设计多周期CPU的Datapath MIPS计算机硬件组成 MIPS指令执行步骤 MIPS的 ADD 指令的执行过程 MIPS的 LW 指令的执行过程 MIPS的 BEQ 指令的执行过程 MIPS的 J 指令的执行过程状态转移图和指令各执行步骤的操作功能 Control Unit FSM Implement 小结承接上节课内容，首先是复习单周期CPU；接着由单周期CPU缺陷，引出多周期CPU。本讲提要单周期CPU特点单周期CPU主要不足多周期CPU设计多周期CPU控制器基本组成多周期CPU设计过程单周期CPU特点为什么单周期CPU不再适用了？各组成部件的利用率不高：各部件大部分时间在保...

2021-06-22

611

2 --> 这几天一直在研究IDEA上面怎么搭建一个web-mvc的SpringBoot项目，看网上的教程一步步的搭建，可是还是出现一堆的问题。想学习分布式、微服务、JVM、多线程、架构、java、python的童鞋，千万不要扫码，否则后果自负~ 为了让大家以后少走一些弯路，我在这里分享一下我这几天研究的成果，也希望对大家能有所帮助。这里先介绍一下各种环境的配置信息：idea2016.2.1 jdk1.8.0_31 因为SpringBoot中是内置tomcat的，所以也就不需要额外的tomcat配置了，现在开始讲如何在idea上面搭建SpringBoot web-mvc项目了步骤一：在IDEA中新建一个常规的maven项目，具体步骤请看看下面的图示：通过图上面的几个步骤，一个基本的maven项目就搭建完成了，接下来就是开始搭建SpringBoot中各种配置文件信息了。步骤二： 1.先复制以下代码到pox.xml中去 <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.ap...

2021-06-22

665

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Spring

Spring框架（Spring Framework）是由Rod Johnson于2002年提出的开源Java企业级应用框架，旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念，提供核心容器、应用上下文、数据访问集成等模块，支持整合Hibernate、Struts等第三方框架，其适用范围不仅限于服务器端开发，绝大多数Java应用均可从中受益。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能，例如代码缩略图，Python的插件，代码段等。还可自定义键绑定，菜单和工具栏。Sublime Text 的主要功能包括：拼写检查，书签，完整的 Python API ， Goto 功能，即时项目切换，多选择，多窗口等等。Sublime Text 是一个跨平台的编辑器，同时支持Windows、Linux、Mac OS X等操作系统。