Microservices are the go-to architecture in most new, modern software solutions. They are (mostly) designed to do one thing, and they must talk to each other to accomplish a business use-case. All communication between the microservices is via network calls; this pattern avoids tight coupling between services and provides better separation between them.

There are basically two styles of communication: synchronous and asynchronous. These two styles applied properly are the foundation for request-reply and event-driven patterns. In the case of the request-reply pattern, a client initiates a request and typically waits synchronously for the reply. However, there are cases where the client could decide not to wait and register a callback with the other party, which is an example of the request-reply pattern in an asynchronous fashion.



In this article, I am showcasing the approach of asynchronous request-reply by having two services communicate with each other over Advanced Message Queuing Protocol (AMQP). AMQP is an open standard for passing business messages between applications or organizations. Although this article focuses on the request-reply pattern, the same code can be used to develop additional scenarios like event storming. Communicating using an asynchronous model can be very beneficial for implementing the aggregator pattern.

I will be using Apache QPid Proton (or Red Hat AMQ Interconnect) as the message router and the Vert.x AMQP bridge for communication between the two services.


我会使用Apache QPid Proton(或Red Hat AMQ Interconnect)作为消息路由器和使用Vert.x AMQP桥接器,用于两种服务之间的通信。

Solution components

This demo has three components:

  1. frontend: This is a service written in Java and provides an HTTP endpoint to receive calls from clients. Upon receiving a request, the frontendservice sends the call to the QPid router and registers a reply handler. The reply handler will be invoked by the Vert.x AMQP bridge when the response is available. The frontend folder in the codebase hosts this project.

  2. QPid router: The frontend process takes the call and posts a message to the QPid queue. Vert.x automatically takes care of adding a correlationId as the message property to identify a response to the original request.

  3. backend: The backend component listens for the message in the call from the QPid router, process it (e.g. doing a calculation or persisting in a database), and sends the response back to the QPid router. The QPid router will then notify the frontend component with the response. The backend folder in the codebase hosts this project.



1.前端:这是一个用Java编写的服务,此服务提供了一个HTTP端点来接收来自客户端的调用。收到请求后,前端服务将调用指令发送到QPid路由器并注册应答处理程序。当响应可用时,Vert.x AMQP桥将调用回复处理程序。代码库中的前端文件夹托管此项目。



Message flow

The basic flow of the messages across different components is as follows. The full details of this flow along with the relative headers can be found here.

  1. The frontend service will send a message to a QPid server and provides a reply handler. Vert.x automatically populates the required headers needed for request-reply communication.

  2. The receiving application, the backend service, consumes the message and sends a reply back to the QPid server. Vert.x populates the required headers needed for request-reply communication.

  3. The QPid server dispatches the reply message to the frontend service’s reply handler. Vert.x bridge handles the invocation of the reply handler automatically.

Clone this GitHub repo to get the example code.



2.前端服务将向QPid服务器发送消息并提供回复处理程序。Vert.x自动填充请求 - 回复通信所需的标头。

3.接收后端服务应用程序,处理该消息并将回复发送回QPid服务器。Vert.x填充请求 - 回复通信所需的标头。


How to run the example: Quickstart

You can use the Docker Compose file to run all three components of this example, by issuing the following command:

docker-compose up

How to run the example: The hard way

This section summarizes how to run each component individually. You need the following software to run them on your laptop.

  1. Docker (for executing the Apache Qpid router)

  2. Open JDK 8 (to compile the frontend and the backend service components)

  3. Maven 3.2 (both services use Maven)

  4. Vegeta as an HTPP client (or you can use your favorite tool for this)


  • Use the following command to start the local QPid router:

docker run -it -p 5672:5672 ceposta/qdr
  • Compile and execute the frontend service:

cd frontend 
mvn clean install
java -jar target/frontend-service-full.jar
  • Compile and execute the backend service:

cd backend 
mvn clean install
java -jar target/backend-service-full.jar


通过发出以下命令,您可以使用Docker Compose文件来运行本例的所有三个组件:

docker-compose up

如何运行示例: 困难的方式


  1. Docker (执行Apache Qpid路由器)

  2. Open JDK 8 (要编译前端和后端服务组件)

  3. Maven 3.2 (两个服务都使用Maven)

  4. Vegeta 作为HTPP客户端(或者您可以使用您最喜欢的工具)


  • 使用下面的命令启动本地的QPid路由器:

docker run -it -p 5672:5672 ceposta/qdr
  • 编译并执行前端服务:

cd frontend 
mvn clean install
java -jar target/frontend-service-full.jar
  • 编译并执行后端服务:

cd backend 
mvn clean install
java -jar target/backend-service-full.jar


Vegeta, an open source tool for HTTP load testing, can be used to post requests to the frontend component.

echo "GET http://localhost:8080/" | ./vegeta attack -duration=60s -rate=50 | tee results.bin | ./vegeta report

Verifying the number of messages and latency

QPid provides an ultra-fast backbone as an asynchronous hub for communication between services. Once you finish testing your application, you can log into the QPid router’s Docker container using its IMAGE ID and run qdstat to see various metrics.

docker exec <container-name> qdstat -c
docker exec <container-name> qdstat -l
docker exec <container-name> qdstat -a



echo "GET http://localhost:8080/" | ./vegeta attack -duration=60s -rate=50 | tee results.bin | ./vegeta report


QPid,作为服务之间通信的异步集线器,提供了超快骨干。一旦完成应用程序测试之后,你可以使用其IMAGE ID登录QPid路由的Docker容器,并运行qdstat以查看各种指标

docker exec <container-name> qdstat -c
docker exec <container-name> qdstat -l
docker exec <container-name> qdstat -a


Apache QPid provides an ultra-fast backbone for communication between microservices. Since AMQP is a wire-level protocol, services written in other stacks (like .NET) can also use the same communication channel. Java developers can easily adapt to the AMQP-based asynchronous inter-services communication pattern using the Vert.x AMQP bridge.


Apache QPid为微服务之间的通信提供了一个超快的主干通讯。由于 AMQP 是一种线级协议,在其他栈(如.net)中编写的服务也可以使用相同的通信通道。Java 开发人员可以使用 Vert.x AMQP birdge 工具轻松实现基于 amqp 的异步服务间通信模式。