Partner – Microsoft – NPI (cat= Spring)
announcement - icon

Azure Spring Apps is a fully managed service from Microsoft (built in collaboration with VMware), focused on building and deploying Spring Boot applications on Azure Cloud without worrying about Kubernetes.

And, the Enterprise plan comes with some interesting features, such as commercial Spring runtime support, a 99.95% SLA and some deep discounts (up to 47%) when you are ready for production.

>> Learn more and deploy your first Spring Boot app to Azure.

You can also ask questions and leave feedback on the Azure Spring Apps GitHub page.

1. Overview

In this quick article, we’ll discuss the integration of Spring with Vert-x and leverage the best of both worlds: the powerful and well-known Spring feature, and the reactive single-event loop from Vert.x.

To understand more about Vert.x, please refer to our introductory article here.

2. Setup

First, let’s get our dependencies in place:

    <version>3.<span class="x x-first x-last">9.15</span></version>

Notice that we’ve excluded the embedded Tomcat dependency from spring-boot-starter-web since we are going to deploy our services using verticles.

You may find the latest dependencies here.

3. Spring Vert.x Application

Now, we’ll build a sample application with two verticles deployed.

The first Verticle routes requests to the handler that sends them as messages to the given address. The other Verticle listens at a given address.

Let’s look at these in action.

3.1. Sender Verticle

ServerVerticle accepts HTTP requests and sends them as messages to a designated address. Let’s create a ServerVerticle class extending the AbstractVerticle, and override the start() method to create our HTTP Server:

public void start() throws Exception {

    Router router = Router.router(vertx);

      .listen(config().getInteger("http.port", 8080));

In the server request handler, we passed a router object, which redirects any incoming request to the getAllArticlesHandler handler:

private void getAllArticlesHandler(RoutingContext routingContext) {
    vertx.eventBus().<String>send(ArticleRecipientVerticle.GET_ALL_ARTICLES, "", 
      result -> {
        if (result.succeeded()) {
              .putHeader("content-type", "application/json")
        } else {

In the handler method, we’re passing an event to the Vert.x Event bus, with an event id as GET_ALL_ARTICLES. Then we process the callback accordingly for success and error scenarios.

The message from the event bus will be consumed by the ArticleRecipientVerticle, discussed in the following section.

3.2. Recipient Verticle

ArticleRecipientVerticle listens for incoming messages and injects a Spring bean. It acts as the rendezvous point for Spring and Vert.x.

We’ll inject Spring service bean into a Verticle and invoke respective methods:

public void start() throws Exception {

Here, articleService is an injected Spring bean:

private ArticleService articleService;

This Verticle will keep listening to the event bus on an address GET_ALL_ARTICLES. Once it receives a message, it delegates it to the getAllArticleService handler method:

private Handler<Message<String>> getAllArticleService(ArticleService service) {
    return msg -> vertx.<String> executeBlocking(future -> {
        try {
        } catch (JsonProcessingException e) {
    }, result -> {
        if (result.succeeded()) {
        } else {

This performs the required service operation and replies to the message with the status. The message reply is being referenced at the ServerVerticle and the callback result as we saw in the earlier section.

4. Service Class

The service class is a simple implementation, providing methods to interact with the repository layer:

public class ArticleService {

    private ArticleRepository articleRepository;

    public List<Article> getAllArticle() {
        return articleRepository.findAll();

The ArticleRepository extends, and provides basic CRUD functionalities.

5. Deploying Verticles

We will be deploying the application, just the way we would do for a regular Spring Boot application. We have to create a Vert.X instance, and deploy verticles in it, after the Spring context initialization in completed:

public class VertxSpringApplication {

    private ServerVerticle serverVerticle;

    private ArticleRecipientVerticle articleRecipientVerticle;

    public static void main(String[] args) {, args);

    public void deployVerticle() {
        Vertx vertx = Vertx.vertx();

Notice that, we are injecting verticle instances into the Spring application class. So, we will have to annotate the Verticle classes,

So, we will have to annotate the Verticle classes, ServerVerticle and ArticleRecipientVerticle with @Component.

Let’s test the application:

public void givenUrl_whenReceivedArticles_thenSuccess() {
    ResponseEntity<String> responseEntity = restTemplate
      .getForEntity("http://localhost:8080/api/baeldung/articles", String.class);
    assertEquals(200, responseEntity.getStatusCodeValue());

6. Conclusion

In this article, we learned about how to build a RESTful WebService using Spring and Vert.x.

As usual, the example is available over on GitHub.

Course – LS (cat=Spring)

Get started with Spring and Spring Boot, through the Learn Spring course:

res – REST with Spring (eBook) (everywhere)
Comments are open for 30 days after publishing a post. For any issues past this date, use the Contact form on the site.