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

用惯了高大上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我也删除了，最后代码如下：

1. plugins {

2. id 'java'

3. id 'application'

4. id 'com.github.johnrengelman.shadow' version '1.2.3'

5. }

6.  

7. repositories {

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

9. }

10.  

11. sourceCompatibility = '1.8'

12.  

13. dependencies {

14. compile "io.vertx:vertx-core:3.5.0"

15. }

16.  

17. mainClassName = 'io.vertx.example.HelloWorldEmbedded'

18.  

19. shadowJar {

20. classifier = 'fat'

21. mergeServiceFiles {

22. include 'META-INF/services/io.vertx.core.spi.VerticleFactory'

23. }

24. }

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

编写程序

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

1. package com.abc;

2.  

3. import io.vertx.core.AbstractVerticle;

4. import io.vertx.core.Future;

5.  

6. public class Application extends AbstractVerticle {

7.  

8. @Override

9. public void start(Future f) throws Exception {

10. vertx.createHttpServer()

11. .requestHandler(req->{

12. req.response().end("Hello Vert.x");

13. })

14. .listen(8080,result->{

15. if (result.succeeded()){

16. f.complete();

17. }else{

18. f.fail(result.cause());

19. }

20. });

21. }

22.  

23. }

在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端口。

测试代码

添加单元测试所需依赖：

1. dependencies {

2. compile "io.vertx:vertx-core:$version"

3. compile "io.vertx:vertx-unit:$version"

4. compile "junit:junit:4.12"

5. }

编写测试com.abc.ApplicationTest：

1. package com.abc;

2.  

3. import io.vertx.core.Vertx;

4. import io.vertx.ext.unit.Async;

5. import io.vertx.ext.unit.TestContext;

6. import io.vertx.ext.unit.junit.VertxUnitRunner;

7. import org.junit.After;

8. import org.junit.Before;

9. import org.junit.Test;

10. import org.junit.runner.RunWith;

11.  

12. @RunWith(VertxUnitRunner.class)

13. public class ApplicationTest {

14.  

15. //vertx容器

16. private Vertx vertx;

17.  

18. @Before

19. public void setUp(TestContext context) {

20. //创建一个vertx容器的实例

21. vertx = Vertx.vertx();

22. //将Application这个verticle部署到容器中，并注册部署完成的处理器

23. vertx.deployVerticle(Application.class.getName(),

24. context.asyncAssertSuccess());

25. }

26.  

27. @After

28. public void tearDown(TestContext context) {

29. //关闭容器，注册关闭完成的处理器

30. vertx.close(context.asyncAssertSuccess());

31. }

32.  

33. @Test

34. public void testApplication(TestContext context) {

35. final Async async = context.async();

36. //创建一个http客户端，发送请求到http服务端

37. vertx.createHttpClient().getNow(8080, "localhost", "/",

38. response -> {

39. response.handler(body -> {

40. context.assertTrue(body.toString().contains("Hello"));

41. async.complete();

42. });

43. });

44. }

45.  

46. }

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

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

项目打包

修改build.gradle文件：

1. plugins {

2. id 'java'

3. id 'application'

4. id 'com.github.johnrengelman.shadow' version '1.2.3'

5. }

6.  

7. repositories {

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

9. }

10.  

11. sourceCompatibility = '1.8'

12. mainClassName = 'io.vertx.core.Launcher' //<--add

13. def mainVerticleName = 'com.abc.Application'//<--add

14.  

15. dependencies {

16. compile "io.vertx:vertx-core:3.5.0"

17. compile "io.vertx:vertx-unit:3.5.0"

18. compile "junit:junit:4.12"

19. }

20.  

21. shadowJar {

22. classifier = 'fat'

23. manifest { //<--add

24. attributes "Main-Verticle": mainVerticleName

25. }

26. mergeServiceFiles {

27. include 'META-INF/services/io.vertx.core.spi.VerticleFactory'

28. }

29. }

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