项目结构：

依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"><modelVersion>4.0.0</modelVersion><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.1.4.RELEASE</version><relativePath/> <!-- lookup parent from repository --></parent><groupId>com.citydo</groupId><artifactId>vertxspringboot</artifactId><version>0.0.1-SNAPSHOT</version><name>vertxspringboot</name><description>Demo project for Spring Boot</description><properties><java.version>1.8</java.version><vertex.version>3.9.1</vertex.version></properties><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-jpa</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId><exclusions><exclusion><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-tomcat</artifactId></exclusion></exclusions></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><dependency><groupId>io.vertx</groupId><artifactId>vertx-core</artifactId><version>${vertex.version}</version></dependency><dependency><groupId>io.vertx</groupId><artifactId>vertx-web</artifactId><version>${vertex.version}</version></dependency><dependency><groupId>io.vertx</groupId><artifactId>vertx-codegen</artifactId><version>${vertex.version}</version></dependency><dependency><groupId>io.vertx</groupId><artifactId>vertx-web-client</artifactId><version>${vertex.version}</version></dependency></dependencies><build><plugins><plugin><groupId>org.springframework.boot</groupId><artifactId>spring-boot-maven-plugin</artifactId></plugin></plugins></build></project>

配置：

spring.datasource.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
spring.datasource.username=root
spring.datasource.password=123456
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.jpa.properties.hibernate.hbm2ddl.auto=update

启动：

package com.citydo.vertxspringboot;import com.citydo.vertxspringboot.verticle.JpaProductVerticle;
import com.citydo.vertxspringboot.verticle.ProductServerVerticle;
import io.vertx.core.Vertx;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;import javax.annotation.PostConstruct;@Slf4j
@SpringBootApplication
public class VertxspringbootApplication {@Autowiredprivate ProductServerVerticle productServerVerticle;@Autowiredprivate JpaProductVerticle jpaProductVerticle;public static void main(String[] args) {SpringApplication.run(VertxspringbootApplication.class, args);}@PostConstructpublic void deployVerticle() {Vertx vertx = Vertx.vertx();vertx.deployVerticle(productServerVerticle);vertx.deployVerticle(jpaProductVerticle);vertx.exceptionHandler(throwable -> log.error("exception happened: {}", throwable.toString()));log.info("verticle deployed!!");}}

package com.citydo.vertxspringboot.verticle;import com.citydo.vertxspringboot.utils.Constants;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.eventbus.EventBus;
import io.vertx.core.http.HttpServerResponse;
import io.vertx.core.json.JsonObject;
import io.vertx.ext.web.Router;
import io.vertx.ext.web.RoutingContext;
import io.vertx.ext.web.handler.BodyHandler;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;/*** @author nick*/
@Slf4j
@Component
public class ProductServerVerticle extends AbstractVerticle {@Overridepublic void start() throws Exception {super.start();Router router = Router.router(vertx);router.route().handler(BodyHandler.create());router.get("/products/:productID").handler(this::handleGetProduct);router.put("/products/:productID").handler(this::handleAddProduct);router.get("/products/").handler(this::handleListProducts);router.delete("/products/:productID").handler(this::handleDeleteProduct);router.patch("/products/:productID").handler(this::handlePatchProduct);vertx.createHttpServer().requestHandler(router).listen(8080);
//                .exceptionHandler(
//                throwable -> log.error("HTTPServer error happened: {}", throwable.toString())
//        );}private void getProductFailureHandler(RoutingContext failureRoutingContext){HttpServerResponse response = failureRoutingContext.response();response.end("something bad happened!");}private void handlePatchProduct(RoutingContext routingContext){String productId = routingContext.request().getParam("productID");log.info("productId used to patch product from request param: {}", productId);if (productId == null) {log.error("GET: the required productId is null!");sendError(400, routingContext.response());return;}JsonObject product = routingContext.getBodyAsJson();vertx.eventBus().<JsonObject>send(Constants.PATCH_PRODUCT_ADDRESS, product, asyncResult -> {log.info("result is: {}", asyncResult.result().body());if (asyncResult.succeeded()) {log.info("handle PATCH_PRODUCT_ADDRESS success!!");routingContext.response().putHeader("content-type", "application/json").setStatusCode(200).end(String.valueOf(asyncResult.result().body()));} else {log.info("handle PATCH_PRODUCT_ADDRESS failed!!");routingContext.response().setStatusCode(500).end();}});}private void handleDeleteProduct(RoutingContext routingContext){Integer productId = Integer.valueOf(routingContext.request().getParam("productID"));log.info("productId from request param: {}", productId);vertx.eventBus().<Integer>send(Constants.DELETE_PRODUCT_ADDRESS, productId, result -> {log.info("result is: {}", result.result().body());if (result.succeeded()) {log.info("handle DELETE_PRODUCT_ADDRESS success!!");routingContext.response().putHeader("content-type", "application/json").setStatusCode(200).end(String.valueOf(result.result().body()));} else {log.info("handle DELETE_PRODUCT_ADDRESS failed!!");routingContext.response().setStatusCode(500).end();}});}private void handleGetProduct(RoutingContext routingContext) {String productId = routingContext.request().getParam("productID");if (productId == null) {log.error("GET: the required productId is null!");sendError(400, routingContext.response());return;}vertx.eventBus().<String>send(Constants.GET_ONE_PRODUCT_ADDRESS, productId, asyncResult -> {log.info("Got one product by productId: {}", asyncResult);if (asyncResult.succeeded()) {String body = asyncResult.result().body();if ("null".equals(body)){log.info("No product found by the given productId: {}", productId);routingContext.response().setStatusCode(404).end();}else {log.info("handle GET_ONE_PRODUCT_ADDRESS success!!");routingContext.response().putHeader("content-type", "application/json").setStatusCode(200).end(body);}} else {log.info("handle GET_ONE_PRODUCT_ADDRESS failed!!");routingContext.response().setStatusCode(500).end();}});}private void handleAddProduct(RoutingContext routingContext) {String productID = routingContext.request().getParam("productID");if (productID == null) {log.error("PUT: the productId is null!");sendError(400, routingContext.response());return;}JsonObject product = routingContext.getBodyAsJson();vertx.eventBus().<JsonObject> send(Constants.ADD_PRODUCT_ADDRESS, product, asyncResult -> {log.info("added one product: {}", asyncResult);if (asyncResult.succeeded()) {log.info("handle ADD_PRODUCT_ADDRESS success!!");routingContext.response().putHeader("content-type", "application/json").setStatusCode(200).end(asyncResult.result().body().toString());} else {log.info("handle ADD_PRODUCT_ADDRESS failed!!");routingContext.response().setStatusCode(500).end();}});}private void handleListProducts(RoutingContext routingContext) {EventBus eventBus = vertx.eventBus();eventBus.<String>send(Constants.ALL_PRODUCTS_ADDRESS, "", asyncResult -> {log.info("result is: {}", asyncResult.result().body());if (asyncResult.succeeded()) {log.info("handle  ALL_PRODUCTS_ADDRESS success!!");routingContext.response().putHeader("content-type", "application/json").setStatusCode(200).end(asyncResult.result().body());} else {log.info("handle ALL_PRODUCTS_ADDRESS failed!!");routingContext.response().setStatusCode(500).end();}});log.info("ALL_PRODUCTS_ADDRESS Event already sent!");}private void sendError(int statusCode, HttpServerResponse response) {response.setStatusCode(statusCode).end();}
}

package com.citydo.vertxspringboot.verticle;import com.citydo.vertxspringboot.dto.ProductResult;
import com.citydo.vertxspringboot.service.ProductService;
import com.citydo.vertxspringboot.utils.Constants;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.Handler;
import io.vertx.core.eventbus.EventBus;
import io.vertx.core.eventbus.Message;
import io.vertx.core.json.Json;
import io.vertx.core.json.JsonObject;
import lombok.extern.slf4j.Slf4j;
import lombok.val;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;/*** @author nick*/
@Slf4j
@Component
public class JpaProductVerticle extends AbstractVerticle {private final static ObjectMapper objectMapper = Json.mapper;@Autowiredprivate ProductService productService;private Handler<Message<String>> allProductsHandler(ProductService productService) {return msg -> vertx.<String>executeBlocking(future -> {try {future.complete(objectMapper.writeValueAsString(productService.getAllProduct()));log.info("got all products from blocking...");} catch (JsonProcessingException e) {log.error("Failed to serialize result");future.fail(e);}},result -> {if (result.succeeded()) {msg.reply(result.result());} else {msg.reply(result.cause().toString());}});}private Handler<Message<String>> getOneProductHandler(ProductService productService) {return msg -> vertx.<String>executeBlocking(future -> {try {Integer productId = Integer.valueOf(msg.body());log.info("productId from sender: {}", productId);val productDTO = productService.findProductById(productId);future.complete(objectMapper.writeValueAsString(productDTO));log.info("got one product from blocking...");} catch (Exception e) {log.error("Failed to serialize result");future.fail(e);}},result -> {if (result.succeeded()) {msg.reply(result.result());} else {msg.reply(result.cause().toString());}});}@Overridepublic void start() throws Exception {super.start();EventBus eventBus = vertx.eventBus();eventBus.<String>consumer(Constants.ALL_PRODUCTS_ADDRESS).handler(allProductsHandler(productService));eventBus.<String>consumer(Constants.GET_ONE_PRODUCT_ADDRESS).handler(getOneProductHandler(productService));eventBus.<JsonObject>consumer(Constants.ADD_PRODUCT_ADDRESS).handler(addProductHandler(productService));eventBus.<Integer>consumer(Constants.DELETE_PRODUCT_ADDRESS).handler(deleteProductHandler(productService));eventBus.<JsonObject>consumer(Constants.PATCH_PRODUCT_ADDRESS).handler(patchProductHandler(productService));}private Handler<Message<Integer>> deleteProductHandler(ProductService productService) {return message -> vertx.<Integer>executeBlocking(future -> {try {Integer productId = message.body();log.info("productId from sender: {}", productId);future.complete(productService.deleteProduct(productId));log.info("deleted one product from blocking...");} catch (Exception e) {log.error("Failed to serialize result");future.fail(e);}},result -> {if (result.succeeded()) {message.reply(result.result());} else {message.reply(result.cause().toString());}});}private Handler<Message<JsonObject>> patchProductHandler(ProductService productService) {return message -> vertx.<JsonObject>executeBlocking(future -> {try {JsonObject product = message.body();log.info("product to be patched from sender: {}", product);future.complete(JsonObject.mapFrom(productService.patchProduct(product.mapTo(ProductResult.class))));} catch (Exception e) {log.error("Failed to serialize result");future.fail(e);}},result -> {if (result.succeeded()) {message.reply(result.result());} else {message.reply(result.cause().toString());}});}private Handler<Message<JsonObject>> addProductHandler(ProductService productService) {return message -> vertx.<JsonObject>executeBlocking(future -> {try {JsonObject product = message.body();log.info("product from sender: {}", product);future.complete(JsonObject.mapFrom(productService.addProduct(product.mapTo(ProductResult.class))));log.info("got one product from blocking...");} catch (Exception e) {log.error("Failed to serialize result");future.fail(e);}},result -> {if (result.succeeded()) {message.reply(result.result());} else {message.reply(result.cause().toString());}});}private Handler<Message<String>> getAllService() {return msg -> vertx.<String>executeBlocking(future -> {log.info("try to get json.....");try {log.info("get json success..");future.complete(new JsonObject().put("name", "wade").toString());} catch (Exception e) {log.info("Failed to serialize result");future.fail(e);}}, result -> {if (result.succeeded()) {msg.reply(result.result());} else {msg.reply(result.cause().toString());}});}
}

package com.citydo.vertxspringboot.utils;public class Constants {public static final String ALL_PRODUCTS_ADDRESS = "all-products-address";public static final String GET_ONE_PRODUCT_ADDRESS = "get-one-product-address";public static final String ADD_PRODUCT_ADDRESS = "add-product-address";public static final String DELETE_PRODUCT_ADDRESS = "delete-product-address";public static final String PATCH_PRODUCT_ADDRESS = "patch-product-address";
}

package com.citydo.vertxspringboot.service;import com.citydo.vertxspringboot.dto.ProductResult;
import com.citydo.vertxspringboot.entity.Product;
import com.citydo.vertxspringboot.repository.ProductRepository;
import lombok.extern.slf4j.Slf4j;
import lombok.val;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;import javax.transaction.Transactional;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;/*** @author nick*/
@Slf4j
@Service
@Transactional
public class ProductService {@Autowiredprivate ProductRepository productRepository;/*** 获取全部数据* @return*/public List<ProductResult> getAllProduct() {val entityList = productRepository.findAll();if (CollectionUtils.isEmpty(entityList)){return Collections.EMPTY_LIST;}return entityList.stream().map(Product::getProductResult).collect(Collectors.toList());}/*** 查询单个数据Constants* @param productId* @return*/public ProductResult findProductById(Integer productId){if (StringUtils.isEmpty(productId)){return null;}val entity = productRepository.findById(productId);return Objects.isNull(entity) ? null :  entity.map(Product::getProductResult).get();}/*** 添加* @param productResult* @return*/public ProductResult addProduct(ProductResult productResult){Product toBeSavedEntity = new Product();BeanUtils.copyProperties(productResult, toBeSavedEntity);val savedEntity = productRepository.save(toBeSavedEntity);return savedEntity.getProductResult();}/*** 删除数据* @param productId* @return*/public Integer deleteProduct(Integer productId){productRepository.deleteById(productId);return productId;}public ProductResult patchProduct(ProductResult productResult) {val entity = productRepository.findById(productResult.getProductId()).get();entity.setProductName(productResult.getProductName());entity.setDescription(productResult.getDescription());val saved = productRepository.save(entity);return saved.getProductResult();}}

package com.citydo.vertxspringboot.repository;import com.citydo.vertxspringboot.entity.Product;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.stereotype.Repository;@Repository
public interface ProductRepository extends JpaRepository<Product, Integer> {}

package com.citydo.vertxspringboot.entity;import com.citydo.vertxspringboot.dto.ProductResult;
import lombok.Data;
import lombok.val;
import org.springframework.beans.BeanUtils;import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;/*** @author nick*/
@Data
@Entity
@Table(name = "product")
public class Product {@Id@Column(name = "product_id")private Integer productId;@Column(name = "product_name")private String productName;@Column(name = "description")private String description;/*** 将数据对象转成返给前端对象* @return*/public ProductResult getProductResult(){val productDTO = new ProductResult();BeanUtils.copyProperties(this, productDTO);return productDTO;}}

package com.citydo.vertxspringboot.dto;import lombok.Data;@Data
public class ProductResult {private Integer productId;private String description;private String productName;
}

sql：

-- ----------------------------
-- Table structure for product
-- ----------------------------
DROP TABLE IF EXISTS `product`;
CREATE TABLE `product` (`product_id` int(11) NOT NULL,`product_name` varchar(45) NOT NULL,`description` varchar(45) DEFAULT NULL,PRIMARY KEY (`product_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;-- ----------------------------
-- Records of product
-- ----------------------------
INSERT INTO `product` VALUES ('1', '张三', '测试中');