Vert.x - SpringBoot 整合 vertx

一、vertx

前面的文章讲解了 vertx 的简介及 vertx-web 的路由，看过的小伙伴应该对 vertx 有了一定的了解，从前面的演示来看，都是单独使用的 vertx ，对于目前的后端来说 SpringBoot 可是一个非常火热的框架，那如果将 vertx 嵌入 SpringBoot 中不是符合我们的开发习惯了。对于 SpringBoot 来说引入 vertx 就是引入一个普通的组件，并没有什么特别之处。

但是有一个非常坑的地方，就是 vertx 4.1.x 版本和SpringBoot 2.3.x 版本的整合在一起，在做文件上传时会一直卡住，当时笔者对此问题也是没有什么头绪，自己默默折腾了两天才发现，vertx 4.1.x 和 SpringBoot 2.2.X 版本整合在一起是 OK 的，而 SpringBoot 2.3.X 的需要整合 vertx.4.2.X 版本的就不会有问题了。希望后面的小伙伴不要踩坑！

下面是上篇文章的地址：

https://blog.csdn.net/qq_43692950/article/details/124073457

下面是我个人在 SpringBoot 中 引入 vertx 的处理过程。

二、SpringBoot 整合 vertx

首先新建一个 SpringBoot 项目，注意不要引入其他 web 框架。在 pom 中引入依赖，注意这里我使用的是 vertx 4.1.8 版本的，对应SpringBoot 2.2.X 。这里我的 SpringBoot 版本是 2.2.6 。

<dependency>
    <groupId>io.vertx</groupId>
    <artifactId>vertx-core</artifactId>
    <version>4.1.8</version>
</dependency>

<dependency>
    <groupId>io.vertx</groupId>
    <artifactId>vertx-web</artifactId>
    <version>4.1.8</version>
</dependency>

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
</dependency>

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.76</version>
</dependency>

下面编写 vertx 的配置类，主要声明 vertx 对象及 Router对象，对于具体的路由接口，我是放在 Verticle 中进行声明，直接使用 Spring 的 getBeansOfType 根据 AbstractVerticle获取所有的 Verticle 进行初始化，其中跨域、全局异常捕获、及拦截我也在该类中进行了声明：

@Slf4j
@Configuration
public class VertxConfig {

    @Autowired
    Environment environment;

    @Bean
    public Vertx vertx() {
        VertxOptions options = new VertxOptions()
                .setEventLoopPoolSize(20)
                .setWorkerPoolSize(20);
        return Vertx.vertx(options);
    }

    @Bean
    public Router router(Vertx vertx) {
        Router router = Router.router(vertx);
        globalIntercept(router);
        globalError(router);
        cors(router);
        return router;
    }

    private Integer port() {
        return environment.getProperty("server.port", Integer.class, 8080);
    }

    @Bean
    public HttpServer httpServer(Vertx vertx, Router router, ApplicationContext applicationContext) {
        //获取所有子类
        Map<String, AbstractVerticle> beansOfType = applicationContext.getBeansOfType(AbstractVerticle.class);
        beansOfType.forEach((k, verticle) -> {
            vertx.deployVerticle(verticle);
        });
        return vertx.createHttpServer().requestHandler(router).listen(port(), "0.0.0.0", res -> {
            if (res.succeeded()) {
                log.info("vert.x success to listen： " + port());
            } else {
                log.info("vert.x fail:" + res.cause().getMessage());
            }
        });
    }

    //跨域处理
    private void cors(Router router) {
        router.route().handler(CorsHandler.create()
                .addOrigin("*")
                .allowedHeader(" x-www-form-urlencoded, Content-Type,x-requested-with")
                .allowedMethod(HttpMethod.GET)
                .allowedMethod(HttpMethod.POST)
                .allowedMethod(HttpMethod.PUT)
                .allowedMethod(HttpMethod.DELETE));

    }

    //全局异常返回
    private void globalError(Router router) {
        router.route().failureHandler(ctx -> {
            ctx.response().end(JSONObject.toJSONString(ResultDTO.err(ctx.failure().getMessage())));
        });
    }

    //全局拦截器
    private void globalIntercept(Router router) {
        router.route("/*").handler(ctx -> {
            ctx.response().putHeader("Content-Type", "application/json");
            ctx.next();
        });
    }
}

下面我又编写了一个 BaseVerticle 继承 AbstractVerticle，只是起到一个模板的作用，在该类中我就引入了一个 Router 对象，也可以做其他公共的逻辑写在这里面：

@Component
public abstract class BaseVerticle extends AbstractVerticle {
    @Autowired
    public Router router;
}

下面就可以根据业务逻辑编写不同的 Verticle 了，如：

@Component
public class TestVerticle extends BaseVerticle {

    @Override
    public void start() throws Exception {
        router.get("/getTest").handler(this::getTest);
        router.get("/err").handler(this::err);
    }

    private void getTest(RoutingContext ctx) {
        ctx.response().end(JSONObject.toJSONString(ResultDTO.ok()));
    }

    private void err(RoutingContext ctx) {
        int a = 1/0;
    }
}

下面贴出公共的返回对象：

@Data
@Accessors(chain = true)
@AllArgsConstructor
@NoArgsConstructor
public class ResultDTO {
    private Integer code;
    private String message;
    private Object data;

    public static ResultDTO ok() {
        return new ResultDTO(200, "success", null);
    }

    public static ResultDTO err(String message) {
        return new ResultDTO(400, message, null);
    }
}

到这基本就已经整合 OK 了，启动 SpringBoot 项目，可以看到成功的日志：

使用PostMan访问接口：

喜欢的小伙伴可以关注我的个人微信公众号，获取更多学习资料！