用惯了高大上SpringBoot不妨试试小清新Vert.x

Vert.x是一个基于netty的异步的工具集。能够简单理解成运行在JVM上的Node.js。本文是简单的入门教程。

Hello Vert.x

新建项目

在IDEA中新建一个Gradle项目（名为hello）：

从官网github例子中复制build.gradle文件内容，并修改maven仓库url改为国内淘宝镜像的，因为我没有使用gradle wrapper，因此官网build.gradle例子中最后关于wrapper的task我也删除了，最后代码以下：

plugins {
    id 'java'
    id 'application'
    id 'com.github.johnrengelman.shadow' version '1.2.3'
}

repositories {
    maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
}

sourceCompatibility = '1.8'

dependencies {
    compile "io.vertx:vertx-core:3.5.0"
}

mainClassName = 'io.vertx.example.HelloWorldEmbedded'

shadowJar {
    classifier = 'fat'
    mergeServiceFiles {
        include 'META-INF/services/io.vertx.core.spi.VerticleFactory'
    }
}

别忘了修改了build.gradle文件内容以后，须要点击IDEA右边gradle栏目的刷新按钮，以更新项目依赖信息：

编写程序

新增一个类：com.abc.Application，继承vertx的AbstractVerticle抽象类，重写start方法，在方法中编写启动一个服务端的代码：

package com.abc;

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Future;

public class Application extends AbstractVerticle {

    @Override
    public void start(Future<Void> f) throws Exception {
        vertx.createHttpServer()
                .requestHandler(req->{
                    req.response().end("Hello Vert.x");
                })
                .listen(8080,result->{
                    if (result.succeeded()){
                        f.complete();
                    }else{
                        f.fail(result.cause());
                    }
                });
    }

}

在vert.x中，一个verticle就是一个组件。Application继承AbstractVerticle，即Application是一个组件。从代码中能够看到，Application用到了父类提供的vertx成员。vertx成员提供建立服务端的方法。

start方法会在verticle部署的时候执行。start方法实际上是一个回调方法，它能够有一个Future类型的参数（io.vertx包的），该参数能够用来通知Vertx当前这个verticle的start方法是否执行成功。因为Vert.x是异步非阻塞的，因此verticle部署的时候，不会等待start方法执行结束，所以才须要一个Future类型的参数来通知Vert.x执行是否成功。

在start方法中，咱们建立了一个http服务端，并注册了请求处理器（requestHandler），顾名思义，请求处理器中的方法会在每次请求到来时执行。最后，让该http服务端监听8080端口。

测试代码

添加单元测试所需依赖：

dependencies {
    compile "io.vertx:vertx-core:$version"
    compile "io.vertx:vertx-unit:$version"
    compile "junit:junit:4.12"
}

编写测试com.abc.ApplicationTest：

package com.abc;

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;

@RunWith(VertxUnitRunner.class)
public class ApplicationTest {

    //vertx容器
    private Vertx vertx;

    @Before
    public void setUp(TestContext context) {
        //建立一个vertx容器的实例
        vertx = Vertx.vertx();
        //将Application这个verticle部署到容器中，并注册部署完成的处理器
        vertx.deployVerticle(Application.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();
        //建立一个http客户端，发送请求到http服务端
        vertx.createHttpClient().getNow(8080, "localhost", "/",
                response -> {
                    response.handler(body -> {
                        context.assertTrue(body.toString().contains("Hello"));
                        async.complete();
                    });
                });
    }

}

上面的测试代码用到了vertx-unit模块，该模块是用来测试异步的代码的。在setUp方法中，咱们建立了一个vertx容器，并部署Application这个verticle到容器中（部署时会执行Application类的start方法）。setUp方法有一个TestContext参数，是用来控制异步代码的。当部署verticle时，verticle的start方法异步执行。所以将context.asyncAssertSuccess()（一个Handler<AsyncResult>）传入到deployVerticle方法中，那么deployVerticle方法执行成功或失败，都会有与这个Handler来执行对应的操做。

在testApplication方法中，因为发送请求和接收请求的过程是异步的，因此咱们建立了一个Async处理器，并在收到响应的回调中执行async.complete()来通知测试的上下文该单元测试完成了。

项目打包

修改build.gradle文件：

plugins {
    id 'java'
    id 'application'
    id 'com.github.johnrengelman.shadow' version '1.2.3'
}

repositories {
    maven { url 'http://maven.aliyun.com/nexus/content/groups/public/' }
}

sourceCompatibility = '1.8'
mainClassName = 'io.vertx.core.Launcher' //<--add
def mainVerticleName = 'com.abc.Application'//<--add

dependencies {
    compile "io.vertx:vertx-core:3.5.0"
    compile "io.vertx:vertx-unit:3.5.0"
    compile "junit:junit:4.12"
}

shadowJar {
    classifier = 'fat'
    manifest {  //<--add
        attributes "Main-Verticle": mainVerticleName
    }
    mergeServiceFiles {
        include 'META-INF/services/io.vertx.core.spi.VerticleFactory'
    }
}

执行gradle shadowJar命令打包。运行打包出来的Jar包，而后浏览器输入127.0.0.1:8080访问便可看到响应的内容。