Vertx入门学习(含代码)

一、Vertx是什么?

github: https://github.com/vert-x3
官网:http://vertx.io/

Vert.x诞生于2011年,当时叫node.x,不过后来因为某些原因改名为Vert.x,目前官网最新版本是4.4.0,官网上介绍Vert.x是一个用于在JVM上构建高效应用程序的工具包,是JVM上的Reative开发套件。说白了,Vert.x就是一堆的jar包,提供了一系列的编程API接口,通过这些API可以实现异步编程。
Vert.x目前是我见过功能最强大、对第三方库依赖最少的Java框架,是一个异步无阻塞的网络框架,其参照物是node.js,基本上node.js能干的事情,Vert.x都能干,它只依赖Netty4以及Jacskon,Vert.x利用Netty4的EventLoop来做单线程的事件循环,所以跑在Vert.x上的业务不能做CPU密集型的运算,这样会导致整个线程被阻塞,另外如果你需要建立分布式的Vert.x,则再依赖HazelCast这个分布式框架即可,注意Vert.x3必须基于Java8。由于基于JVM,所以Vert.x可以用其他语言来实现你的业务。
异步编程怎么理解呢?对于写过ajax的人来说,不难理解,$.ajax方法并不会阻塞,而是直接向下执行,等到远程服务器响应之后,才会回调success方法,那么这时候success方法才会执行。ajax下面的代码不会等到success方法执行完毕之后再执行,这就是所谓的异步。如下:

console.log("1");
$.ajax({
    "url" : "/hello",
    "type" : "post",
    "dataType" : "json",
    "success" : function(val) {
        console.log("2");
    }
});
console.log("3");

浏览器会先输出1,在hello方法没有相应之前不会输出2,但是会先输出3,等接口响应success之后会输出2,这就是异步,异步编程是Vert.x的一大特性,也是Vert.x的核心,Vert.x可以开发Web应用,但Vert.x不仅仅是一个Web开发框架,他更像Spring,是一个技术栈(Vert.x生态可以查看https://github.com/vert-x3/vertx-awesome),或者说是一个Vert.x生态体系。在这个体系中,Vert.x只是提供了Web开发的能力。下面对Vertx和Spring做一个对比:

项目SpringVertx
核心框架spring-corevertx-core
Web开发spring-webmvcvertx-web
jdbc框架spring-jdbcvertx-jdbc-client
redisspring-data-redisvertx-redis-client
微服务spring-cloudvertx-hazelcast

可以说,很多spring能做的事情,Vertx也都能实现。那么既然如此,Spring如此强大,社区如此活跃,为何还会有Vertx呢?他们之前区别的核心点就只有一个:Spring的操作是同步的,Vertx的操作是异步的。异步带来了更高的性能,但同时也带来了编码和调试的复杂度,但不得不说异步可能是未来的一个趋势,至少在Java实现高性能服务器上的一个趋势。
在Java领域,做Web开发我们一般有很多的选择,比如使用原生的Servlet,比如使用SpringMVC,再比如使用Struts等等总之你有很多的选择。在国内,目前来讲,SpringMVC作为Spring体系下的Web层架构,是深受企业青睐的,绝大部分的企业可能都在使用SpringMVC,而对于我们今天要说的Vert.x这个Web层框架,却很少有人知道,但它却是仅次于SpringMVC,排名第二的一个Web层框架。
Vert.x是基于事件的,提供一个事件驱动编程模型,使用Vert.x作为服务器时,程序员只要编写事件处理器event handler即可,当TCP socket有数据时,event handler理解被创建调用,另外它还可以在以下几种情况激活: ‘当事件总线Event Bus接受到消息时,’ ‘当接收到HTTP消息时,’ 当一个连接断开时’,’ ‘当计时器超时时.’
作为服务层处理逻辑这一层基本上对应的传统Java里的领域模型处理层,各种Service调用以及对数据层的调用,差不多是一个承上启下的一层,传统的模型里,这一层基本上都是同步调用,即使有异步调用,也是与业务逻辑分离的异步,如果全异步会导致业务逻辑碎乱,代码很难描述清楚,到这里你会发现Vert.x其实不太好融合到业务性很强的服务层里,其主要原因如下
1、自身是异步体系,不适合描述顺序逻辑性强的业务。
2、由于异步的问题,访问数据层也必须是异步,导致业务模型进一步碎片化。

二、Vertx基本概念

我们学习一个新东西,都要去了解理解它的基本概念,学习Vert.x也是如此。那么Vert.x又有哪些基本概念呢?

  • Verticle:Vert.x的执行单元,即程序的入口,它可以用JS、Ruby、Java等多语言来编写,每个语言可能实现的方式不一样,比如Java需要继承一个AbstractVerticle抽象类。在同一个Vert.x实例中可以同时执行多个Verticle,一个应用可能由多个Verticle组成,它们被部署到不同的网络节点上,彼此之间通过在Vert.x的事件总线(event bus)上交换信息来通信。
  • Module:Vert.x应用由一个或者多个modules来实现,一个module由多个verticles来实现,所以可以把module理解为Java package,里面可能是特定业务的实现或者公共的服务实现(那些可以重用的服务),Vert.x编写好的module可以发布到maven的仓库里,以zip包装成二进制格式,或者发布到vert.x module 注册中心,实际上这种以模块方式的开发,支撑着整个Vert.x生态系统。
  • Event Loops:事件循环,是由Vert.x启动的事件处理线程,也是Vert.x项目对外开放的入口,Vert.x由此接收请求事件,一个Vert.x由一个或者多个事件循环线程组成,线程最大数为主机有效的CPU核数。处理函数是handler接口,用来处理事件。
  • Event Loop verticle:事件的业务处理线程,存在于Event Loop中,用于处理非阻塞短任务。
  • Event bus:是Vert.x的核心,在集群中容器之间的通信,各个Verticle之间的通信也都是经过Event bus来实现的,所以Event bus存在堵塞的可能。
  • Shared Data(共享数据):消息通过bus可以在各个Vert.x实例直接传输,但是如果多个Verticle在一个Vert.x实例内,是可以避免进行消息传输的,比如单个JVM内,你不会通过两个socket互相在两个Java对象之间传输消息的,这是同样的道理,但是因为实例隔离,因为actor模型,所以对象数据如果要传输到handler里必须通过消息传输。Shared Data是Vert.x提供的一个简单共享map和set,用来解决各个Verticle之间的数据共享的,数据被存储到一个不可变的数据结构里,各个实例可以直接通过此API获取数据。
  • Worker Verticle(阻塞处理):事件处理之外肯定会发生长时间数据处理请求,比如处理一个图片上传,然后转存到磁盘等,此时就需要事件的业务处理线程用来处理长时间阻塞任务,worker verticle就是这个阻塞处理线程,是一种阻塞式的方法,但是无法做到并发水平扩展,在Verticle类型中有一种特别的verticle叫做worker,与标准的verticle不同的是它采用的是vert.x内部的另外一种线程池叫做worker pool,而不是使用event loop ,worker verticle不会并行的执行handler,而是阻塞式的,等前一个handler处理完了才会执行后面的请求,这种的适合CPU密集型的,标准的verticle适合IO密集型的。vert.x为了支持标准的和阻塞的worker verticle提供了一种混合线程模型,你可以根据自己的需求按需选择合适的线程模型。
    纯文字的,可能没什么概念,下面我们来看一下Vertx的框架图,加深印象,便于理解:
    在这里插入图片描述

三、Vertx能干什么?

一句话总结:Java能做的,Vert.x都能做。咱这里主要列出来Vert.x擅长做什么?

  • Web开发,Vert.x封装了Web开发常用的组件,支持路由、Session管理、模板等,可以非常方便的进行Web开发。不需要容器!不需要容器!不需要容器!
  • TCP/UDP开发,Vert.x底层基于Netty,提供了丰富的IO类库,支持多种网络应用开发。不需要处理底层细节(如拆包和粘包),注重业务代码编写。
  • 提供对WebSocket的支持,可以做网络聊天室,动态推送等。
  • Event Bus(事件总线)是Vert.x的神经系统,通过Event Bus可以实现分布式消息,远程方法调用等等。正是因为Event Bus的存在,Vert.x可以非常便捷的开发微服务应用。
  • 支持主流的数据和消息的访问redis mongodb rabbitmq kafka 等。
  • 分布式锁,分布式计数器,分布式map的支持。

四、Vertx的技术体系

上面也提到了,Vert.x和Spring一样,也有着完善的生态,具体可以查看https://github.com/vert-x3/vertx-awesome 我们可以看到,每一块内容都提供了多种的实现,有官方支持的版本还有社区版本。下面我们具体介绍下技术体系中官方支持的版本。

  • 核心模块。Vert.x核心模块包含一些基础的功能,如HTTP,TCP,文件系统访问,EventBus、WebSocket、延时与重复执行、缓存等其他基础的功能,你可以在你自己的应用程序中直接使用。可以通过vertx-core模块引用即可。
  • web模块。Vert.x Web是一个工具集,虽然核心模块提供了HTTP的支持,但是要开发复杂的Web应用,还需要路由、Session、请求数据读取、Rest支持等等还需要Web模块,这里提供了上述的这些功能的API,便于开发,除了对Web服务的开发以外,还提供了对Web客户端请求的支持,通过vertx-web-client即可方便的访问HTTP服务。有朋友可能会有疑惑,我明明可以使用JDK提供的URL来请求HTTP服务啊,使用Vert.x一定要注意,Vert.x是一个异步框架,请求HTTP服务是一个耗时操作,所有的耗时,都会阻塞Event Bus,导致整体性能被拖垮,因此,对于请求Web服务,一定要使用Vert.x提供的vertx-web-client模块。
  • 数据访问模块:Vert.x提供了对关系型数据库、NoSQL、消息中间件的支持,传统的客户端因为是阻塞的,会严重影响系统的性能,因此Vert.x提供了对以上客户端的异步支持。具体支持的数据访问如下:MongoDB client,JDBC client,SQL common,Redis client,MySQL/PostgreSQLclient。
  • Reactive响应式编程:复杂的异步操作会导致异步回调地狱的产生,看下面的代码,这是我在Vert.x提供的例子中找到的,我们不去管这段代码干了啥,只是看后面的}就很惊讶了,如果操作更为复杂一些,会嵌套的层次更多,通过reactive可以最小化的简化异步回调地狱。
// create a test table
execute(conn.result(), "create table test(id int primary key, name varchar(255))", create -> {
  // start a transaction
  startTx(conn.result(), beginTrans -> {
    // insert some test data
    execute(conn.result(), "insert into test values(1, 'Hello')", insert -> {
      // commit data
      rollbackTx(conn.result(), rollbackTrans -> {
        // query some data
        query(conn.result(), "select count(*) from test", rs -> {
          for (JsonArray line : rs.getResults()) {
            System.out.println(line.encode());
          }
 
          // and close the connection
          conn.result().close(done -> {
            if (done.failed()) {
              throw new RuntimeException(done.cause());
            }
          });
        });
      });
    });
  });
});

再看一个使用Reactive2构建的多步操作的代码,paramCheckStep,insertPayDtlStep,requestStep等等都是异步方法,但这里就很好的处理了异步回调的问题,不再有那么多层的大括号,代码结构也geng

public void scanPay(JsonObject data, Handler<AsyncResult<JsonObject>> resultHandler) {
    paramCheckStep(data) // 参数校验
            .flatMap(this::insertPayDtlStep) // 插入流水
            .flatMap(x -> requestStep(x, config)) // 请求上游
            .flatMap(this::cleanStep) //参数清理
            .subscribe(ok -> {
                        logger.info("成功结束");
                        resultHandler.handle(Future.succeededFuture(ok));
                    },
                    err -> {
                        logger.error("正在结束", err);
                        resultHandler.handle(Future.failedFuture(err));
                    }
 
            );
}
  • 整合其他模块
    • 邮件客户端。Vert.x提供了一简单STMP邮件客户端,所以你可以在应用程序中发送电子邮件。
    • STOMP客户端与服务端。Vert.x提供了STOMP协议的实现包括客户端与服务端。
    • Consul Client。consul是google开源的一个使用go语言开发的服务发现、配置管理中心服务。内置了服务注册与发现框 架、分布一致性协议实现、健康检查、Key/Value存储、多数据中心方案。
    • RabbitMQ Client Kafka Client。消息队里的客户端支持。
    • JCA适配器。Vert.x提供了Java连接器架构适配器,这允许同任意JavaEE应用服务器进行互操作。
  • 认证与授权:Vert.x提供了简单API用于在应用中提供认证和授权。
    • Auth common 通用的认证API,可以通过重写AuthProvider类来实现自己的认证。
    • JDBC auth 后台为JDBC的认证实现。
    • JWT auth 用JSON Web tokens认证实现。
    • Shiro auth 使用Apache Shiro认证实现。
    • MongoDB auth MongoDB认证实现。
    • OAuth 2 Oauth2协义认证实现。
    • htdigest auth 这个是新增一种认证的支持
  • 微服务:Vert.x提供多个组件构建基于微服务的应用程序。比如服务发现(Vert.x Service Discovery)、断路器(Vert.x Circuit Breaker)、配置中心(Vert.x Config)等。

五、快速体验:搭建一个简单的Vertx项目并输出Hello World

首先新建一个Maven项目,然后在pom.xml中加入相关的依赖和插件,如下:

<?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>org.example</groupId>
    <artifactId>vertxone</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <vertx.version>4.0.0</vertx.version>
        <main.class>org.example.Main</main.class>
    </properties>

    <dependencies>
        <dependency>
            <groupId>io.vertx</groupId>
            <artifactId>vertx-core</artifactId>
            <version>${vertx.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.4</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <manifestEntries>
                                        <Main-Class>${main.class}</Main-Class>
                                    </manifestEntries>
                                </transformer>
                            </transformers>
                            <artifactSet/>
                            <outputFile>${project.build.directory}/${project.artifactId}-${project.version}-prod.jar</outputFile>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

跟其它Maven项目一样,我们首先定义了项目的GroupId,ArtifactId以及版本号,随后我们定义了两个属性,分别是:vertx.version,也就是Vert.x的版本号,此处我们使用最新的Vert.x版本,也就是4.4.0;以及main.class,也就是我们要使用的包含有main函数的主类。之后我们引入了两个Maven插件,分别是maven-compiler-plugin和maven-shade-plugin,前者用来将.java的源文件编译成.class的字节码文件,后者可将编译后的.class字节码文件打包成可执行的jar文件,俗称fat-jar。
然后我们在src/main/java/org/example目录下新建两个java文件,分别是Main.java和MyFirstVerticle.java,代码如下:

Main.java

package org.example;

import io.vertx.core.Vertx;

/**
 * @author dxm
 * @description
 * @ClassName
 * @date 2023-03-14 15:19
 */
public class Main {
    public static void main(String[] args) {
        Vertx vertx = Vertx.vertx();
        vertx.deployVerticle(MyFirstVerticle.class.getName());
    }
}

MyFirstVerticle.java

package org.example;

import io.vertx.core.AbstractVerticle;

/**
 * @author dxm
 * @description
 * @ClassName
 * @date 2023-03-14 15:25
 */
public class MyFirstVerticle extends AbstractVerticle {

    public void start() {
        vertx.createHttpServer().requestHandler(req -> {
            req.response()
                    .putHeader("content-type", "text/plain")
                    .end("Hello World222!");
        }).listen(8080);
    }
}

然后用Maven的mvn package命令打包,随后在src的同级目录下会出现target目录,进入之后,会出现vertxone-1.0-SNAPSHOT.jar和vertxone-1.0-SNAPSHOT-prod.jar两个jar文件,后者是可执行文件,在有图形界面的操作系统中,您可双击执行或者用以下命令:java -jar vertxone-1.0-SNAPSHOT-prod.jar执行,然后打开浏览器,在浏览器的地址栏中输入:http://localhost:8080/ 便可看到熟悉的Hello World!啦。
在这里插入图片描述
我们也可以使用Launcher来替代Main类,这也是官方推荐的方式,在pom.xml中加入main.verticle属性,并将该属性值设置为maven-shade-plugin插件的manifestEntries的Main-Verticle对应的值,最后修改main.class为io.vertx.core.Launcher,修改后的pom.xml如下:

<?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>org.example</groupId>
    <artifactId>vertxone</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <vertx.version>4.0.0</vertx.version>
        <main.class>io.vertx.core.Launcher</main.class>
        <main.verticle>org.example.MainVerticle</main.verticle>
    </properties>

    <dependencies>
        <dependency>
            <groupId>io.vertx</groupId>
            <artifactId>vertx-core</artifactId>
            <version>${vertx.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.4</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <manifestEntries>
                                        <Main-Class>${main.class}</Main-Class>
                                        <Main-Verticle>${main.verticle}</Main-Verticle>
                                    </manifestEntries>
                                </transformer>
                            </transformers>
                            <artifactSet/>
                            <outputFile>${project.build.directory}/${project.artifactId}-${project.version}-prod.jar</outputFile>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>

</project>

然后在src/main/java/org/example目录下新增MainVerticle.java文件,代码如下:

package org.example;

import io.vertx.core.AbstractVerticle;

/**
 * @author dxm
 * @description
 * @ClassName
 * @date 2023-03-14 3:48 PM
 */
public class MainVerticle extends AbstractVerticle {

    public void start() throws Exception {
       vertx.deployVerticle(MyFirstVerticle.class.getName());
    }
}

然后重新打包后执行,便可再次看到Hello World!。

六、单元测试

下面我们将会介绍测试部分,首先引入两个新的测试依赖,修改后的pom.xml如下:

<?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>org.example</groupId>
    <artifactId>vertxone</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <vertx.version>4.0.0</vertx.version>
        <main.class>io.vertx.core.Launcher</main.class>
        <main.verticle>org.example.MainVerticle</main.verticle>
    </properties>

    <dependencies>
        <dependency>
            <groupId>io.vertx</groupId>
            <artifactId>vertx-core</artifactId>
            <version>${vertx.version}</version>
        </dependency>

        <dependency>
            <groupId>io.vertx</groupId>
            <artifactId>vertx-unit</artifactId>
            <version>${vertx.version}</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.3</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>

            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>3.2.4</version>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <manifestEntries>
                                        <Main-Class>${main.class}</Main-Class>
                                        <Main-Verticle>${main.verticle}</Main-Verticle>
                                    </manifestEntries>
                                </transformer>

                                <!--多语言支持在打包时需加入以下转换器-->
                                <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
                                    <resource>META-INF/services/io.vertx.core.spi.VerticleFactory</resource>
                                </transformer>
                                
                            </transformers>
                            <artifactSet/>
                            <outputFile>${project.build.directory}/${project.artifactId}-${project.version}-prod.jar</outputFile>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

随后在src/test/java/org/example目录下新增MyFirstVerticleTest.java文件:

package org.example;
import io.vertx.core.Vertx;
import io.vertx.ext.unit.Async;
import io.vertx.ext.unit.TestContext;
import io.vertx.ext.unit.junit.VertxUnitRunner;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;

/**
 * @author dxm
 * @description
 * @ClassName
 * @date 2023-03-14 3:56 PM
 */
@RunWith(VertxUnitRunner.class)
public class MyFirstVerticleTest {
    private Vertx vertx;

    @Before
    public void setUp(TestContext context){
        vertx = Vertx.vertx();
        vertx.deployVerticle(MyFirstVerticle.class.getName(), context.asyncAssertSuccess());
    }

    @After
    public void tearDown(TestContext context) {
        vertx.close(context.asyncAssertSuccess());
    }

    @Test
    public void testApplication(TestContext context) {
        final Async async = context.async();

        vertx.createHttpClient().getNow(8080, "localhost", "/", response -> {
            response.handler(body -> {
                context.assertTrue(body.toString().contains("Hello"));
                async.complete();
            });
        });
    }
}

执行该测试案例便可得到期望的结果,有兴趣的可以练习一下。

总结

最后呢,我想说咱程序员不能只会一种语言,开发框架也不能只知道Spring,也得去了解学习接触一些其他的框架,拓展自己的知识面,在后面解决问题的时候,你就会发现,书到用时方恨少,所以还是要在日常进行不断的积累和总结,然后在适当的场景下选择合适的技术选型来解决问题,适合自己的才是最好的,最后给大家布置一个作业,就是结合自己现在的项目结构分层写一下增删改查的接口,感兴趣的你,赶紧去试试吧。

  • 6
    点赞
  • 18
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
### 回答1: Vertx是一种基于事件驱动的应用程序框架,而MyBatis是一种流行的Java持久层框架。Vertx是轻量级的,可扩展的,适用于构建高性能的网络应用程序,而MyBatis则提供了一种优雅的方法来管理应用程序与数据库之间的交互。 Vertx与MyBatis的结合可以在构建Web应用程序时提供更好的开发体验和性能。Vertx通过异步IO和事件驱动的方式,可以快速地处理来自Web客户端的请求。而MyBatis可以通过提供有针对性的SQL语句,方便地对数据库进行操作。 Vertx提供了一个轻量级的Web服务器,可以处理HTTP请求和Websocket连接。而MyBatis可以方便地将数据库查询结果映射为Java对象。通过使用Vertx和MyBatis,我们可以将数据库查询和处理请求的逻辑解耦,使代码更易于理解和维护。 使用Vertx和MyBatis的组合,我们可以轻松地构建可扩展的,高性能的Web应用程序。我们可以使用Vertx的事件总线机制来处理不同组件之间的消息传递,同时利用MyBatis的缓存机制提高数据库查询的性能。 总的来说,Vertx和MyBatis是一对强大的组合,可以帮助我们构建高性能、可扩展的Web应用程序。通过将异步事件驱动的编程模型与优雅的数据库交互方式结合起来,我们可以更轻松地开发复杂的应用程序。 ### 回答2: Vert.x是一个基于JVM的高性能、非阻塞、事件驱动的应用框架,它可以用于构建轻量级、可伸缩、可扩展的分布式系统。而MyBatis是一个流行的Java持久化框架,它能够帮助我们方便地进行数据库访问。 Vert.x和MyBatis可以结合使用,以实现高效的数据库访问和处理。通常情况下,我们可以使用Vert.x的事件驱动机制来处理Web请求,而MyBatis则用于执行数据库操作。 首先,我们可以使用Vert.x的路由器来处理HTTP请求,并在请求处理程序中调用MyBatis执行数据库查询或更新操作。通过这种方式,我们可以确保数据库的访问是非阻塞的,避免了阻塞其他请求的情况发生。 其次,Vert.x的事件总线机制可以用于将不同模块之间的消息进行传递和处理。我们可以在MyBatis的映射器接口中定义观察者,当数据库发生变化时,MyBatis会向事件总线发布消息,其他模块可以根据需求来订阅这些消息进行相应的处理。 另外,Vert.x的异步特性与MyBatis的异步API结合使用,可以进一步提升应用程序的性能。我们可以使用Vert.x的异步回调机制来执行MyBatis的异步数据库操作,从而避免线程阻塞和资源浪费。 总而言之,Vert.x和MyBatis的结合使用可以为我们提供一个高性能、可伸缩的应用程序架构。通过将事件驱动的非阻塞处理与灵活的数据库访问相结合,我们可以构建出更好的分布式系统。 ### 回答3: Vertx是一个开源的、响应式的应用程序平台,可用于构建高性能、可伸缩的微服务和分布式系统。MyBatis是一个Java持久层框架,用于管理数据库访问,并且可以将数据库操作与应用程序逻辑分离。那么,Vertx和MyBatis可以结合使用吗? 答案是可以的。Vertx提供了异步的、非阻塞的I/O操作,而MyBatis则可以将I/O操作,例如数据库查询和更新,封装成简洁易用的API。Vertx和MyBatis的结合可以提供高效的数据库访问和管理,并且保持系统的响应性和可伸缩性。 在Vertx中使用MyBatis非常简单。首先,需要在Vertx应用程序的依赖中添加MyBatis的库。然后,可以通过MyBatis的配置文件来配置数据库连接和SQL映射。接下来,可以在Vertx的事件处理器中使用MyBatis的API来执行数据库操作。 在Vertx中使用MyBatis可以享受到Vertx的优势,例如事件驱动的架构和高性能的I/O操作。此外,Vertx还提供了丰富的异步编程模型和工具,可以方便地与MyBatis结合使用,例如使用Vertx的Future和Promise来处理异步的数据库操作结果。 总而言之,Vertx和MyBatis的结合可以提供高效的数据库访问和管理,并且保持系统的响应性和可伸缩性。这是一种强大的组合,可以用于构建高性能、可伸缩的微服务和分布式系统。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值