Vert.x 事务处理

最新推荐文章于 2024-09-10 09:34:10 发布
最新推荐文章于 2024-09-10 09:34:10 发布
阅读量1k 收藏 2
点赞数
文章标签： java 数据库 json
原文链接：https://juejin.im/post/5a308e7f6fb9a0451b04876d
版权

Vert.x中处理数据库事务，需要手动关闭自动提交事务，不多说，直接上代码。

Demo.java

package com.test;

import com.test.utils.Runner;
import io.vertx.core.*;
import io.vertx.core.http.HttpServerRequest;
import io.vertx.core.json.Json;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.jdbc.JDBCClient;
import io.vertx.ext.sql.ResultSet;
import io.vertx.ext.sql.SQLConnection;
import io.vertx.ext.sql.UpdateResult;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.RoutingContext;
import io.vertx.ext.web.handler.BodyHandler;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

import java.util.ArrayList;
import java.util.List;


/**
 * Created by sweet on 2017/6/24.
 */
public class Demo extends AbstractVerticle {


  private static final Logger logger = LogManager.getLogger(Demo.class);

  private JDBCClient jdbcClient;

  @Override
  public void start() throws Exception {

    jdbcClient = JDBCClient.createShared(vertx, new JsonObject()
            .put("url", "jdbc:mysql://localhost:3306/vertx?characterEncoding=UTF-8&useSSL=false")
            .put("driver_class", "com.mysql.jdbc.Driver")
            .put("user", "root").put("password", "xxxx")
            .put("max_pool_size", 30));

    Router router = Router.router(vertx);
    router.route().handler(BodyHandler.create());

    router.get("/hello").handler(r -> {
      r.response().end("hello");
    });

    router.get("/db").handler(this::queryDB);
    router.get("/tx").handler(this::tx);
    router.get("/tx2").handler(this::tx2);

    vertx.createHttpServer().requestHandler(router::accept).listen(8081, r -> {
      if (r.succeeded()) {
        logger.info("服务启动成功，端口 8081");
      } else {
        logger.error("服务启动失败，error ：" + r.cause().getMessage());
      }
    });

  }

  // 下面的代码类似
  // try{
  //  // 开启事务
  //  ...
  // // 提交事务
  // } catch (Exception e) {
  // // 回滚事务
  // }
  private void tx(RoutingContext routingContext) {
    jdbcClient.getConnection(conn -> {

      final SQLConnection connection = conn.result();
      String s1 = "INSERT INTO movie (id, name, duration, director) VALUES ('1432414', 'xxx124', 20, '124xxx')";
      String s2 = "INSERT INTO movie (id, name, duration, director) VALUES ('1432415', 'xxx125', 21, '125xxx')";
      String s3 = "INSERT INTO movie (id, name, duration, director) VALUES ('1432416', 'xxx126', 22, '126xxx')";

      Future.<Void>future(f ->
              connection.setAutoCommit(false, f)
      ).compose(f1 ->
              Future.<UpdateResult>future(f ->
                      connection.update(s1, f)
              )
      ).compose(f2 ->
              Future.<UpdateResult>future(f3 ->
                      connection.update(s2, f3)
              )
      ).compose(f4 ->
              Future.<UpdateResult>future(f5 ->
                      connection.update(s3, f5)
              )
      ).setHandler(res -> {
        if (res.failed()) {
          logger.error("事务失败");
          connection.rollback(roll -> {
            if (roll.succeeded()) {
              logger.info("rollback  ok");
              routingContext.response().setStatusCode(500).end("rollback ok");
              connection.close();
            } else {
              logger.error("rollback error, " + roll.cause().getMessage());
              routingContext.response().setStatusCode(500).end("rollback error");
              connection.close();
            }
          });
        } else {
          logger.info("事务成功");
          connection.commit(commit -> {
            if (commit.succeeded()) {
              logger.info("commit  ok");
              routingContext.response().end("ok");
              connection.close();
            } else {
              logger.error("commit error, " + commit.cause().getMessage());
              routingContext.response().end("commit error");
              connection.close();
            }
          });
        }

      });
    });
  }
  
  private void tx2(RoutingContext routingContext) {
    final String s1 = "INSERT INTO movie (id, name, duration, director) VALUES ('1432414', 'xxx124', 20, '124xxx')";
    final String s2 = "INSERT INTO movie (id, name, duration, director) VALUES ('1432415', 'xxx125', 21, '125xxx')";
    final String s3 = "INSERT INTO movie (id, name_, duration, director) VALUES ('1432416', 'xxx126', 22, '126xxx')";

    jdbcClient.getConnection(conn -> {
      if (conn.succeeded()) {
        final SQLConnection connection = conn.result();

        List<Future> futures = new ArrayList<>();

        Future<Void> future = Future.future();        // 手动开启事务
        connection.setAutoCommit(false, future);
        futures.add(future);

        Future<UpdateResult> future1 = Future.future(); // 执行 Update1
        connection.update(s1,future1);
        futures.add(future1);

        Future<UpdateResult> future2 = Future.future(); // 执行 Update2
        connection.update(s2,future2);
        futures.add(future2);

        Future<UpdateResult> future3 = Future.future(); // 执行 Update3
        connection.update(s3,future3);
        futures.add(future3);

        CompositeFuture.all(futures).setHandler(re -> {
          if (re.succeeded()){ // 如果都执行成功，提交事务
            connection.commit(comm -> {
              if (comm.succeeded()){
                routingContext.response().end("commit ok");
              }else {
                routingContext.response().setStatusCode(500).end();
                logger.error(comm.cause().getMessage());
              }
              connection.close();
            });
          }else { // 如果其中一条执行失败，回滚事务
            connection.rollback(roll -> {
              if (roll.succeeded()){
                routingContext.response().setStatusCode(500).end("rollback ok");
                logger.info("rollback ok");
              }else {
                routingContext.response().setStatusCode(500).end();
                logger.error(roll.cause().getMessage());
              }
              connection.close();
            });
          }
        });
      }else {
        routingContext.response().setStatusCode(500).end();
        logger.error(conn.cause().getMessage());
      }
    });

  }

  private void queryDB(RoutingContext routingContext) {

    jdbcClient.getConnection(conn -> {
      if (conn.succeeded()) {
        final SQLConnection connection = conn.result();

        Future<ResultSet> future = Future.future();
        future.setHandler(res -> {
          if (res.succeeded()) {
            List<JsonObject> list = res.result().getRows();
            if (list != null && list.size() > 0) {
              routingContext.response().end(Json.encodePrettily(list));
              connection.close();
            }
          } else {
            logger.error(res.cause().getMessage());
            routingContext.response().setStatusCode(500).end();
            connection.close();
          }
        });

        final String sql = "SELECT * FROM movie";
        connection.queryWithParams(sql, null, future);

      } else {
        logger.error(conn.cause().getMessage());
        routingContext.response().setStatusCode(500).end();
      }
    });


  }

  public static void main(String[] args) {
    Runner.runExample(Demo.class);
  }
}

复制代码

里面的main方法可以直接运行

Runner.java 是官方提供的 方便在IDE里运行。

package com.test.utils;

/**
 * Created by sweet on 2017/5/8.
 */


import io.vertx.core.DeploymentOptions;
import io.vertx.core.Vertx;
import io.vertx.core.VertxOptions;

import java.io.File;
import java.io.IOException;
import java.util.function.Consumer;

/*
 * @author <a href="http://tfox.org">Tim Fox</a>
 */
public class Runner {

    private static final String WEB_EXAMPLES_DIR = "web-examples";
    private static final String WEB_EXAMPLES_JAVA_DIR = WEB_EXAMPLES_DIR + "/src/main/java/";
    private static final String WEB_EXAMPLES_JS_DIR = WEB_EXAMPLES_DIR + "/src/main/js/";
    private static final String WEB_EXAMPLES_GROOVY_DIR = WEB_EXAMPLES_DIR + "/src/main/groovy/";
    private static final String WEB_EXAMPLES_RUBY_DIR = WEB_EXAMPLES_DIR + "/src/main/ruby/";

    public static void runClusteredExample(Class clazz) {
        runExample(WEB_EXAMPLES_JAVA_DIR, clazz, new VertxOptions().setClustered(true), null);
    }

    public static void runExample(Class clazz) {
        runExample(WEB_EXAMPLES_JAVA_DIR, clazz, new VertxOptions().setClustered(false), null);
    }

    public static void runExample(Class clazz, DeploymentOptions options) {
        runExample(WEB_EXAMPLES_JAVA_DIR, clazz, new VertxOptions().setClustered(false), options);
    }

    // JavaScript examples

    public static void runJSExample(String scriptName) {
        runScriptExample(WEB_EXAMPLES_JS_DIR, scriptName, new VertxOptions().setClustered(false));
    }

    public static void runJSExampleClustered(String scriptName) {
        runScriptExample(WEB_EXAMPLES_JS_DIR, scriptName, new VertxOptions().setClustered(true));
    }

    static class JSAuthRunner {
        public static void main(String[] args) {
            Runner.runJSExample("io/vertx/example/web/auth/server.js");
        }
    }

    static class JSAuthJDBC {
        public static void main(String[] args) {
            Runner.runJSExample("io/vertx/example/web/authjdbc/server.js");
        }
    }

    static class JSHelloWorldRunner {
        public static void main(String[] args) {
            Runner.runJSExample("io/vertx/example/web/helloworld/server.js");
        }
    }

    static class JSRealtimeRunner {
        public static void main(String[] args) { Runner.runJSExample("io/vertx/example/web/realtime/server.js"); }
    }

    static class JSChatRunner {
        public static void main(String[] args) {
            Runner.runJSExample("io/vertx/example/web/chat/server.js");
        }
    }

    static class JSSessionsRunner {
        public static void main(String[] args) {
            Runner.runJSExample("io/vertx/example/web/sessions/server.js");
        }
    }

    static class JSTemplatingRunner {
        public static void main(String[] args) {
            Runner.runJSExample("io/vertx/example/web/templating/mvel/server.js");
        }
    }

    // Groovy examples

    public static void runGroovyExample(String scriptName) {
        runScriptExample(WEB_EXAMPLES_GROOVY_DIR, scriptName, new VertxOptions().setClustered(false));
    }

    public static void runGroovyExampleClustered(String scriptName) {
        runScriptExample(WEB_EXAMPLES_GROOVY_DIR, scriptName, new VertxOptions().setClustered(true));
    }

    static class GroovyAuthRunner {
        public static void main(String[] args) {
            Runner.runGroovyExample("io/vertx/example/web/auth/server.groovy");
        }
    }

    static class GroovyAuthJDBC {
        public static void main(String[] args) {
            Runner.runGroovyExample("io/vertx/example/web/authjdbc/server.groovy");
        }
    }

    static class GroovyHelloWorldRunner {
        public static void main(String[] args) {
            Runner.runGroovyExample("io/vertx/example/web/helloworld/server.groovy");
        }
    }

    static class GroovyChatRunner {
        public static void main(String[] args) { Runner.runGroovyExample("io/vertx/example/web/chat/server.groovy"); }
    }

    static class GroovyRealtimeRunner {
        public static void main(String[] args) {
            Runner.runGroovyExample("io/vertx/example/web/realtime/server.groovy");
        }
    }

    static class GroovySessionsRunner {
        public static void main(String[] args) {
            Runner.runGroovyExample("io/vertx/example/web/sessions/server.groovy");
        }
    }

    static class GroovyTemplatingRunner {
        public static void main(String[] args) {
            Runner.runGroovyExample("io/vertx/example/web/templating/mvel/server.groovy");
        }
    }

    static class GroovyRestRunner {
        public static void main(String[] args) {
            Runner.runGroovyExample("io/vertx/example/web/rest/simple_rest.groovy");
        }
    }

    // Ruby examples

    public static void runRubyExample(String scriptName) {
        runScriptExample(WEB_EXAMPLES_RUBY_DIR, scriptName, new VertxOptions().setClustered(false));
    }

    public static void runRubyExampleClustered(String scriptName) {
        runScriptExample(WEB_EXAMPLES_RUBY_DIR, scriptName, new VertxOptions().setClustered(true));
    }

    static class RubyAuthRunner {
        public static void main(String[] args) {
            Runner.runRubyExample("io/vertx/example/web/auth/server.rb");
        }
    }

    static class RubyAuthJDBC {
        public static void main(String[] args) {
            Runner.runRubyExample("io/vertx/example/web/authjdbc/server.rb");
        }
    }
    static class RubyHelloWorldRunner {
        public static void main(String[] args) {
            Runner.runRubyExample("io/vertx/example/web/helloworld/server.rb");
        }
    }

    static class RubyChatRunner {
        public static void main(String[] args) { Runner.runRubyExample("io/vertx/example/web/chat/server.rb");
        }
    }

    static class RubyRealtimeRunner {
        public static void main(String[] args) {
            Runner.runRubyExample("io/vertx/example/web/realtime/server.rb");
        }
    }

    static class RubySessionsRunner {
        public static void main(String[] args) {
            Runner.runRubyExample("io/vertx/example/web/sessions/server.rb");
        }
    }

    static class RubyTemplatingRunner {
        public static void main(String[] args) {
            Runner.runRubyExample("io/vertx/example/web/templating/mvel/server.rb");
        }
    }

    public static void runExample(String exampleDir, Class clazz, VertxOptions options, DeploymentOptions
            deploymentOptions) {
        runExample(exampleDir + clazz.getPackage().getName().replace(".", "/"), clazz.getName(), options, deploymentOptions);
    }


    public static void runScriptExample(String prefix, String scriptName, VertxOptions options) {
        File file = new File(scriptName);
        String dirPart = file.getParent();
        String scriptDir = prefix + dirPart;
        runExample(scriptDir, scriptDir + "/" + file.getName(), options, null);
    }

    public static void runExample(String exampleDir, String verticleID, VertxOptions options, DeploymentOptions deploymentOptions) {
        if (options == null) {
            // Default parameter
            options = new VertxOptions();
        }
        // Smart cwd detection

        // Based on the current directory (.) and the desired directory (exampleDir), we try to compute the vertx.cwd
        // directory:
        try {
            // We need to use the canonical file. Without the file name is .
            File current = new File(".").getCanonicalFile();
            if (exampleDir.startsWith(current.getName()) && !exampleDir.equals(current.getName())) {
                exampleDir = exampleDir.substring(current.getName().length() + 1);
            }
        } catch (IOException e) {
            // Ignore it.
        }

        System.setProperty("vertx.cwd", exampleDir);
        Consumer<Vertx> runner = vertx -> {
            try {
                if (deploymentOptions != null) {
                    vertx.deployVerticle(verticleID, deploymentOptions);
                } else {
                    vertx.deployVerticle(verticleID);
                }
            } catch (Throwable t) {
                t.printStackTrace();
            }
        };
        if (options.isClustered()) {
            Vertx.clusteredVertx(options, res -> {
                if (res.succeeded()) {
                    Vertx vertx = res.result();
                    runner.accept(vertx);
                } else {
                    res.cause().printStackTrace();
                }
            });
        } else {
            Vertx vertx = Vertx.vertx(options);
            runner.accept(vertx);
        }
    }
}

复制代码
weixin_33696822
关注
vert.x+连接mysql_Vert-x-通过异步的方式使用JDBC连接SQL
weixin_39734184的博客
01-30 211
交流群：231419585转载请注明出处，谢谢在这篇文章中，我们将会看到怎样在vert.x应用中使用HSQL，当然也可以使用任意JDBC，以及使用vertx-jdbc-client提供的异步的API，这篇文章的代码在github上。异步？vert.x一个很重要的特点就是它的异步性。使用异步的API，不需要等结果返回，当有结果返回时，vert.x会主动通知。为了说明这个，我们来看一个简单的例子。我们...
java mysql 异步查询数据库_Vert.x 异步访问数据库 MySQL
weixin_42512613的博客
01-19 1261
Vert.x提供异步访问数据库的API，数据库操作是一个耗时操作，使用传统的同步模型，容易阻塞线程，导致整体性能下降，因此我们对于数据库操作，需要使用Vert.x提供的异步API。Vert.x提供的API层级非常低，可以说是仅仅在原生JDBC基础上封装了一层异步接口。所有的对数据库操作都需要通过编写SQL来完成，参数的封装和结果的获取都需要手动的来实现，对于习惯使用ORM框架的开发者可能会非常的不...
simple-vertx-proxy-example:展示如何使用 Vert.x 3.0.0-SNAPSHOT 实现 HTTP 代理服务器的简单示例
06-21
Vert.x 代理示例 先决条件 Maven >= 3.0 Java >= 1.8 用于 core/apex/codetrans 的 Vert.x 'master' 分支的当前快照 跑步 mvn clean package exec:java 测试 运行后，此应用程序侦听端口 8080 并将请求代理到 curl http://localhost:8080/r/java
Vert.x JDBC Client 开源项目实战指南
最新发布
gitblog_00399的博客
09-10 310
Vert.x JDBC Client 开源项目实战指南 vertx-jdbc-clientJDBC support for Vert.x项目地址:https://gitcode.com/gh_mirrors/ve/vertx-jdbc-client 1. 项目目录结构及介绍 Vert.x JDBC Client 的具体目录结构和文件细节在 GitHub 仓库 vert-x3/vertx-jdbc...
Vertx的Redis Client进行事务处理
卓小洛的专栏
09-23 2977
Vertx的Redis Client中主要有两个类 RedisClientRedisTransaction 其中RedisTransaction是用来处理Redis缓存事务的。 场景：Redis缓存中有个数据 i=100; 有两个操作，都要对i进行+100的处理 如果不做事务处理： 操作1读Redis缓存i，得到100操作2读Redis缓存i，也得到10
vertx事务提交(Vertx 3.9.8版本)
遙夜人間
06-24 409
使用事务 事务与连接 您可以使用 SQL BEGIN/COMMIT/ROLLBACK 执行事务，如果这样做，您必须使用 SqlConnection 并自己管理。 或者你可以使用 SqlConnection 的事务API： pool.getConnection(res -> { if (res.succeeded()) { // 事务必须使用一个连接 SqlConnection conn = res.result(); // 开始事务 Transaction t
Vert.x MySQL Client中文版
白石的专栏
05-15 750
Reactive MySQL Client 是 MySQL 的一个客户端，它有一个简单的 API，专注于可伸缩性和低开销。
vertx-infinispan:Vert.x Infinispan 集群管理器
07-12
【标题】：Vert.x Infinispan 集群管理器 【正文】： Vert.x Infinispan 集群管理器是一个强大的工具，它将Infinispan缓存库与Vert.x框架相结合，提供了分布式数据管理和集群功能。Infinispan是一个开源的、高性能...
使用Vert.x异步JDBC连接SQL：vertx-jdbc-client实践
然后，可以通过 `JDBCClient` 的方法创建连接，执行SQL查询、更新、事务处理等操作，所有这些都将以非阻塞的方式进行。 Vert.x 提供的异步JDBC客户端允许开发者以高效的方式处理数据库交互，充分利用事件循环模型，...
思科Java面试： Vert.x与Spring Boot在后台架构与ORM应用
1. ** Verticles（微服务单元）**：这是Vert.x的核心组成部分，每个Verticle都是一个独立的执行单元，可以处理特定的任务或服务。面试者可能被问及如何组织和管理这些微服务，以及它们如何通过事件驱动的方式协同...
Vert-x-通过异步的方式使用JDBC连接SQL
09-02
在这篇文章中，我们将会看到怎样在vert.x应用中使用HSQL，当然也可以使用任意JDBC，以及使用vertx-jdbc-client提供的异步的API，这篇文章的代码在github
vertx 学习 jdbc 数据库连接
zhaluo_dehezi的博客
07-17 1237
依赖: <?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="htt...
Vert.x(vertx) 连接MySQL、Oracle数据库
happyfly的博客
12-13 1万+
Vert.x提供异步访问数据库的API，可能这里有朋友会有疑惑，直接使用我们之前的熟悉的Mybatis或者Hibernate不行吗，可行，但数据库操作是一个耗时操作，使用传统的同步模型，容易阻塞线程，导致整体性能下降，因此我们对于数据库操作，需要使用Vert.x提供的异步API。 Vert.x提供的API层级非常低，可以说是仅仅在原生JDBC基础上封装了一层异步接口。所有的对数据库操作都需要通过...
JDBC一数据库事务
Fifth_floor的博客
03-21 207
引入数据库事务 为什么要引入数据库事务 举一个简单的例子 ↓ 假如A向B转账300块钱 如果发生了以下情况 String sql1 = "update test set balance = balance - 300 where name =?"; update(sql1,"A"); //中途出现异常 System.out...
python:matplotlib.pyplot绘制箱线图并 检测异常值(基础一)
qq_44039983的博客
03-17 1万+
在数据处理中，箱线图常用来检测异常值。 数据文件data01.xls 1.绘制箱线图使用boxplot()函数 import pandas as pd import matplotlib.pyplot as plt # 读取excel文件 file_01 = pd.read_excel("data01.xls") fig = plt.figure(figsize=(16, 8)) d1 = file_01['变量1'] d2 = file_01['变量2'] d3 = file_01['变量
pandas基础操作大全之数据可视化
热门推荐
yifengchaoran的专栏
12-05 13万+
在pandas 基础操作大全之数据读取&清洗&分析中介绍了pandas常见的数据处理操作，现在继续对pandas常用的数据合并及数据可视化操作做下介绍，便于大家快速了解，也方便后续需要时快速查询。 一、数据合并 1.1 concat 1.1.1 概述 #concat是 1.1.2 指定合并的轴方向--axis 1.2.3 指定合并轴另外一个轴标签是否合并--join 1.2.4 指定合并轴原标签是否需要变化--ignore_index 1.2.5 指定 1.2.6 指定合
Vertx之MQTT客户端服务端发送
Lance
01-25 6567
介绍 Vert.x MQTT消息发送, 客户端和服务端 1. maven项目依赖 <dependencies> <dependency> <groupId>io.vertx</groupId> <artifactId>vertx-web</artifactId> </dependency> <dependency> <groupId>io.vertx</groupId&
深入理解Vert.x配置：VertxOptions详解
事件循环线程负责处理非阻塞I/O操作，是Vert.x的核心。默认值基于系统可用处理器数量的两倍，确保高效地处理并发事件。 其次，`setWorkerPoolSize`用于设定工作线程池的最大数量。工作线程主要用于处理阻塞任务，如...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值