Start

Hello World

欢迎来到Vert.x的世界，相信您在接触Vert.x的同时，迫不及待想动手试一试，如您在学习计算机其它知识一样，总是从Hello World开始，下面我们将引导您制作一个最基本简单的Hello World例子，但在此之前，我们需要您具备有以下基础知识：

  1. Java基础知识，您不需要了解Java EE或者是Java ME的知识，但是需要您对Java有所了解，在此文档中，我们不会介绍任何关于Java SE又称Core Java的知识点。请注意：Vert.x 3以上版本需要Java 8以上版本方能运行；

  2. Maven相关知识，您需要知道什么Maven是做什么用的，以及如何使用Maven；

  3. 互联网的基础知识，知道什么是网络协议，尤其是TCP，HTTP协议。

本文将会建立一个基本的HTTP服务器，并监听8080端口，对于任何发往该服务器以及端口的请求，服务器会返回一个Hello World字符串。

首先新建一个Maven项目，一个基本的Maven项目目录结构如下所示：

  1. ├── pom.xml
  2. ├── src
  3. │   ├── main
  4. │   │   ├── java
  5. │   │   └── resources
  6. │   └── test
  7. │       └── java

随后在pom.xml中加入相关的依赖和插件，如下所示：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>io.example</groupId>
  8.     <artifactId>vertx-example</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <properties>
  12.         <vertx.version>3.4.2</vertx.version>
  13.         <main.class>io.example.Main</main.class>
  14.     </properties>
  16.     <dependencies>
  17.         <dependency>
  18.             <groupId>io.vertx</groupId>
  19.             <artifactId>vertx-core</artifactId>
  20.             <version>${vertx.version}</version>
  21.         </dependency>
  22.     </dependencies>
  24.     <build>
  25.         <plugins>
  26.             <plugin>
  27.                 <artifactId>maven-compiler-plugin</artifactId>
  28.                 <version>3.3</version>
  29.                 <configuration>
  30.                     <source>1.8</source>
  31.                     <target>1.8</target>
  32.                 </configuration>
  33.             </plugin>
  35.             <plugin>
  36.                 <groupId>org.apache.maven.plugins</groupId>
  37.                 <artifactId>maven-shade-plugin</artifactId>
  38.                 <version>2.4.2</version>
  39.                 <executions>
  40.                     <execution>
  41.                         <phase>package</phase>
  42.                         <goals>
  43.                             <goal>shade</goal>
  44.                         </goals>
  45.                         <configuration>
  46.                             <transformers>
  47.                                 <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
  48.                                     <manifestEntries>
  49.                                         <Main-Class>${main.class}</Main-Class>
  50.                                     </manifestEntries>
  51.                                 </transformer>
  52.                             </transformers>
  53.                             <artifactSet />
  54.                             <outputFile>${project.build.directory}/${project.artifactId}-${project.version}-prod.jar</outputFile>
  55.                         </configuration>
  56.                     </execution>
  57.                 </executions>
  58.             </plugin>
  59.         </plugins>
  60.     </build>
  61. </project>

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

然后我们在src/main/java/io/example目录下新建两个java文件，分别是Main.java和MyFirstVerticle.java，代码如下：

Main.java

  1. package io.example;
  3. import io.vertx.core.Vertx;
  5. /**
  6.  * Created by chengen on 26/04/2017.
  7.  */
  8. public class Main {
  9.     public static void main(String[] args){
  10.         Vertx vertx = Vertx.vertx();
  12.         vertx.deployVerticle(MyFirstVerticle.class.getName());
  13.     }
  14. }

MyFirstVerticle.java

  1. package io.example;
  3. import io.vertx.core.AbstractVerticle;
  5. /**
  6.  * Created by chengen on 26/04/2017.
  7.  */
  8. public class MyFirstVerticle extends AbstractVerticle {
  9.     public void start() {
  10.         vertx.createHttpServer().requestHandler(req -> {
  11.             req.response()
  12.                     .putHeader("content-type", "text/plain")
  13.                     .end("Hello World!");
  14.         }).listen(8080);
  15.     }
  16. }

然后用Maven的mvn package命令打包，随后在src的同级目录下会出现target目录，进入之后，会出现vert-example-1.0-SNAPSHOT.jar和vert-example-1.0-SNAPSHOT-prod.jar两个jar文件，后者是可执行文件，在有图形界面的操作系统中，您可双击执行，或者用以下命令：java -jar vert-example-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如下：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>io.example</groupId>
  8.     <artifactId>vertx-example</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <properties>
  12.         <vertx.version>3.4.2</vertx.version>
  13.         <main.class>io.vertx.core.Launcher</main.class>
  14.         <main.verticle>io.example.MainVerticle</main.verticle>
  15.     </properties>
  17.     <dependencies>
  18.         <dependency>
  19.             <groupId>io.vertx</groupId>
  20.             <artifactId>vertx-core</artifactId>
  21.             <version>${vertx.version}</version>
  22.         </dependency>
  23.     </dependencies>
  25.     <build>
  26.         <plugins>
  27.             <plugin>
  28.                 <artifactId>maven-compiler-plugin</artifactId>
  29.                 <version>3.3</version>
  30.                 <configuration>
  31.                     <source>1.8</source>
  32.                     <target>1.8</target>
  33.                 </configuration>
  34.             </plugin>
  36.             <plugin>
  37.                 <groupId>org.apache.maven.plugins</groupId>
  38.                 <artifactId>maven-shade-plugin</artifactId>
  39.                 <version>2.4.2</version>
  40.                 <executions>
  41.                     <execution>
  42.                         <phase>package</phase>
  43.                         <goals>
  44.                             <goal>shade</goal>
  45.                         </goals>
  46.                         <configuration>
  47.                             <transformers>
  48.                                 <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
  49.                                     <manifestEntries>
  50.                                         <Main-Class>${main.class}</Main-Class>
  51.                                         <Main-Verticle>${main.verticle}</Main-Verticle>
  52.                                     </manifestEntries>
  53.                                 </transformer>
  54.                             </transformers>
  55.                             <artifactSet />
  56.                             <outputFile>${project.build.directory}/${project.artifactId}-${project.version}-prod.jar</outputFile>
  57.                         </configuration>
  58.                     </execution>
  59.                 </executions>
  60.             </plugin>
  61.         </plugins>
  62.     </build>
  63. </project>

然后在src/main/java/io/example目录下新增MainVerticle.java文件，代码如下：

  1. package io.example;
  3. import io.vertx.core.AbstractVerticle;
  5. /**
  6.  * Created by chengen on 26/04/2017.
  7.  */
  8. public class MainVerticle extends AbstractVerticle {
  9.     public void start() {
  10.         vertx.deployVerticle(MyFirstVerticle.class.getName());
  11.     }
  12. }

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

请注意：重新打包之前，您可能需要清除之前编译后留下的文件，用mvn clean package命令打包。

测试

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

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  5.     <modelVersion>4.0.0</modelVersion>
  7.     <groupId>io.example</groupId>
  8.     <artifactId>vertx-example</artifactId>
  9.     <version>1.0-SNAPSHOT</version>
  11.     <properties>
  12.         <vertx.version>3.4.2</vertx.version>
  13.         <main.class>io.vertx.core.Launcher</main.class>
  14.         <main.verticle>io.example.MainVerticle</main.verticle>
  15.     </properties>
  17.     <dependencies>
  18.         <dependency>
  19.             <groupId>io.vertx</groupId>
  20.             <artifactId>vertx-core</artifactId>
  21.             <version>${vertx.version}</version>
  22.         </dependency>
  24.         <dependency>
  25.             <groupId>io.vertx</groupId>
  26.             <artifactId>vertx-unit</artifactId>
  27.             <version>${vertx.version}</version>
  28.             <scope>test</scope>
  29.         </dependency>
  31.         <dependency>
  32.             <groupId>junit</groupId>
  33.             <artifactId>junit</artifactId>
  34.             <version>4.12</version>
  35.             <scope>test</scope>
  36.         </dependency>
  37.     </dependencies>
  39.     <build>
  40.         <plugins>
  41.             <plugin>
  42.                 <artifactId>maven-compiler-plugin</artifactId>
  43.                 <version>3.3</version>
  44.                 <configuration>
  45.                     <source>1.8</source>
  46.                     <target>1.8</target>
  47.                 </configuration>
  48.             </plugin>
  50.             <plugin>
  51.                 <groupId>org.apache.maven.plugins</groupId>
  52.                 <artifactId>maven-shade-plugin</artifactId>
  53.                 <version>2.4.2</version>
  54.                 <executions>
  55.                     <execution>
  56.                         <phase>package</phase>
  57.                         <goals>
  58.                             <goal>shade</goal>
  59.                         </goals>
  60.                         <configuration>
  61.                             <transformers>
  62.                                 <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
  63.                                     <manifestEntries>
  64.                                         <Main-Class>${main.class}</Main-Class>
  65.                                         <Main-Verticle>${main.verticle}</Main-Verticle>
  66.                                     </manifestEntries>
  67.                                 </transformer>
  69.                                 <!--多语言支持在打包时需加入以下转换器-->
  70.                                 <transformer implementation="org.apache.maven.plugins.shade.resource.AppendingTransformer">
  71.                                     <resource>META-INF/services/io.vertx.core.spi.VerticleFactory</resource>
  72.                                 </transformer>
  74.                             </transformers>
  75.                             <artifactSet />
  76.                             <outputFile>${project.build.directory}/${project.artifactId}-${project.version}-prod.jar</outputFile>
  77.                         </configuration>
  78.                     </execution>
  79.                 </executions>
  80.             </plugin>
  81.         </plugins>
  82.     </build>
  83. </project>

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

  1. package io.example;
  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;
  12. /**
  13.  * Created by chengen on 26/04/2017.
  14.  */
  15. @RunWith(VertxUnitRunner.class)
  16. public class MyFirstVerticleTest {
  18.     private Vertx vertx;
  20.     @Before
  21.     public void setUp(TestContext context) {
  22.         vertx = Vertx.vertx();
  23.         vertx.deployVerticle(MyFirstVerticle.class.getName(), context.asyncAssertSuccess());
  24.     }
  26.     @After
  27.     public void tearDown(TestContext context) {
  28.         vertx.close(context.asyncAssertSuccess());
  29.     }
  31.     @Test
  32.     public void testApplication(TestContext context) {
  33.         final Async async = context.async();
  35.         vertx.createHttpClient().getNow(8080, "localhost", "/", response -> {
  36.             response.handler(body -> {
  37.                 context.assertTrue(body.toString().contains("Hello"));
  38.                 async.complete();
  39.             });
  40.         });
  41.     }
  42. }

执行该测试案例便可得到期望的结果，理解测试代码并不难，留给读者作为练习。

至此，大功告成，欢迎来到Vert.x的世界。