入门级 使用 vertx进行tcp 开发 spring boot整合vertx开发tcp

已于 2023-09-08 09:23:27 修改
阅读量2.2k 收藏 3
点赞数 1
文章标签： tcp/ip spring boot java
于 2023-05-22 09:28:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wonder_dog/article/details/130799994
版权

Vertx 简介

准备

软件下载
网络调试工具

前言

NetServerOptions options = new NetServerOptions();
options.setRegisterWriteHandler(true);
options.setTcpKeepAlive(true);  // 是否存活
//        options.setIdleTimeout(5);   // 配置了 客户端会自动断连，重新连接

创建Spring boot 项目

导入依赖

<!--   vertx tcp开发依赖     -->
<dependency>
   <groupId>io.vertx</groupId>
   <artifactId>vertx-core</artifactId>
   <version>4.3.1</version>
</dependency>


<!--   spring boot 依赖   -->
 <dependency>
<groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>


 <!--   其他工具类依赖     -->

<dependency>
  <groupId>com.google.guava</groupId>
  <artifactId>guava</artifactId>
  <version>31.1-jre</version>
</dependency>


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


<dependency>
  <groupId>cn.hutool</groupId>
  <artifactId>hutool-all</artifactId>
  <version>5.8.11</version>
</dependency>




<dependency>
  <groupId>com.alibaba</groupId>
  <artifactId>fastjson</artifactId>
  <version>2.0.8.graal</version>
</dependency>

<dependency>
  <groupId>com.alibaba.fastjson2</groupId>
  <artifactId>fastjson2</artifactId>
  <version>2.0.25</version>
</dependency>

创建tcpServer

  1. server.connectHandler 服务端创建连接后的操作
  2. socket.writeHandlerID() 获取 clientid
  3. socket.handler 接收客户端发送的消息
  4. vertx.setPeriodic 设置定时器 通过定时器，服务端主动定时给服务端发送消息
  5. socket.closeHandler 监测客户端是否断开连接
  6. server.listen 监听指定的端口号，启动TcpServer

使用 vertx.createNetServer 创建 netServer

当客户端连入后，服务端会通过配置的定时发送消息，给客户端发送消息，客户端断开连接后，会通过socket.closeHandler 监测，检测到取消定时器，不再向客户端发送消息

package com.example.socketdemo.socket5;

import cn.hutool.core.util.CharsetUtil;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.Vertx;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.net.NetServer;
import io.vertx.core.net.NetServerOptions;
import lombok.extern.slf4j.Slf4j;

import java.time.LocalDateTime;

@Slf4j
public class VertxTCPServer extends AbstractVerticle {

 
    @Override
    public void start() {

        // 可以配置 ip 端口号
        NetServerOptions netServerOptions = new NetServerOptions().setPort(9090).setHost("127.0.0.1");

        // 创建TCP服务器
        NetServer server = vertx.createNetServer(netServerOptions);

        // 处理连接请求
        server.connectHandler(socket -> {

			String handlerID = socket.writeHandlerID();
            System.out.println("服务端id" + handlerID);

            // 接收客户端发送的消息
            socket.handler(buff -> {
                System.out.println("RECV: " + buff.length());
                // 需要回复消息可以在这发送
                socket.write(Buffer.buffer("TcpServer Receive -=== Hello Vertx from Server!"));
            });
            
            
            // 创建服务端发送消息定时器
            long id = vertx.setPeriodic(10000, res -> {
                socket.write(Buffer.buffer("Hello Vertx from Server!......"), ar -> {
                    if (ar.succeeded()) {
                        socket.handler(buffer -> {
                            // 在这里应该解析报文，封装为协议对象，并找到响应的处理类，得到处理结果，并响应
                            log.info("TcpServer接收到的数据为：" + buffer.toString(CharsetUtil.CHARSET_GBK) + " " + LocalDateTime.now());
						  //todo  收到客户端消息后做其他操作
                        });
                    } else {
                        log.error("写入数据失败!");
                        // todo 发送给客户端消息失败 记录日志或其他操作
                    }
                });
            });

            // 监听客户端的退出连接
            socket.closeHandler(close -> {
                System.out.println("客户端退出连接"+ socket.writeHandlerID());
                // 取消定时器  不再向退出连接的客户端发送信息
                vertx.cancelTimer(id);
            });
        });


        // 监听端口
        server.listen(9090, "127.0.0.1", res -> {
          if (res.succeeded()) {
                log.info(" 服务器启动成功");
            } else {
                log.error(" 服务器启动失败 {}", res.cause().getMessage());
            }
        });
    }




    public static void main(String[] args) {
        // 启动服务端   spring boot 可以使用 ApplicationRunner 启动
        Vertx.vertx().deployVerticle(new VertxTCP2Server());
    }
}

在这里插入图片描述

注意 这里有两个 socket.handler 接收消息的方法，客户端创建连接后第一个，定时器里面第二个，第一个接收创建连接后的第一条消息，可以理解为注册包, 后面客户端发送的消息都在第二个 socket.handler 接收

启动完服务端之后，我们可以通过 网络调试助手 启动客户端，进行消息发送接收测试
使用 public static void main 进行简单的启动测试
整合spring Boot 可以使用 ApplicationRunner 代码如下

@Component
public class ThreadApplicationRuner implements ApplicationRunner {
    @Override
    public void run(ApplicationArguments args) throws Exception {
        Vertx.vertx().deployVerticle(new VertxTCP2Server());
    }
}

创建 TcpClient

使用 vertx.createNetClient 创建客户端

  1. client.connect 客户端进行连接
  2. socket.handler 连接成功后 接收客户端消息

启动同 TcpServer 可以使用 ApplicationRunner

package com.example.socketdemo.socket5;

import cn.hutool.core.util.CharsetUtil;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.Vertx;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.net.NetClient;
import io.vertx.core.net.NetClientOptions;
import io.vertx.core.net.NetSocket;
import lombok.extern.slf4j.Slf4j;

import java.time.LocalDateTime;

@Slf4j
public class VertxTCPClient extends AbstractVerticle {


    @Override
    public void start() {
        NetClientOptions options = new NetClientOptions().setConnectTimeout(10000);
        NetClient client = vertx.createNetClient(options);
        client.connect(11203, "192.168.2.141", res -> {
            if (res.succeeded()) {
                System.out.println("Connected!");
                NetSocket socket = res.result();
                socket.handler(buffer -> {
//                    // 在这里应该解析报文，封装为协议对象，并找到响应的处理类，得到处理结果，并响应
                    log.info("tcpClient 接收到的数据为：" + buffer.toString(CharsetUtil.CHARSET_GBK) + " " + LocalDateTime.now());
//                    String heartStr = HexUtil.encodeHexStr(buffer.toString(CharsetUtil.CHARSET_GBK).getBytes(CharsetUtil.CHARSET_GBK)).toUpperCase();
//                    System.out.println("接收到的数据为 -HEX：" + HexUtil.encodeHexStr(buffer.toString(CharsetUtil.CHARSET_GBK).getBytes(CharsetUtil.CHARSET_GBK)).toUpperCase());
                    // 收到客户端消息后回复客户端信息
                    socket.write(Buffer.buffer("tcpClient send ====> Hello Vertx from Server!"));

                });
            } else {
                System.out.println("Failed to connect: " + res.cause().getMessage());
            }
        });
    }


    public static void main(String[] args) {

        Vertx.vertx().deployVerticle(new VertxTCPClient());
    }
}

测试

有时我们需要向tcp客户端发送十六进制的数据，直接发送的时候会发现没有数据返回 下面代码是以 十六进制格式发送信息, 利用 hutool工具里

使用 HexUtil.decodeHex(sendMsg) 将字符串转换成十六进制的字节码 进行发送，测试是否返回数据

socket.write(Buffer.buffer(HexUtil.decodeHex(sendMsg)), resp -> {
     if (resp.succeeded()) {
          log.info("服务端 发送消息成功 {}", sendDeHex);
      } else {
          log.error("发送消息失败");
      }
  });

实战

接 5g路由器配置

tcp 接收消息的时候会有拆包粘包问题，可能接收的消息被分开，或者多条消息在一起接收，所以指令一般会有首部跟尾部进行区分，vertx也是异步编程，所以接收的时候需要改同步接收
具体代码图下，使用 Record Parser 解析

这里要点是

  1. socket.write(Buffer.buffer(HexUtil.decodeHex(sendMsg.get()))).onComplete 同步发送消息
  2. RecordParser parser = RecordParser.newDelimited 使用解析器确定结尾命令 防止粘包 拆包

测试代码


package com.example.socket.tcp2;

import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.HexUtil;
import com.example.socket.tcp1.BufferWrapper;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.Promise;
import io.vertx.core.Vertx;
import io.vertx.core.VertxOptions;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.net.NetServer;
import io.vertx.core.net.NetServerOptions;
import io.vertx.core.net.NetSocket;
import io.vertx.core.parsetools.RecordParser;
import lombok.extern.slf4j.Slf4j;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicReference;

@Slf4j
public class VertxTCPServer extends AbstractVerticle {


    public final static Map<String, NetSocket> CLIENT_MAP = Maps.newHashMap();

    public static final String host = "192.168.2.141";
    public static final Integer port = 10123;

    public static final String REGISTER_MSG = "心跳包";
    public static final String HEART_MSG = "注册包";

    @Override
    public void start() {

        //测试指令 这里模拟发送给tcp客户端的指令
        String sendMsg = "指令1";
        String sendMsg2 = "指令2";
        List<String> msgList = Lists.newArrayList();
        msgList.add(sendMsg);
        msgList.add(sendMsg2);
        
        //配置
        NetServerOptions netServerOptions = new NetServerOptions();
        netServerOptions.setRegisterWriteHandler(true);
        netServerOptions.setTcpKeepAlive(true);
        // 创建TCP服务器
        NetServer server = vertx.createNetServer(netServerOptions);
        // 处理连接请求
        server.connectHandler(socket -> {
            String handlerId = socket.writeHandlerID();
            log.info("客户端接入===》 {}", handlerId);
            CLIENT_MAP.put(handlerId, socket);
            // 接收客户端发送的消息
            socket.handler(buff -> {
                log.info("==接收串口指令 GBK：" + buff.toString(CharsetUtil.CHARSET_GBK));
            });


            // 监听客户端的退出连接
            socket.closeHandler(close -> {
                CLIENT_MAP.remove(socket.writeHandlerID());
                log.info("客户端退出连接 {}" , LocalDateTime.now());
                // 取消定时器  不再向退出连接的客户端发送信息
            });
        });


        // 监听端口
        server.listen(port, host, res -> {
            if (res.succeeded()) {
                System.out.println(port + " 服务器启动成功");
            } else {
                log.error("连接失败===》 {}  {}" ,port, res.cause().getMessage());
            }
        });

        // 定时给客户端发送指令
        long timerId = vertx.setPeriodic(18000, res -> {
            CLIENT_MAP.forEach((key, socket) -> receiveMsg(socket, msgList));
        });
    }


    private static void receiveMsg(NetSocket socket, List<String> msgList) {
        int initialIndex = 0;
        sendNextMessage(socket, msgList, initialIndex);
    }

    private static void sendNextMessage(NetSocket socket, List<String> msgList, int currentIndex) {
        if (currentIndex < msgList.size()) {
            String nextMsg = msgList.get(currentIndex);
            AtomicReference<String> sendMsg = new AtomicReference<>(nextMsg);
            System.out.println(sendMsg.get());
            // 1. 使用 onComplete 做同步发送消息  
            // 2. 根据接收发送格式  选择时候使用十六进制发送  HexUtil.decodeHex(sendMsg.get()))
            socket.write(Buffer.buffer(HexUtil.decodeHex(sendMsg.get()))).onComplete(ar1 -> {
                if (ar1.succeeded()) {
                    ThreadUtil.sleep(1000);
                    final RecordParser parser = RecordParser.newDelimited(Buffer.buffer(HexUtil.decodeHex("EE")), receive -> {
                        if (receive.toString().equals(REGISTER_MSG) || receive.toString().equals(HEART_MSG)) {
                            return;
                        }
                        String heartStr =  HexUtil.encodeHexStr(receive.getBytes(), false).toUpperCase();
                        System.out.println("接收到的消息: " + sendMsg.get() +" " + LocalDateTime.now() + " - " + heartStr);
                        // todo 具体逻辑处理
                        // 发送下一条消息
                        sendNextMessage(socket, msgList, currentIndex + 1);
                    });
                    socket.handler(parser);
                } else {
                    // 处理发送失败的情况
                    log.error("发送失败");
                }
            });
        }
    }



    public static void main(String[] args) {
        VertxOptions vertxOptions = new VertxOptions();
        vertxOptions.setBlockedThreadCheckInterval(999888777666L);
        vertxOptions.setMaxEventLoopExecuteTime(999888777666L);
        Vertx.vertx(vertxOptions).deployVerticle(new VertxTCPServer());
        Vertx.vertx().close();
    }


}

升级版

经过测试 vertx使用 socket.write(Buffer.buffer(HexUtil.decodeHex(sendMsg.get()))).onComplete 同步编程，假使客户端不回发消息，会造成堵塞，所以还是得用异步发送
要点

  1. 使用vertx异步发送消息 将发送的指令存到map中 保持发送消息跟接收消息一直
  2. 使用 RecordParser.newDelimited 进行拆包，解决TCP粘包问题
package com.example.socket.tcphex;

import cn.hutool.core.thread.ThreadUtil;
import cn.hutool.core.util.CharsetUtil;
import cn.hutool.core.util.HexUtil;
import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import io.vertx.core.AbstractVerticle;
import io.vertx.core.Promise;
import io.vertx.core.Vertx;
import io.vertx.core.VertxOptions;
import io.vertx.core.buffer.Buffer;
import io.vertx.core.net.NetServer;
import io.vertx.core.net.NetServerOptions;
import io.vertx.core.net.NetSocket;
import io.vertx.core.parsetools.RecordParser;
import lombok.extern.slf4j.Slf4j;

import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.concurrent.atomic.AtomicBoolean;

@Slf4j
public class VertxTCPHexServer1 extends AbstractVerticle {


    public final static Map<String, NetSocket> CLIENT_MAP = Maps.newHashMap();

    public static final String host = "192.168.2.141";
    public static final Integer port = 10123;
    public final static Map<String, Integer> PORT_MAP = Maps.newHashMap();
    @Override
    public void start() {

        String sendMsg = "指令一";
        String sendMsg2 = "指令二";
        List<String> msgList = Lists.newArrayList();
        msgList.add(sendMsg);
        msgList.add(sendMsg2);


        //配置
        NetServerOptions netServerOptions = new NetServerOptions();
        netServerOptions.setRegisterWriteHandler(true);
        netServerOptions.setTcpKeepAlive(true);
        //设置socket多长时间未收到消息超时（s）
        netServerOptions.setReadIdleTimeout(120);

        // 创建TCP服务器
        NetServer server = vertx.createNetServer(netServerOptions);

        // 处理连接请求
        server.connectHandler(socket -> {
            String handlerId = socket.writeHandlerID();
            CLIENT_MAP.put(handlerId, socket);
            // 接收客户端发送的消息
            socket.handler(buff -> {
                log.info("==接收串口指令 GBK：{} 客户端{}", buff.toString(CharsetUtil.CHARSET_GBK), handlerId);
            });


            // 监听客户端的退出连接
            socket.closeHandler(close -> {
                CLIENT_MAP.remove(socket.writeHandlerID());
                log.error("客户端退出连接 ");
                // 取消定时器  不再向退出连接的客户端发送信息
            });
        });

        // 监听端口 配置tcp启动信息
        String key1 = String.format("%s-%s", host, port);
        if (!PORT_MAP.containsKey(key1)) {
            server.listen(port, host).onComplete(res -> {
                if (res.succeeded()) {
                    log.info(port + " 服务器启动成功");
                    PORT_MAP.put(key1, server.actualPort());
                } else {
                    log.error("连接失败===》 {}  {}", port, res.cause().getMessage());
                }
            });
        }



        // 定时循环向客户端发送消息
        long timerId = vertx.setPeriodic(20000, res -> {
            log.info("循环开始====》{} {}", LocalDateTime.now(), CLIENT_MAP.size());
            CLIENT_MAP.forEach((key, socket) -> {
                sendMsg(socket, msgList);
            });
        });
    }
    
    private void sendMsg(NetSocket socket, List<String> msgList) {
        Map<String, String> sendMap = Maps.newHashMap();
        msgList.forEach(msg -> {
            // 异步的时候 发送的消息跟接收的消息会不一致 这里我们发到map里面去  用的时候从里面取
            int index = msg.indexOf("CAFC");
            String substring = msg.substring(index, index + 6);
            sendMap.put(substring.replace("FC", "BD"), msg);
            socket.write(Buffer.buffer(HexUtil.decodeHex(msg))).onComplete(ar1 -> {
                if (ar1.succeeded()) {
                    final RecordParser parser = RecordParser.newDelimited(Buffer.buffer(HexUtil.decodeHex("EE")), receive -> {
                        String heartStr = HexUtil.encodeHexStr(receive.getBytes(), false).toUpperCase();
                        int receiveIndex = heartStr.indexOf("CABD");
                        String receiveSubstring = heartStr.substring(receiveIndex, receiveIndex + 6);
                        String sendOne = sendMap.get(receiveSubstring);
                        log.info(String.format("接收指令: %s key %s 客户端数量 %s 信息%s", sendOne, socket.writeHandlerID(), CLIENT_MAP.size(), heartStr));
                    });
                    socket.handler(parser);
                }
            });
            ThreadUtil.sleep(3000);
        });
    }



    public static void main(String[] args) {
            VertxOptions vertxOptions = new VertxOptions();
            vertxOptions.setBlockedThreadCheckInterval(999888777666L);
            vertxOptions.setMaxEventLoopExecuteTime(999888777666L);
            Vertx.vertx(vertxOptions).deployVerticle(new VertxTCPHexServer1());
    }


}
ccubee
关注
现在的你是选 Spring Boot 还是 Vert.x ?
程序员野蛮成长
07-24 726
Vert.x支持多种编程语言，包括Java、Groovy、Kotlin和JavaScript等，并提供了非常丰富的库和工具，使得开发者可以快速构建高性能应用程序。Vert.x的设计哲学是提供一种简单、轻量级、高可用性的开发框架，同时具备高并发处理、非阻塞IO、事件驱动等特性。综上所述，Vert.x和Spring Boot在编程模型、语言支持、响应式编程、性能和微服务支持等方面有所不同，开发者可以根据自己的需求和技术选型来选择适合的框架。Web API，数据库，消息传递，事件流，云，服务注册，安全性…
vert.x-springboot模版项目
07-12
vert.x是内存占用极小的快速开发框架，springboot模版项目
Vert.x 和 Spring Boot 是两种流行的 Java 框架的比较
wolf23151269的博客
09-26 1438
Vert.x：异步非阻塞，适合高并发、高 I/O 密集型应用，性能优异，灵活性高，但在生态系统和企业级支持方面不如 Spring Boot 成熟。：同步阻塞编程模型，生态系统庞大，企业支持全面，开发效率高，适合绝大多数企业应用场景，也支持通过 WebFlux 实现异步非阻塞。在不同的应用场景下，根据项目需求选择合适的框架，可以最大化发挥两者的优势。
Vert.x - SpringBoot 整合 vertx
小毕超博客
04-10 7614
一、vertx 前面的文章讲解了 vertx 的简介及 vertx-web 的路由，看过的小伙伴应该对 vertx 有了一定的了解，从前面的演示来看，都是单独使用的 vertx ，对于目前的后端来说 SpringBoot 可是一个非常火热的框架，那如果将 vertx 嵌入 SpringBoot 中不是符合我们的开发习惯了。对于 SpringBoot 来说引入 vertx 就是引入一个普通的组件，并没有什么特别之处。 但是有一个非常坑的地方，就是 vertx 4.1.x 版本和SpringBoot 2.
Springboot跟Vert.x整合
qq_18244417的博客
05-30 2248
众所知周，Vert.x 是一个异步无阻塞的网络框架，其参照物是 node.js。基本上 node.js 能干的事情，Vert.x 都能干。Vert.x 利用 Netty4 的 EventLoop 来做单线程的事件循环，所以跑在 Vert.x 上的业务不能做 CPU 密集型的运算，这样会导致整个线程被阻塞。Springboot 是应用非常广泛的 java 快速开发框架，它提...
Vert.x 与Springboot集成
热门推荐
russle的专栏
05-26 1万+
欢迎使用Markdown编辑器写博客 众所知周，Vert.x是一个异步无阻塞的网络框架，其参照物是node.js。基本上node.js能干的事情，Vert.x都能干。Vert.x利用Netty4的EventLoop来做单线程的事件循环，所以跑在Vert.x上的业务不能做CPU密集型的运算，这样会导致整个线程被阻塞。 Springboot是应用非常广泛的java快速开发框架，它提供了与数据库，w...
vert.x结合springboot开发mqtt服务，真实可用
10-18
vert.x结合springboot开发mqtt服务端，直接启动主类。
使用 vertx进行mqtt 开发 spring boot整合vertx开发mqtt
07-13
要在Spring Boot中整合Vert.x开发MQTT应用程序，可以按照以下步骤进行操作： 1. 添加依赖：在项目的pom.xml文件中添加以下依赖，包括Vert.x和MQTT相关的依赖： ```xml <groupId>io.vertx <artifactId>vertx-...
基于Vertx与Spring Boot整合的响应式Web服务设计源码
最新发布
09-28
该项目为基于Vertx与Spring Boot整合的响应式Web服务设计源码，共计2901个文件，涵盖1937个Java源文件、344个XML配置文件、332个PNG图像文件、29个JavaScript文件、24个Git忽略文件、23个SO库文件、21个JPG图像文件...
vertx-vs-spring-reactor:一个基准，比较使用Groovy，Vertx和vertx-redis-client与Groovy，Spring Reactor和生菜制作的Web服务
05-10
在vert.x示例中，使用Vertx-Redis-Client，并将9个哈希获取请求发送到Redis。 该库使用管道作为默认模式 在弹簧React堆样品中，使用生菜驱动器。 我在某处读到使用React式生菜时流水线是默认模式。 然后，Redis...
vertx3-tcp-samples:使用vertx3框架。 并通过tcp（netserver）协议连接某物
05-13
【描述】：“vertx3-tcp-samples”项目展示了如何使用Vert.x 3中的NetServer模块与TCP（传输控制协议）进行通信。TCP是一种面向连接的、可靠的网络协议，确保数据的有序和无损传输，广泛用于互联网通信。 在“vertx...
springboot-vertx:SpringBoot和Vert.x示例
05-22
springboot-vertx 使用SpringBoot和Vert.x（3.0.0）示例 用法 步骤1.建立 mvn package 步骤2.运行 java -jar target/springboot-vertx-example-1.0.0.jar
vertx-embedded-springboot:Vert.x嵌入Springboot
05-14
Vert.x嵌入Springboot 当您需要异步多线程工作器模式时，可以使用此示例在JAVA中进行分布式处理，并且具有： Vert.x Worker线程verticle示例 SpringBoot Liquebase，在容器部署时初始化数据库数据迁移。 SpringBoot执行器，过程状态检查 Vert.x SpringBoot JPA示例，SQL。 使用Mybatis和SQL的Vert.x SpringBoot。 本示例按以下顺序工作。 实例部署后，将liquibase数据库迁移到数据库（H2或MariaDB） 弹簧执行器上的迁移状态检查 REST API检查到Vert.x Facade verticle（请求和响应） 在控制台日志记录中检查辅助线程日志记录。 （初始集：worker verticle实例4，事件循环：6） 检查Mybatis SQL日志记录 端口信息 港
vertx for springboot
08-29
vertx for springboot 是基于vert.x集成spring boot框架，只需要启动自己的eureka service 就能启动
vertx_example+springboot_example+maven 开发模板
07-21
vertx_example+springboot_example+maven 开发模板
Kotlin整合Vertx开发Web应用
08-26
在本文中，我们将探讨如何使用Kotlin与Vert.x框架整合来构建Web应用程序。Vert.x是一个轻量级、反应式和事件驱动的Java平台，适用于构建现代的、高性能的后端服务。Kotlin作为一种现代的、静态类型的编程语言，与...
Vert.x - SpringBoot 整合 vertx 使用 thymeleaf、freemarker 模板引擎
小毕超博客
04-10 2301
一、模板引擎 在 SpringMVC 项目中使用模板引擎，使用较多的应该是 thymeleaf 及 freemarker 了吧，虽然现在前后端分离的浪潮已经席卷而来，但对于 SEO 或者 页面静态话来说，后端的模板引擎还是具有一定的作用力。本篇文章继续上篇文章中搭建的 SpringBoot 项目中继续讲解，因此在看本篇文章之前，确保已经搭建了上篇文章的项目。 下面是上篇文章的地址： https://blog.csdn.net/qq_43692950/article/details/124076793 下
Vert.x(vertx) 实现TCP服务
happyfly的博客
12-07 1万+
对于Java开发人员，想要实现一个http服务，非常简单，写个servlet，打成war包，放到tomcat下就能运行。但如果要实现一个tcp服务就没那么简单了，因为tcp是传输层协议，并不像http那样，有类似tomcat的中间件给我们封装底层的网络协议，封装线程的交互。要实现一个tcp服务，只能自己动手处理网络和线程问题，这是非常考验编程功底的事情，而且如果团队人员素质不高，项目周期要求较短的...
Vert.x整合springboot
mingluo1的博客
07-16 1109
1.添加maven中的依赖 <!--spring-boot依赖--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependen...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值