Vertx http client & concurrency

See more:

Java

Newbie to vertx: Looking to develop an app that uses vertx http client i'd like to validate the approach used below:

public class RequestInitializer extends BusModBase
{
  
    private EventBus eventBus = null;
    
    private Handler<Message<JsonObject>> httpClientRequestHandler;
    private HttpClient client;

    @Override
    public void start()
    {
   /*------------------------------------------------------------------------
       Create (pool of) HTTP Client
  ---------------------------------------------------------------------------*/
        httpClient = vertx.createHttpClient()
                .setHost(host)
                .setPort(1234)
                .setMaxPoolSize(500);

    /*--------------------------------------------------------------------------------
       Define handler
    --------------------------------------------------------*/
        httpClientRequestHandler = new Handler<Message<JsonObject>>()
        {
            @Override
            public void handle(final Message<JsonObject> message)
            {
                // Received message to build http request
                LOGGER.info("Request |--> " + message.body());
                if(message.body().getBoolean("START_USER_SESSION") == null)
                {
                    message.reply("handler.http.client");
                }

                int req_timeout = Integer.valueOf(1500);
				
                switch (message.body().getString("HTTP_REQUEST_METHOD")
                {
                    case POST_REQUEST:
                    {
                        try
                        {
                            processHttpPostRequest(httpClient, message, req_timeout);
                            break;
                        }
                        catch (BlueWaveException ex)
                        {
                            LOGGER.error(ex.getMessage());
                        }
                    }
                    case GET_REQUEST:
                    {
                        processHttpGetRequest(httpClient, message, req_timeout);
                        break;
                    }
                    case DELETE_REQUEST:
                    {
                        processHttpDeleteRequest(httpClient, message, req_timeout);
                        break;
                    }
                    case PUT_REQUEST:
                    {
                        processHttpPutRequest(httpClient, message, req_timeout);
                        break;
                    }
                }
            }
        };
/*-------------------------------------------------------------------
           Register general handler
------------------------------------------------------------------------*/
        eventBus.registerHandler("HTTP_REQUEST_HANDLER", httpClientRequestHandler);
}

/*-------------------------------------------------------------------
      OR     Register handler per cleint?
------------------------------------------------------------------------*/
        eventBus.registerHandler("request.address", new Handler<Message<JsonObject>>()
        {
            @Override
            public void handle(final Message<JsonObject> request)
            {
                if (request.body().getString("action").toString().equalsIgnoreCase("register"))
                {
                    String requestHandlerAddress = request.body().getString("address") + "REQUEST_HANDLER";
                    eventBus.registerHandler(requestHandlerAddress, httpClientRequestHandler, new Handler<AsyncResult<Void>>()
                    {
                        @Override
                        public void handle(AsyncResult<Void> event)
                        {
                            if(event.succeeded())
                            {
                                LOGGER.info("Request handler successfully registered for: " + request.body().getString("address"));
                            }
                            else
                            {
                                LOGGER.error("Unable to register request handler for: " + request.body().getString("address").toString() + "Reason: " + event.result().toString());
                                // Retry
                            }
                        }
                    });
                }
                
            }
        });

/*------------------------------------------------------------------
           Post request
----------------------------------------------------------------*/
		 private void processHttpPostRequest(HttpClient client, final Message<JsonObject> message, int request_timeout) throws BlueWaveException {
        
        try
        {
            HttpClientRequest request = client.post(message.body().getString("URL"), new Handler <HttpClientResponse> ()
            {
                public void handle(final HttpClientResponse response)
                {
                    response.bodyHandler(new Handler<Buffer>()
                    {
                        public void handle(Buffer responseBody)
                        {
                            // The entire response body has been received from server - send to specified handler address
                            String userID = message.body().getString("USER_ID");
							JsonObject responseObject = constructJsonResponse(response, responseBody.toString(), userID);
							eventBus.send(message.body().getString("REPLY_TO"), responseObject);
							
							// OR The entire response body has been received from server - reply sender
							message.reply(responseObject)
                           
                        }
                    });
                    
            request.end(message.body().getString("REQUEST_BODY"));
        }
        catch (Exception ex)
        {
            LOGGER.error(ex.getMessage());
        }

private JsonObject constructJsonResponse(HttpClientResponse response, String responseBody, String userID)
    {
        JsonObject responseObject = new JsonObject();
        responseObject.putString("RESPONSE_CODE", String.valueOf(response.statusCode()));
        responseObject.putString("RESPONSE_MESSAGE", response.statusMessage());
        responseObject.putString("USER_ID", userID);
        responseObject.putString("HANDLER_ID", "REQUEST_HANDLER");
        responseObject.putString("RESPONSE_BODY", responseBody);
        return responseObject;
    }
}