vertx和springboot整合案例

超、凢脫俗 2023-02-13 08:08 2阅读 0赞

**项目结构：**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDQ3MzAx_size_16_color_FFFFFF_t_70]

**依赖：**

<?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/> 
        </parent>
        <groupId>com.xxxx</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.xxxx.vertxspringboot;
    
    
    import com.xxxx.vertxspringboot.verticle.JpaProductVerticle;
    import com.xxxx.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 { 
    
        @Autowired
        private ProductServerVerticle productServerVerticle;
    
        @Autowired
        private JpaProductVerticle jpaProductVerticle;
    
        public static void main(String[] args) { 
            SpringApplication.run(VertxspringbootApplication.class, args);
        }
    
        @PostConstruct
        public 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.xxxx.vertxspringboot.verticle;
    
    import com.xxxx.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 { 
    
        @Override
        public 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.xxxx.vertxspringboot.verticle;
    
    import com.xxxx.vertxspringboot.dto.ProductResult;
    import com.xxxx.vertxspringboot.service.ProductService;
    import com.xxxx.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;
    
        @Autowired
        private 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());
                        }
                    });
        }
    
        @Override
        public 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.xxxx.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.xxxx.vertxspringboot.service;
    
    import com.xxxx.vertxspringboot.dto.ProductResult;
    import com.xxxx.vertxspringboot.entity.Product;
    import com.xxxx.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 { 
    
        @Autowired
        private 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.xxxx.vertxspringboot.repository;
    
    import com.xxxx.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.xxxx.vertxspringboot.entity;
    
    
    import com.xxxx.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.xxxx.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', '张三', '测试中');

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDQ3MzAx_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210316235409419.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzMyNDQ3MzAx,size_16,color_FFFFFF,t_70