Vert.x Java开发指南——第三章 重构为独立可重用的Verticle

最新推荐文章于 2024-09-26 17:39:09 发布
最新推荐文章于 2024-09-26 17:39:09 发布
阅读量3.1k 收藏 3
点赞数
分类专栏： 微服务 文章标签： Vert.x 微服务 Java
本文是Vert.x Java开发指南的第三章，介绍如何将应用重构为独立可重用的Verticle，包括HTTP Server Verticle和数据库Verticle的设计，以及如何通过事件总线解耦组件。内容涵盖Verticle的配置、SQL查询的管理、JDBC客户端的优化以及主Verticle的部署方法。
摘要由CSDN通过智能技术生成

第三章 重构为独立可重用的Verticle

版权声明：本文为博主自主翻译，转载请标明出处。 https://blog.csdn.net/elinespace/article/details/80381261

相应的代码位于本指南代码仓库的step-2目录下

通过第一次迭代，我们得到了一个可工作的Wiki应用。然而它的实现存在以下问题：

  1. HTTP请求处理和数据库访问代码交织在相同的方法中。
  2. 大量配置数据（如端口号、JDBC驱动等）是代码中的硬编码字符串。

3.1 架构和技术选择

第二次迭代是关于重构代码为独立可重用Verticle的：

这里写图片描述

我们将部署两个Verticle来处理HTTP请求，一个Verticle封装数据库持久化。由此产生的Verticle将没有相互的直接引用，它们将只商定事件总线中的目的地名称以及消息格式。这种方式提供了一个简单但有效的解耦。

发送到事件总线的消息将解码为JSON。虽然Vert.x的事件总线支持灵活的串行化方案用于高要求或者高度定制的上下文，但是使用JSON数据通常是明智的选择。使用JSON的另一个优势是它是一种语言无关的格式。由于Vert.x是支持多语言的，对于使用不同语言编写的Verticle之间的通讯，JSON是非常理想的。

3.2 HTTP Server Verticle

Verticle类开端及start方法看起来如下：

public class HttpServerVerticle extends AbstractVerticle {
    private static final Logger LOGGER = LoggerFactory.getLogger(HttpServerVerticle.class);
    public static final String CONFIG_HTTP_SERVER_PORT = "http.server.port"; ①
    public static final String CONFIG_WIKIDB_QUEUE = "wikidb.queue";
    private String wikiDbQueue = "wikidb.queue";
    @Override
    public void start(Future<Void> startFuture) throws Exception {
        wikiDbQueue = config().getString(CONFIG_WIKIDB_QUEUE, "wikidb.queue"); ②
        HttpServer server = vertx.createHttpServer();
        Router router = Router.router(vertx);
        router.get("/").handler(this::indexHandler);
        router.get("/wiki/:page").handler(this::pageRenderingHandler);
        router.post().handler(BodyHandler.create());
        router.post("/save").handler(this::pageUpdateHandler);
        router.post("/create").handler(this::pageCreateHandler);
        router.post("/delete").handler(this::pageDeletionHandler);
        int portNumber = config().getInteger(CONFIG_HTTP_SERVER_PORT, 8080); ③
        server
            .requestHandler(router::accept)
            .listen(portNumber, ar -> {
                if (ar.succeeded()) {
                    LOGGER.info("HTTP server running on port " + portNumber);
                    startFuture.complete();
                } else {
                    LOGGER.error("Could not start a HTTP server", ar.cause());
                    startFuture.fail(ar.cause());
                }
            });
    }
    // (...)

① 我们暴露了公开的常量用于Verticle配置参数：HTTP端口号以及发送消息到数据库Verticle的事件总线目的地名称。

② AbstractVerticle#config()方法允许访问已提供的Verticle配置。对于没有指定值的情况，第二个参数是默认值。

③ 配置值不只可以是字符串，也可以是整数、布尔值以及复杂的JSON数据等。

该类剩余部分主要是提取HTTP部分的代码，以前的数据库代码通过事件总线消息替换。这是indexHandler方法的代码：

private final FreeMarkerTemplateEngine templateEngine = FreeMarkerTemplateEngine.create();
private void indexHandler(RoutingContext context) {
    DeliveryOptions options = new DeliveryOptions().addHeader("action", "all-pages"); ②
    vertx.eventBus().send(wikiDbQueue, new JsonObject(), options, reply -> { ①
        if (reply.succeeded()) {
            JsonObject body = (JsonObject) reply.result().body(); ③
            context.put("title", "Wiki home");
            context.put("pages", body.getJsonArray("pages").getList());
            templateEngine.render(context, "templates", "/index.ftl", ar -> {
                if (ar.succeeded()) {
                    context.response().putHeader("Content-Type", "text/html");
                    context.response().end(ar.result());
                } else {
                    context.fail(ar.cause());
                }
            });
        } else {
            context.fail(reply.cause());
        }
    });
}

① vertx对象提供了对事件总线的访问，我们发送一个消息到数据库Verticle的队列。

② 传递选项（DeliveryOptions）允许我们指定头、有效载荷（payload）编解码器和超时时间。

③ 一旦成功，回复包含有效载荷。

正如我们所看到的，事件总线消息由一个消息体和选项组成，它可以选择性地期待一个答复。对于没有预期答复的情况，有一个send方法的变体，它没有Handler参数。

我们将有效载荷编码为JSON对象，并通过一个称为action的消息头指定数据库Verticle应该执行哪个操作。

Verticle的剩余代码就是路由器处理器，同样使用事件总线获取和存储数据：

private static final String EMPTY_PAGE_MARKDOWN = "# A new page\n" + "\n"
        + "Feel-free to write in Markdown!\n";

private void pageRenderingHandler(RoutingContext context) {
    String requestedPage = context.request().getParam("page");
    JsonObject request = new JsonObject().put("page", requestedPage);
    DeliveryOptions options = new DeliveryOptions().addHeader("action",
            "get-page");
    vertx.eventBus().send(
            wikiDbQueue,
            request,
            options,
            reply -> {
                if (reply.succeeded()) {
                    JsonObject body = (JsonObject) reply.result().body();
                    boolean found = body.getBoolean("found");
                    String rawContent = body.getString("rawContent",
                            EMPTY_PAGE_MARKDOWN);
                    context.put("title", requestedPage);
                    context.put("id", body.getInteger("id", -1));
                    context.put("newPage", found ? "no" : "yes");
                    context.put("rawContent", rawContent);
                    context.put("content", Processor.process(rawContent));
                    context.put("timestamp", new Date().toString());
                    templateEngine.render(
                            context,
                            "templates",
                            "/page.ftl",
                            ar -> {
                                if (ar.succeeded()) {
                                    context.response().putHeader(
                                            "Content-Type", "text/html");
                                    context.response().end(ar.result());
                                } else {
                                    context.fail(ar.cause());
                                }
                            });
                } else {
                    context.fail(reply.cause());
                }
            });
}

private void pageUpdateHandler(RoutingContext context) {
    String title = context.request().getParam("title");
    JsonObject request = new JsonObject()
            .put("id", context.request().getParam("id"))
            .put("title", title)
            .put("markdown", context.request().getParam("markdown"));
    DeliveryOptions options = new DeliveryOptions();
    if ("yes".equals(context.request().getParam("newPage"))) {
        options.addHeader("action", "create-page");
    } else {
        options.addHeader("action", "save-page");
    }

    vertx.eventBus().send(wikiDbQueue, request, options, reply -> {
        if (reply.succeeded()) {
            context.response().setStatusCode(303);
            context.response().putHeader("Location", "/wiki/" + title);
            context.response().end();
        } else {
            context.fail(reply.cause());
        }
    });
}

private void pageCreateHandler(RoutingContext context) {
    String pageName = context.request().getParam("name");
    String location = "/wiki/" + pageName;
    if (pageName == null || pageName.isEmpty()) {
        location = "/";
    }
    context.response().setStatusCode(303);
    context.response().putHeader("Location", location);
    context.response().end();
}

private void pageDeletionHandler(RoutingContext context) {
    String id = context.request().getParam("id");
    JsonObject request = new JsonObject().put("id", id);
    DeliveryOptions options = new DeliveryOptions().addHeader("action",
            "delete-page");
    vertx.eventBus().send(wikiDbQueue, request, options, reply -> {
        if (reply.succeeded()) {
            context.response().setStatusCode(303);
            context.response().putHeader("Location", "/");
            context.response().end();
        } else {
            context.fail(reply.cause());
        }
    });
}

3.3 数据库Verticle

使用JDBC链接到一个数据库当然需要数据库驱动以及配置，这些我们在第一次迭代中采用硬编码的方式实现。

3.3.1 配置SQL查询

在将前面Verticle的硬编码值转换为配置参数的同时，我们还可以进一步从一个配置文件中加载SQL查询。

查询语句将从一个文件中加载，这个文件名作为一个配置参数传递，如果没有提供则从一个默认资源加载。这个方法的优点是Verticle可以适配不同的JDBC驱动和SQL方言。

Verticle类的开端包含了主要的配置键的定义：

public class WikiDatabaseVerticle extends AbstractVerticle {
    public static final String CONFIG_WIKIDB_JDBC_URL = "wikidb.jdbc.url";
    public static final String CONFIG_WIKIDB_JDBC_DRIVER_CLASS = "wikidb.jdbc.driver_class";
    public static final String CONFIG_WIKIDB_JDBC_MAX_POOL_SIZE = "wikidb.jdbc.max_pool_size";
    public static final String CONFIG_WIKIDB_SQL_QUERIES_RESOURCE_FILE = "wikidb.sqlqueries.resource.file";
    public static final String CONFIG_WIKIDB_QUEUE = "wikidb.queue";
    private static final Logger LOGGER = LoggerFactory.getLogger(WikiDatabaseVerticle.class);
    // (...)

SQL查询存储在一个Properties文件中，使用HSQLDB的默认文件位于src/main/resources/db-queries.properties：

create-pages-table=create table if not exists Pages (Id integer identity primary key, Name varchar(255) unique, Content
clob)
get-page=select Id, Content from Pages where Name = ?
create-page=insert into Pages values (NULL, ?, ?)
save-page=update Pages set Content = ? where Id = ?
all-pages=select Name from Pages
delete-page=delete from Pages where Id = ?

WikiDdatabaseVerticle中的以下代码用于从文件中加载SQL查询，并将它们放到一个map中：

private enum SqlQuery {
    CREATE_PAGES_TABLE,
    ALL_PAGES,
    GET_PAGE,
    CREATE_PAGE,
    SAVE_PAGE,
    DELETE_PAGE
}

private final HashMap<SqlQuery, String> sqlQueries = new HashMap<>();

private void loadSqlQueries() throws IOException {
    String queriesFile = config().getString(CONFIG_WIKIDB_SQL_QUERIES_RESOURCE_FILE);
    InputStream queriesInputStream;
    if (queriesFile != null) {
        queriesInputStream = new FileInputStream(queriesFile);
    } else {
        queriesInputStream = getClass().getResourceAsStream("/db-queries.properties");
    }
    Properties queriesProps = new Properties();
    queriesProps.load(queriesInputStream);
    queriesInputStream.close();
    sqlQueries.put(SqlQuery.CREATE_PAGES_TABLE, queriesProps.getProperty("create-pages-table"));
    sqlQueries.put(SqlQuery.ALL_PAGES, queriesProps.getProperty("all-pages"));
    sqlQueries.put(SqlQuery.GET_PAGE, queriesProps.getProperty("get-page"));
    sqlQueries.put(SqlQuery.CREATE_PAGE, queriesProps.getProperty("create-page"));
    sqlQueries.put(SqlQuery.SAVE_PAGE, queriesProps.getProperty("save-page"));
    sqlQueries.put(SqlQuery.DELETE_PAGE, queriesProps.getProperty("delete-page"));
}

在接下来的代码中，我们使用SqlQuery枚举类型以避免字符串常量。Verticle的start方法代码如下：

private JDBCClient dbClient;

@Override
public void start(Future<Void> startFuture) throws Exception {
    /*
    * Note: this uses blocking APIs, but data is small...
    */
    loadSqlQueries(); ①
    dbClient = JDBCClient.createShared(vertx, new JsonObject()
        .put("url", config().getString(CONFIG_WIKIDB_JDBC_URL, "jdbc:hsqldb:file:db/wiki"))
        .put("driver_class", config().getString(CONFIG_WIKIDB_JDBC_DRIVER_CLASS, "org.hsqldb.jdbcDriver"))
        .put("max_pool_size", config().getInteger(CONFIG_WIKIDB_JDBC_MAX_POOL_SIZE, 30)));
    dbClient.getConnection(ar -> {
        if (ar.failed()) {
            LOGGER.error("Could not open a database connection", ar.cause());
            startFuture.fail(ar.cause());
        } else {
            SQLConnection connection = ar.result();
            connection.execute(sqlQueries.get(SqlQuery.CREATE_PAGES_TABLE), create -> { ②
                connection.close();
                if (create.failed()) {
                    LOGGER.error("Database preparation error", create.cause());
                    startFuture.fail(create.cause());
                } else {
                    vertx.eventBus().consumer(config().getString(CONFIG_WIKIDB_QUEUE,                       "wikidb.queue"), this::onMessage); ③
                    startFuture.complete();
                }
            });
        }
    });
}

① 有趣的是，我们打破了Vert.x中的一个重要的原则——就是避免阻塞API，但是因为没有异步API来访问类路径上的资源，所以我们的选择是受限的。我们可以使用Vert.x的executeBlocking方法将阻塞的I/O操作从事件循环转移到工作者线程，但是由于数据非常小，这么做没有明显的效益。

② 这儿是使用SQL查询的一个示例。

③ consumer方法注册了一个事件总线目的地Handler。

3.3.2 分发请求

事件总线消息的Handler是onMessage方法：

public enum ErrorCodes {
    NO_ACTION_SPECIFIED,
    BAD_ACTION,
    DB_ERROR
}
public void onMessage(Message<JsonObject> message) {
    if (!message.headers().contains("action")) {
        LOGGER.error("No action header specified for message with headers {} and body {}",
        message.headers(), message.body().encodePrettily());
        message.fail(ErrorCodes.NO_ACTION_SPECIFIED.ordinal(), "No action header specified");
        return;
    }
    String action = message.headers().get("action");
    switch (action) {
        case "all-pages":
            fetchAllPages(message);
            break;
        case "get-page":
            fetchPage(message);
            break;
        case "create-page":
            createPage(message);
            break;
        case "save-page":
            savePage(message);
            break;
        case "delete-page":
            deletePage(message);
            break;
        default:
            message.fail(ErrorCodes.BAD_ACTION.ordinal(), "Bad action: " + action);
    }
}

我们为错误定义了一个ErrorCodes枚举，用来报回消息发送者。为此，Message类的fail方法提供了一个便捷方式答复错误，原消息发送者得到一个失败的AsyncResult.

3.3.3 减少JDBC客户端样板文件（译者注：原文使用的是boilerplate，应该指的是那些重复的代码）

截止目前，我们可以看到执行一个SQL查询的完整交互：

  1. 获取一个链接
  2. 执行请求
  3. 释放链接

这导致对每个异步操作需要异常处理的地方都需要编码，如下：

dbClient.getConnection(car -> {
    if (car.succeeded()) {
        SQLConnection connection = car.result();
        connection.query(sqlQueries.get(SqlQuery.ALL_PAGES), res -> {
            connection.close();
            if (res.succeeded()) {
                List<String> pages = res.result()
                    .getResults()
                    .stream()
                    .map(json -> json.getString(0))
                    .sorted()
                    .collect(Collectors.toList());
                message.reply(new JsonObject().put("pages", new JsonArray(pages)));
            } else {
                reportQueryError(message, res.cause());
            }
        });
    } else {
        reportQueryError(message, car.cause());
    }
});

自从Vert.x 3.5.0开始，JDBC客户端现在支持一次性（one-shot）操作，获取一个链接执行一个SQL操作，并且在内部释放。与前面相同的代码现在简化如下：

dbClient.query(sqlQueries.get(SqlQuery.ALL_PAGES), res -> {
if (res.succeeded()) {
List<String> pages = res.result()
.getResults()
.stream()
.map(json -> json.getString(0))
.sorted()
.collect(Collectors.toList());
message.reply(new JsonObject().put("pages", new JsonArray(pages)));
} else {
reportQueryError(message, res.cause());
}
});

这对于获取数据库链接执行一个单独操作的情况非常有用。但就性能而言，需要注意的是，对于链式的SQL操作，重用数据库链接会更好。

该类的剩余部分包含了onMessage分发接收消息时的私有方法调用：

private void fetchAllPages(Message<JsonObject> message) {
    dbClient.query(sqlQueries.get(SqlQuery.ALL_PAGES), res -> {
        if (res.succeeded()) {
            List<String> pages = res.result()
                .getResults()
                .stream()
                .map(json -> json.getString(0))
                .sorted()
                .collect(Collectors.toList());
            message.reply(new JsonObject().put("pages", new JsonArray(pages)));
        } else {
            reportQueryError(message, res.cause());
        }
    });
}

private void fetchPage(Message<JsonObject> message) {
    String requestedPage = message.body().getString("page");
    JsonArray params = new JsonArray().add(requestedPage);
    dbClient.queryWithParams(sqlQueries.get(SqlQuery.GET_PAGE), params, fetch -> {
        if (fetch.succeeded()) {
            JsonObject response = new JsonObject();
            ResultSet resultSet = fetch.result();
            if (resultSet.getNumRows() == 0) {
                response.put("found", false);
            } else {
                response.put("found", true);
                JsonArray row = resultSet.getResults().get(0);
                response.put("id", row.getInteger(0));
                response.put("rawContent", row.getString(1));
            }
            message.reply(response);
        } else {
            reportQueryError(message, fetch.cause());
        }
    });
}

private void createPage(Message<JsonObject> message) {
    JsonObject request = message.body();
    JsonArray data = new JsonArray()
        .add(request.getString("title"))
        .add(request.getString("markdown"));
    dbClient.updateWithParams(sqlQueries.get(SqlQuery.CREATE_PAGE), data, res -> {
        if (res.succeeded()) {
            message.reply("ok");
        } else {
            reportQueryError(message, res.cause());
        }
    });
}

private void savePage(Message<JsonObject> message) {
    JsonObject request = message.body();
    JsonArray data = new JsonArray()
        .add(request.getString("markdown"))
        .add(request.getString("id"));
    dbClient.updateWithParams(sqlQueries.get(SqlQuery.SAVE_PAGE), data, res -> {
        if (res.succeeded()) {
            message.reply("ok");
        } else {
            reportQueryError(message, res.cause());
        }
    });
}

private void deletePage(Message<JsonObject> message) {
    JsonArray data = new JsonArray().add(message.body().getString("id"));
    dbClient.updateWithParams(sqlQueries.get(SqlQuery.DELETE_PAGE), data, res -> {
        if (res.succeeded()) {
            message.reply("ok");
        } else {
            reportQueryError(message, res.cause());
        }
    });
}

private void reportQueryError(Message<JsonObject> message, Throwable cause) {
    LOGGER.error("Database query error", cause);
    message.fail(ErrorCodes.DB_ERROR.ordinal(), cause.getMessage());
}

3.4 从主Verticle部署Verticle

我们依旧有一个MainVerticle类，但它不是像首次迭代一样包含所有逻辑，它的唯一目的是启动应用并且部署其它Verticle。

这些代码包括部署一个WikiDatabaseVerticle实例和两个HttpServerVerticle实例：

public class MainVerticle extends AbstractVerticle {

@Override
public void start(Future<Void> startFuture) throws Exception {
    Future<String> dbVerticleDeployment = Future.future(); ①
    vertx.deployVerticle(new WikiDatabaseVerticle(), dbVerticleDeployment.completer()); ②
    dbVerticleDeployment.compose(id -> { ③
        Future<String> httpVerticleDeployment = Future.future();
        vertx.deployVerticle("io.vertx.guides.wiki.HttpServerVerticle", ④
                new DeploymentOptions().setInstances(2), ⑤
                httpVerticleDeployment.completer());
        return httpVerticleDeployment; ⑥
        }).setHandler(ar -> { ⑦
            if (ar.succeeded()) {
                startFuture.complete();
            } else {
                startFuture.fail(ar.cause());
            }
        });
    }
}

① 部署Verticle是一个异步操作，因此我们需要一个Future。String参数类型是因为一个Verticle部署成功时会返回一个标识。

② 一种选择是使用new创建一个Verticle实例，传递对象引用给deploy方法。completer返回值是一个处理器，简单的完成future。

③ 使用compose的顺序组合允许在一个操作之后运行另一个异步操作。当初始化future成功完成之后，调用组合方法。

④ 指定一个类名字符串也是部署Verticle的一种选项。对于其它JVM语言来说，基于字符串的惯例（conventions）允许指定一个模块/脚本。

⑤ DeploymentOption类允许指定一些参数，尤其部署的实例个数。

⑥ 组合方法返回下一个future。它的完成将会触发组合操作的完成。

⑦ 我们定义了一个Handler，以便完成MainVerticle的启动future。

精明的读者可能会感到惊奇，我们怎么可以在同一个端口部署HTTP Server代码两次，并且对于每个实例都不期望出现由于TCP端口已经被占用而导致的任何错误。对于许多Web框架，我们需要选择不同的TCP端口，并且有一个前端HTTP代理来执行端口之间的负载平衡。

对于Vert.x则不需要这么做，多个Verticle可以共享相同的TCP端口号。传入的连接只是简单的通过接收线程以轮转的方式分发。

边城白衣
关注
专栏目录
Vert.x！这是目前最快的 Java 框架
01-07
如果您搜索“最佳网络框架”，您可能会偶然发现Techempower基准测试，其中排名超过300个框架，在那里你可能已经注意到Vert.x是排名最高的。Vert.x是一个多语言 Web 框架，它支持Java，Kotlin，Scala，Ruby和Javascript支持的语言之间的共同功能。无论语言如何，Vert.x都在Java虚拟机（JVM）上运行。模块化和轻量级，它面向微服务开发。Techempower基准测试衡量从数据库更新，获取和交付数据的性能。每秒提供的请求越多越好。在这种涉及很少计算的IO场景中，任何非阻塞框架都会有优势。近年来，这种范式几乎与Node.js不可分割，Node.js通过
Vert.x Java开发指南——第一章 介绍
边城白衣的博客
05-19 6285
第一章 介绍 该指南是Vert.x异步编程的一个入门介绍，主要针对那些熟悉主流、非异步Web开发框架和库（如Java EE、Spring）的开发者。 1.1 关于该手册 我们假定读者已经熟悉Java编程语言及其生态系统。 我们将以一个Wiki Web应用作为开始，它开始采用关系数据库和服务端页面渲染；然后我们通过几个步骤逐步演进该应用，直到它成为一个现代的单页应用，并且拥有实时Web的...
Vert.x 和 Spring Boot 是两种流行的 Java 框架的比较
最新发布
wolf23151269的博客
09-26 1436
Vert.x：异步非阻塞，适合高并发、高 I/O 密集型应用，性能优异，灵活性高，但在生态系统和企业级支持方面不如 Spring Boot 成熟。：同步阻塞编程模型，生态系统庞大，企业支持全面，开发效率高，适合绝大多数企业应用场景，也支持通过 WebFlux 实现异步非阻塞。在不同的应用场景下，根据项目需求选择合适的框架，可以最大化发挥两者的优势。
vert.x+java入门_Vertx入门教程 -解道Jdon
weixin_39710594的博客
02-26 373
事件驱动架构EDAVert.x入门教程Vert.x是一个轻量级的高性能JVM应用平台，基于它可开发各种移动，Web和企业应用程序。一个主要特点是可使用多种语言编写应用，如Java, JavaScript, CoffeeScript, Ruby, Python 或 Groovy等等，它的简单actor-like机制能帮助脱离直接基于多线程编程。它是基于Netty和Java 7的NIO2的编写的。当前...
Vert.x Java开发指南——第二章 使用Vert.x编写最小可用Wiki
边城白衣的博客
05-19 7899
第二章 使用Vert.x编写的最小可用Wiki 相应的源代码位于该指南代码库的step-1目录下 我们将从第一次迭代开始，最简单的代码可能是使用Vert.x编写一个Wiki。而下一次迭代将在代码库中引入更多的简洁以及适当的测试，我们将看到基于Vert.x的快速原型是一个既简单又现实的目标。 现阶段，Wiki将使用HTML页面的服务端渲染以及通过JDBC链接进行数据持久化。为了完成这些...
vert.x java_使用Java 9模块和Vert.x微服务构建CI系统
cunfu6353的博客
07-10 345
vert.x java 重要要点 Java 9和Vert.x微服务与构建应用程序兼容 许多Java库仍无法作为模块使用 “自动模块”（库尚未打包为模块）需要格外小心 Java的内置Nashorn Javascript环境对于编写Vert.x应用程序很有用 本文将引导您使用Eclipse Vert.x工具包设计和开发现代的，响应式，弹性和消息驱动的持续集成（CI）系统...
Vert.x 4 核心手册中文版
05-27
Vert.x 是一个轻量级、高性能的反应式应用开发框架，适用于 Java 和其他多种语言。它的核心组件小巧且灵活，允许开发者只使用需要的部分，并能无缝嵌入到现有的应用程序中，无需按照特定的架构模式进行改造。Vert.x ...
基于Vert.x(java)开发的API网关,是一个分布式,全异步,高性能,可扩展,轻.zip
03-23
标题中的“基于Vert.x(java)开发的API网关”指的是使用Vert.x框架构建的应用程序，该应用程序主要功能是作为API网关。API网关是一种架构模式，它充当客户端（如Web应用、移动应用或IoT设备）与后端服务之间的单一...
Vert.x应用开发实例教程
01-17
一个Vert.x有一个或多个事件循环线程组成，线程最大数量为主机有效的CPU核数。 Event Loop Vertical：事件的业务处理线程，存在于Event Loop中，用于处理非阻塞短任务。 Worker Vertical : 事件的业务处理线程，用于...
Vert.x:关于Vert.x Mongo客户端的教程
05-14
Vert.x 该存储库显示了如何在包含RESTful Web服务的Web应用程序上使用Vert.x core ， web和test模块以及mongodb和web客户端。 您将在此存储库中学到什么？ 如何部署Verticle 如何创建和使用HTTP服务器 如何为Web...
vert-x:使用Java语言中的vert-x框架的基本功能进行项目
04-27
垂直 使用Java语言中的vert-x框架的基本功能进行项目设计。 在3.1.0版中使用vert-x Java 8 Maven的3 春天4 蒙哥3 ＃运行项目要运行项目，必须在计算机上配置maven依赖管理器和版本8中的Java。 输入项目的vertx目录并执行命令： mvn清洁包装 完成上述命令后，执行以下命令： java -jar目标/ vex-1.0-SNAPSHOT-fat.jar 消息后： 信息：成功部署垂直 访问URL： 并浏览应用程序 ＃CNAB集成可以从软件包的根目录获得有关CNAB400集成的类： com.daniel.vertx.cnab 为了测试Vert-x文件写入功能和其余处理，开发了CNAB400协议附带的文件写入功能（随附的文档）。 作为示例，仅开发了文件头的编写，但是有了它，就已经可以看到框架的行为了。 根据休假后的要求撰写作品。
探索Java中的Vert.x框架
weixin_53840353的博客
08-22 867
在现代应用程序开发中，性能和响应速度是关键因素。随着微服务架构的广泛应用，异步和非阻塞编程模型变得越来越重要。Vert.x是一个多语言的应用程序框架，它特别适合编写高性能、实时的网络应用。本文将详细介绍Vert.x框架的核心概念，并通过示例代码展示如何使用Vert.x构建一个简单的微服务。Vert.x是一个开源的、反应式的应用程序框架，支持多种编程语言（包括Java、Kotlin、Groovy、Ruby等）。Vert.x的设计目标是在尽可能高的并发量下保持最低的延迟。
这是目前最快的 Java 框架，300个框架中排名第一，真香
weixin_46302190的博客
02-23 507
如果您搜索“ 最佳网络框架 ”，您可能会偶然发现Techempower基准测试，其中排名超过300个框架，在那里你可能已经注意到Vert.x是排名最高的。 Vert.x是一个多语言 Web 框架，它支持 Java ，Kotlin，Scala，Ruby和Javascript支持的语言之间的共同功能。 无论语言如何，Vert.x都在Java虚拟机（JVM）上运行。 模块化和轻量级，它面向微服务开发。 ...
【Java】初学Vert.x（1）
Kida 的技术小屋（CSDN 版）
04-14 1000
今天开始将分享自己初学Vert.x的一些经验和看法。里面有不足或想得不周到的地方，还请各位看官多多包涵。
vert.x+java入门_从Vert.x开始_Java API 版本的Vert.x Core 手册_w3cschool
weixin_28753647的博客
02-26 190
注意：这大部分是Java特有的-需要语言特有的调用方法如果没有获得Vertx对象，Vert.x做不了什么。Vertx对象是 Vert.x 的控制中心，几乎可以做所有事，包括创建客户端和服务器，获取引用到事件总线(event bus)、 设置计时器等。所以怎么获得Vertx实例?如果已经嵌入了 Vert.x，然后只需创建一个实例，如下所示:Vertx vertx = Vertx.vertx();如果...
Vert.x Java开发指南——第十二章 结束
边城白衣的博客
06-23 764
第十二章 结束 这是本指南的最后一部分，让我们花点时间来概括一下前面几章中的重要收获，然后再给出更多有用的资源。 12.1 概述 我们通过使用Vert.x构建一个Wiki web应用作为开始。首次迭代是典型的“快速但令人不快的快速原型”，它展示了我们使用Web模板的服务端渲染以及使用关系数据库持久化，可以快速且轻易构建应用程序。 下一步，展示了如何通过连续的重构提升设计：首先分离每个技...
vert.x+java入门_vertx从入门到精通
weixin_39913472的博客
02-26 331
1、Vert.x安装指南http://blog.csdn.net/sdyy321/article/details/38926005http://blog.csdn.net/chszs/article/details/8949559在windows下，jdk有多个版本，需要切换，切换方式：1)Set JAVA_HOME in windows cmd.(在windows 命令行中修改JAVA_HOME...
Vert.x Java开发指南——第六章 与第三方的Web服务集成
边城白衣的博客
06-03 1383
第六章 与第三方的Web服务集成 相应代码位于本指南仓库的step-5目录下。 现代应用很少位于孤岛之上，因为它们需要与其它（分布式）应用和服务集成。集成通常采用API实现，这些API通过多功能的HTTP协议公开。 本章展示了如何使用Vert.x的HTTP客户端API与第三方Web服务集成。 6.1 场景：备份到GitHub Gist GitHub Gist服务（https:...
Vert.x Core Java指南：异步应用开发与 EventBus详解
Vert.x是一个强大的Java应用平台，基于JVM设计，专为现代移动后端、互联网和企业应用架构提供高性能、轻量级的支持。它建立在Netty全异步网络库之上，具有多种编程语言支持、异步无锁编程、丰富的I/O操作支持、高效...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值