Въведение в Vert.x

1. Общ преглед

В тази статия ще обсъдим Vert.x, ще разгледаме основните му концепции и ще създадем проста RESTfull уеб услуга с него.

Ще започнем, като обхванем основните концепции за инструментариума, бавно ще преминем към HTTP сървър и след това ще изградим RESTfull услугата.

2. Относно Vert.x

Vert.x е инструментариум за разработка на софтуер с отворен код, реактивен и полиглот от разработчиците на Eclipse.

Реактивното програмиране е програмна парадигма, свързана с асинхронни потоци, които реагират на всякакви промени или събития.

По същия начин Vert.x използва шина за събития, за да комуникира с различни части на приложението и предава събития, асинхронно на манипулаторите, когато са налични.

Ние го наричаме полиглот поради неговата поддръжка за множество JVM и не-JVM езици като Java, Groovy, Ruby, Python и JavaScript.

3. Настройка

За да използваме Vert.x, трябва да добавим зависимостта Maven:

 io.vertx vertx-core 3.4.1 

Най-новата версия на зависимостта може да бъде намерена тук.

3. Вертикали

Verticles са парчета код, които Vert.x двигателят изпълнява. Инструментарият ни предоставя много абстрактни класове на вертикули, които могат да бъдат разширени и внедрени, както искаме.

Като полиглоти, вертикалите могат да се пишат на всеки от поддържаните езици. Приложението обикновено се състои от множество вертикали, работещи в един и същ екземпляр на Vert.x и комуникират помежду си, като използват събития чрез шината на събитията.

За да създаде вертикул в JAVA, класът трябва да реализира интерфейс io.vertx.core.Verticle или някой от неговите подкласове.

4. Bus автобус

Това е нервната система на всяко приложение на Vert.x.

Като реактивни, вертикалите остават бездействащи, докато не получат съобщение или събитие. Вертикалите комуникират помежду си чрез шината на събитието. Съобщението може да бъде всичко - от низ до сложен обект.

Обработката на съобщения е в идеалния случай асинхронна, съобщенията се поставят на опашка към шината на събитията и контролът се връща на подателя. По-късно се отменя в слушалката. Отговорът се изпраща по методите Future и callback .

5. Просто приложение на Vert.x.

Да се създаде приложение прости с вертикална и да го разгърне, като се използва vertx инстанция . За да създадем нашата точка, ще разширим

За да създадем нашия вертикул, ще разширим класа io.vertx.core.AbstractVerticle и ще заменим метода start () :

public class HelloVerticle extends AbstractVerticle { @Override public void start(Future future) { LOGGER.info("Welcome to Vertx"); } }

Методът start () ще бъде извикан от екземпляра на vertx, когато вертикулът бъде разположен. Методът взема io.vertx.core.Future като параметър, който може да се използва за откриване на състоянието на асинхронно разполагане на вертикула.

Сега нека разгърнем вертикула:

public static void main(String[] args) { Vertx vertx = Vertx.vertx(); vertx.deployVerticle(new HelloVerticle()); }

По подобен начин можем да заменим метода stop () от класа AbstractVerticle , който ще бъде извикан при изключване на вертикула:

@Override public void stop() { LOGGER.info("Shutting down application"); }

6. HTTP сървър

Сега нека завъртим HTTP сървър, използвайки вертикул:

@Override public void start(Future future) { vertx.createHttpServer() .requestHandler(r -> r.response().end("Welcome to Vert.x Intro"); }) .listen(config().getInteger("http.port", 9090), result -> { if (result.succeeded()) { future.complete(); } else { future.fail(result.cause()); } }); }

Заменихме метода start () , за да създадем HTTP сървър и прикачихме манипулатор на заявки към него. Методът requestHandler () се извиква всеки път, когато сървърът получи заявка.

И накрая, сървърът е обвързан с порт и манипулатор AsyncResult се предава на метода listen () , независимо дали връзката или стартирането на сървъра са успели с помощта на future.complete () или future.fail () в случай на грешки.

Имайте предвид, че: методът config.getInteger () чете стойността за конфигурация на HTTP порт, която се зарежда от външен файл conf.json .

Нека тестваме нашия сървър:

@Test public void whenReceivedResponse_thenSuccess(TestContext testContext) { Async async = testContext.async(); vertx.createHttpClient() .getNow(port, "localhost", "/", response -> { response.handler(responseBody -> { testContext.assertTrue(responseBody.toString().contains("Hello")); async.complete(); }); }); }

За теста нека използваме vertx-unit заедно с JUnit .:

 io.vertx vertx-unit 3.4.1 test 

Тук можем да получим най-новата версия.

Вертикалът е разположен и в екземпляр на vertx в метода setup () на единичния тест:

@Before public void setup(TestContext testContext) { vertx = Vertx.vertx(); vertx.deployVerticle(SimpleServerVerticle.class.getName(), testContext.asyncAssertSuccess()); }

По същия начин екземплярът на vertx е затворен в метода @AfterClass tearDown () :

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

Забележете, че методът @BeforeClass setup () приема аргумент TestContext . Това помага за контролиране и тестване на асинхронното поведение на теста. Например разгръщането на вертикула е асинхронно, така че основно не можем да тестваме нищо, освен ако не е разгърнато правилно.

We have a second parameter to the deployVerticle() method, testContext.asyncAssertSuccess(). This is used to know if the server is deployed correctly or any failures occurred. It waits for the future.complete() or future.fail() in the server verticle to be called. In the case of a failure, it fails the test.

7. RESTful WebService

We have created an HTTP server, lets now use that to host an RESTfull WebService. In order do so we will need another Vert.x module called vertx-web. This gives a lot of additional features for web development on top of vertx-core.

Let's add the dependency to our pom.xml:

 io.vertx vertx-web 3.4.1 

We can find the latest version here.

7.1. Router and Routes

Let's create a router for our WebService. This router will take a simple route of GET method, and handler method getArtilces():

Router router = Router.router(vertx); router.get("/api/baeldung/articles/article/:id") .handler(this::getArticles);

The getArticle() method is a simple method that returns new Article object:

private void getArticles(RoutingContext routingContext) { String articleId = routingContext.request() .getParam("id"); Article article = new Article(articleId, "This is an intro to vertx", "baeldung", "01-02-2017", 1578); routingContext.response() .putHeader("content-type", "application/json") .setStatusCode(200) .end(Json.encodePrettily(article)); }

A Router, when receives a request, looks for the matching route, and passes the request further. The routes having a handler method associated with it to do sumthing with the request.

In our case, the handler invokes the getArticle() method. It receives the routingContext object as an argument. Derives the path parameter id, and creates an Article object with it.

In the last part of the method, let's invoke the response() method on the routingContext object and put the headers, set the HTTP response code, and end the response using the JSON encoded article object.

7.2. Adding Router to Server

Now let's add the router, created in the previous section to the HTTP server:

vertx.createHttpServer() .requestHandler(router::accept) .listen(config().getInteger("http.port", 8080), result -> { if (result.succeeded()) { future.complete(); } else { future.fail(result.cause()); } });

Notice that we have added requestHandler(router::accept) to the server. This instructs the server, to invoke the accept() of the router object when any request is received.

Now let's test our WebService:

@Test public void givenId_whenReceivedArticle_thenSuccess(TestContext testContext) { Async async = testContext.async(); vertx.createHttpClient() .getNow(8080, "localhost", "/api/baeldung/articles/article/12345", response -> { response.handler(responseBody -> { testContext.assertTrue( responseBody.toString().contains("\"id\" : \"12345\"")); async.complete(); }); }); }

8. Packaging Vert.x Application

To package the application as a deployable Java Archive (.jar) let's use Maven Shade plugin and the configurations in the execution tag:

    io.vertx.core.Starter com.baeldung.SimpleServerVerticle      ${project.build.directory}/${project.artifactId}-${project.version}-app.jar  

In the manifestEntries, Main-Verticle indicates the starting point of the application and the Main-Class is a Vert.x class which, creates the vertx instance and deploys the Main-Verticle.

9. Conclusion

В тази уводна статия обсъдихме инструментариума Vert.x и неговите основни концепции. Видях как да създавам и HTTP сървър, с Vert.x и също така RESTFull WebService и показа как да ги тествам с помощта на vertx-unit .

Накрая опакова приложението като изпълним буркан.

Пълното изпълнение на кодовите фрагменти е достъпно в GitHub.