设为首页收藏本站
开启辅助访问

在路上

 找回密码
 立即注册
在路上 › 站点首页 ›学习 › 查看内容

Vert-x-通过异步的方式使用JDBC连接SQL

2017-2-7 13:39| 发布者: zhangjf| 查看: 598| 评论: 0

摘要: 欢迎关注 http://quanke.name/ 交流群： 231419585 转载请注明出处，谢谢 在这篇文章中，我们将会看到怎样在vert.x应用中使用 HSQL ，当然也可以使用任意JDBC，以及使用vertx-jdbc-client提供的异步的API，这篇文 ...
欢迎关注 http://quanke.name/ 交流群： 231419585 转载请注明出处，谢谢

在这篇文章中，我们将会看到怎样在vert.x应用中使用 HSQL ，当然也可以使用任意JDBC，以及使用vertx-jdbc-client提供的异步的API，这篇文章的代码在 github 上。

异步？

vert.x一个很重要的特点就是它的异步性。使用异步的API，不需要等结果返回，当有结果返回时，vert.x会主动通知。为了说明这个，我们来看一个简单的例子。

我们假设有个 add 方法。一般来说，会像 int r = add(1, 1) 这样来使用它。这是一个同步的API，所以你必须等到返回结果。异步的API会是这样： add(1, 1, r -> { /*do something with the result*/}) 。在这个版本中，你传入了一个Handler，当结果计算出来时才被调用。这个方法不返回任何东西，实现如下：

  1. public void add(int a, int b, Handler<Integer> resultHandler) {
  2. int r = a + b;
  3. resultHandler.handle(r);
  4. }
复制代码

为了避免混淆概念，异步API并不是多线程。像我们在add例子里看到的，并没有涉及多线程。

异步JDBC

看了一些基本的异步的API，现在了解下 vertx-jdbc-client 。这个组件能够让我们通过 JDBC driver 与数据库交互。这些交互都是异步的，以前这样：

  1. String sql = "SELECT * FROM Products";
  2. ResultSet rs = stmt.executeQuery(sql);
复制代码

现在要这样：

  1. connection.query("SELECT * FROM Products", result -> {
  2. // do something with the result
  3. });
复制代码

这个模型更高效，当结果出来后vert.x通知，避免了等待结果。

增加maven依赖

在 pom.xml 文件中增加两个 Maven dependencies

  1. <dependency>
  2. <groupId>io.vertx</groupId>
  3. <artifactId>vertx-jdbc-client</artifactId>
  4. <version>3.1.0</version>
  5. </dependency>
  6. <dependency>
  7. <groupId>org.hsqldb</groupId>
  8. <artifactId>hsqldb</artifactId>
  9. <version>2.3.3</version>
  10. </dependency>
复制代码

第一个依赖提供了 vertx-jdbc-client ，第二个提供了 HSQL JDBC 的驱动。如果你想使用另外一个数据库，修改这个依赖，同时你还需要修改 JDBC url 和 JDBC driver 名。

初始化JDBC client

创建JDBC 客户端（client）：

在 MyFirstVerticle 类中，声明一个新变量 JDBCClient jdbc ，并且在 start 方法中添加：

  1. jdbc = JDBCClient.createShared(vertx, config(), "My-Whisky-Collection");
复制代码

创建了一个JDBC client实例，使用verticle的配置文件配置JDBC client。这个配置文件需要提供下面的配置才能让JDBC client正常工作：

url－JDBC url，例如： jdbc:hsqldb:mem:db?shutdown=true _driver class－JDBC的驱动，例如： org.hsqldb.jdbcDriver

有了client，接下来需要连接数据库。连接数据库是通过使用 jdbc.getConnection 来实现的， jdbc.getConnection 需要传入一个 Handler> 参数。我们深入的了解下这个类型。首先，这是一个 Handler ，因此当结果准备好时它就会被调用。这个结果是 AsyncResult 的一个实例。 AsyncResult 是 vert.x 提供的一个结构，使用它能够知道连接数据库的操作是成功或失败了。如果成功了，它就会提供一个结果，这里结果是一个 SQLConnection 的实例。

当你接收一个 AsyncResult 的实例时，代码通常是：

  1. if (ar.failed()) {
  2. System.err.println("The operation has failed...: "
  3. + ar.cause().getMessage());
  4. } else {
  5. // Use the result:
  6. result = ar.result();
  7. }
复制代码

需要获取到 SQLConnection ，然后启动 rest 的应用。因为变成了异步的，这需要改变启动应用的方式。因此，如果将启动序列划分成多块：

  1. startBackend(
  2. (connection) -> createSomeData(connection,
  3. (nothing) -> startWebApp(
  4. (http) -> completeStartup(http, fut)
  5. ), fut
  6. ), fut);
复制代码
startBackend - 获取 SQLConnection 对象，然后调用下一步 createSomeData - 初始化数据库并插入数据。当完成后，调用下一步 startWebApp - 启动web应用 completeStartup - 最后完成启动

fut 由vert.x传入，通知已经启动或者启动过程中遇到的问题。

startBackend 方法：

  1. private void startBackend(Handler<AsyncResult<SQLConnection>> next, Future<Void> fut) {
  2. jdbc.getConnection(ar -> {
  3. if (ar.failed()) {
  4. fut.fail(ar.cause());
  5. } else {
  6. next.handle(Future.succeededFuture(ar.result()));
  7. }
  8. });
  9. }
复制代码

这个方法获取了一个SQLConnection对象，检查操作是否完成。如果成功，会调用下一步。失败了，就会报告一个错误。其他的方法遵循同样的模式：

检查上一步操作是否成功 处理业务逻辑 调用下一步 SQL

客户端已经准备好了，现在写SQL。从 createSomeData 方法开始，这个方法也是启动顺序中的一部分：

  1. private void createSomeData(AsyncResult<SQLConnection> result,
  2. Handler<AsyncResult<Void>> next, Future<Void> fut) {
  3. if (result.failed()) {
  4. fut.fail(result.cause());
  5. } else {
  6. SQLConnection connection = result.result();
  7. connection.execute(
  8. "CREATE TABLE IF NOT EXISTS Whisky (id INTEGER IDENTITY, name varchar(100), " +
  9. "origin varchar(100))",
  10. ar -> {
  11. if (ar.failed()) {
  12. fut.fail(ar.cause());
  13. connection.close();
  14. return;
  15. }
  16. connection.query("SELECT * FROM Whisky", select -> {
  17. if (select.failed()) {
  18. fut.fail(ar.cause());
  19. connection.close();
  20. return;
  21. }
  22. if (select.result().getNumRows() == 0) {
  23. insert(
  24. new Whisky("Bowmore 15 Years Laimrig", "Scotland, Islay"),
  25. connection,
  26. (v) -> insert(new Whisky("Talisker 57° North", "Scotland, Island"),
  27. connection,
  28. (r) -> {
  29. next.handle(Future.<Void>succeededFuture());
  30. connection.close();
  31. }));
  32. } else {
  33. next.handle(Future.<Void>succeededFuture());
  34. connection.close();
  35. }
  36. });
  37. });
  38. }
  39. }
复制代码

这个方法检查 SQLConnection 是否可用，然后执行一些SQL语句。首先，如果表不存在就创建表。看看下面代码：

  1. connection.execute(
  2. SQL statement,
  3. handler called when the statement has been executed
  4. )
复制代码

handler 接收 AsyncResult ，例如：只有是通知而已，没有实际返回的结果。

关闭连接

操作完成后，别忘了关闭SQL链接。这个连接会被放入连接池并且可以被重复利用。

在这个 handler 的代码里，检查了 statement 是否正确的执行了，如果正确，我们接下来检查表是否含有数据，如果没有，将会使用 insert 方法插入数据：

  1. private void insert(Whisky whisky, SQLConnection connection, Handler<AsyncResult<Whisky>> next) {
  2. String sql = "INSERT INTO Whisky (name, origin) VALUES ?, ?";
  3. connection.updateWithParams(sql,
  4. new JsonArray().add(whisky.getName()).add(whisky.getOrigin()),
  5. (ar) -> {
  6. if (ar.failed()) {
  7. next.handle(Future.failedFuture(ar.cause()));
  8. return;
  9. }
  10. UpdateResult result = ar.result();
  11. // Build a new whisky instance with the generated id.
  12. Whisky w = new Whisky(result.getKeys().getInteger(0), whisky.getName(), whisky.getOrigin());
  13. next.handle(Future.succeededFuture(w));
  14. });
  15. }
复制代码

这个方法使用带有INSERT（插入）statement（声明）的 upateWithParams 方法，且传入了值。这个方法避免了 SQL 注入。一旦statement执行了（当数据库没有此条数据就会创建），就创建一个新的 Whisky 对象，自动生成ID。

带有数据库（SQL）的REST

上面的方法都是启动顺序的一部分。但是，关于调用REST API的方法又是怎么样的呢？以 getAll 方法为例。这个方法被web应用前端调用，并检索存储的所有的产品：

  1. private void getAll(RoutingContext routingContext) {
  2. jdbc.getConnection(ar -> {
  3. SQLConnection connection = ar.result();
  4. connection.query("SELECT * FROM Whisky", result -> {
  5. List<Whisky> whiskies = result.result().getRows().stream().map(Whisky::new).collect(Collectors.toList());
  6. routingContext.response()
  7. .putHeader("content-type", "application/json; charset=utf-8")
  8. .end(Json.encodePrettily(whiskies));
  9. connection.close(); // Close the connection
  10. });
  11. });
  12. }
复制代码

这个方法获得了一个 SQLConnection 对象，然后发出一个查询。一旦获取到查询结果，它会像之前的方法一样写 HTTP response 。 getOne 、 deleteOne 、 updateOne 和 addOne 方法都是一样的。注意，在response之后，需要要关闭SQL连接。

看下传入到query方法的handler提供的结果。获取了一个包含了查询结果的ResultSet。每一行都是一个JsonObject，因此，如果你有一个数据对象使用JsonObject作为唯一的参数，那么创建这个对象很简单。

测试

需要小小的更新下测试程序，增加配置 JDBCClient 。在 MyFirstVerticleTest 类中，将 setUp 方法中创建的 DeploymentOption 对象修改成：

  1. DeploymentOptions options = new DeploymentOptions()
  2. .setConfig(new JsonObject()
  3. .put("http.port", port)
  4. .put("url", "jdbc:hsqldb:mem:test?shutdown=true")
  5. .put("driver_class", "org.hsqldb.jdbcDriver")
  6. );
复制代码

除了 http.port ，还配置了 JDBC url 和 JDBC 驱动。测试时，使用的是一个内存数据库。在 src/test/resources/my-it-config.json 文件中也要做同样的修改。

  1. {
  2. "http.port": ${http.port},
  3. "url": "jdbc:hsqldb:mem:it-test?shutdown=true",
  4. "driver_class": "org.hsqldb.jdbcDriver"
  5. }
复制代码

src/main/conf/my-application-conf.json 文件也同样需要修改，这不是为了测试，而是为了运行这个应用：

  1. {
  2. "http.port" : 8082,
  3. "url": "jdbc:hsqldb:file:db/whiskies",
  4. "driver_class": "org.hsqldb.jdbcDriver"
  5. }
复制代码

这里这个 JDBC url 和上一个文件的有点不一样，因为需要将数据库存储到硬盘中。

展示时间！

开始构建程序：

mvn clean package

没有修改API（没有更改发布的java文件和REST接口），测试应该是可以顺利的运行的。

启动应用：

java -jar target/my-first-app-1.0-SNAPSHOT-fat.jar -conf src/main/conf/my-application-conf.json

访问 http://localhost:8082/assets/index.html ，然后，你可以看到这个应用使用的是数据库了。这一次，就算重启应用，这些数据仍然在，因为存储产品被持久化到硬盘里了。

总结

这篇文章中，知道了怎么在 vert.x 里使用 JDBC 数据库，并没有很多复杂的东西。开始可能会被这个异步的开发模型惊讶到，但是，一旦你开始使用了，你就很难再回去了。

下一次，我们将看到这个应用怎么使用mongoDB来替换HSQL。

Stay tuned, and happy coding !

来自： http://www.jianshu.com/p/6725ac7c2143

收藏 邀请
上一篇：Docker应用场景下一篇：JNI Construction Benchmark

最新评论

相关分类

小黑屋|在路上 ( 蜀ICP备15035742号-1 )  

;

GMT+8, 2025-7-9 02:26

Copyright 2015-2025 djqfx

返回顶部