How to use io.vertx.core.net.impl.transport

public static Transport transport(boolean preferNative) {
 if (preferNative) {
  Transport nativeTransport = Transport.nativeTransport();
  if (nativeTransport != null && nativeTransport.isAvailable()) {
   return nativeTransport;
  } else {
   return Transport.JDK;
  }
 } else {
  return Transport.JDK;
 }
}

/**
 * The native transport, it may be {@code null} or failed.
 */
public static Transport nativeTransport() {
 Transport transport = null;
 try {
  Transport epoll = new EpollTransport();
  if (epoll.isAvailable()) {
   return epoll;
  } else {
   transport = epoll;
  }
 } catch (Throwable ignore) {
  // Jar not here
 }
 try {
  Transport kqueue = new KQueueTransport();
  if (kqueue.isAvailable()) {
   return kqueue;
  } else if (transport == null) {
   transport = kqueue;
  }
 } catch (Throwable ignore) {
  // Jar not here
 }
 return transport;
}

/**
 * Apply the connection option to the server.
 *
 * @param domainSocket whether it's a domain socket server
 * @param bootstrap the Netty server bootstrap
 */
private void applyConnectionOptions(boolean domainSocket, ServerBootstrap bootstrap) {
 vertx.transport().configure(options, domainSocket, bootstrap);
}

Bootstrap bootstrap = new Bootstrap();
bootstrap.group(context.nettyEventLoop());
bootstrap.channelFactory(vertx.transport().channelFactory(remoteAddress.path() != null));

public static AsyncResolveConnectHelper doBind(VertxInternal vertx, SocketAddress socketAddress,
                        ServerBootstrap bootstrap) {
 AsyncResolveConnectHelper asyncResolveConnectHelper = new AsyncResolveConnectHelper();
 bootstrap.channelFactory(vertx.transport().serverChannelFactory(socketAddress.path() != null));
 if (socketAddress.path() != null) {
  java.net.SocketAddress converted = vertx.transport().convert(socketAddress, true);
  ChannelFuture future = bootstrap.bind(converted);
  future.addListener(f -> {

private DatagramSocketImpl(VertxInternal vertx, DatagramSocketOptions options) {
 Transport transport = vertx.transport();
 DatagramChannel channel = transport.datagramChannel(options.isIpV6() ? InternetProtocolFamily.IPv6 : InternetProtocolFamily.IPv4);
 transport.configure(channel, new DatagramSocketOptions(options));
 ContextInternal context = vertx.getOrCreateContext();
 channel.config().setOption(ChannelOption.DATAGRAM_CHANNEL_ACTIVE_ON_REGISTRATION, true);
 MaxMessagesRecvByteBufAllocator bufAllocator = channel.config().getRecvByteBufAllocator();
 bufAllocator.maxMessagesPerRead(1);
 context.nettyEventLoop().register(channel);
 if (options.getLogActivity()) {
  channel.pipeline().addLast("logging", new LoggingHandler());
 }
 VertxMetrics metrics = vertx.metricsSPI();
 this.metrics = metrics != null ? metrics.createDatagramSocketMetrics(options) : null;
 this.channel = channel;
 this.context = context;
 this.demand = Long.MAX_VALUE;
}

static VertxImpl vertx(VertxOptions options) {
 VertxImpl vertx = new VertxImpl(options, Transport.transport(options.getPreferNativeTransport()));
 vertx.init();
 return vertx;
}

@Override
protected io.netty.resolver.AddressResolver<InetSocketAddress> newResolver(EventExecutor executor) throws Exception {
 ChannelFactory<DatagramChannel> channelFactory = () -> vertx.transport().datagramChannel();
 DnsAddressResolverGroup group = new DnsAddressResolverGroup(channelFactory, nameServerAddressProvider) {
  @Override

private void handleConnect(SocketAddress remoteAddress, SocketAddress peerAddress, String serverName, Handler<AsyncResult<Channel>> channelHandler) {
 VertxInternal vertx = context.owner();
 bootstrap.resolver(vertx.nettyAddressResolverGroup());
 bootstrap.handler(new ChannelInitializer<Channel>() {
  @Override
  protected void initChannel(Channel ch) {
   initSSL(peerAddress, serverName, ch, channelHandler);
  }
 });
 ChannelFuture fut = bootstrap.connect(vertx.transport().convert(remoteAddress, false));
 fut.addListener(res -> {
  if (res.isSuccess()) {
   connected(fut.channel(), channelHandler);
  } else {
   channelHandler.handle(io.vertx.core.Future.failedFuture(res.cause()));
  }
 });
}

CountDownLatch connectLatch = new CountDownLatch(1);
Bootstrap bootstrap = new Bootstrap();
bootstrap.channelFactory(((VertxInternal)vertx).transport().channelFactory(false));
bootstrap.group(vertx.nettyEventLoopGroup());
bootstrap.resolver(((VertxInternal) vertx).nettyAddressResolverGroup());

private void applyConnectionOptions(boolean domainSocket, Bootstrap bootstrap) {
 vertx.transport().configure(options, domainSocket, bootstrap);
}

static void clusteredVertx(VertxOptions options, Handler<AsyncResult<Vertx>> resultHandler) {
 VertxImpl vertx = new VertxImpl(options, Transport.transport(options.getPreferNativeTransport()));
 vertx.joinCluster(options, resultHandler);
}

channel = transport.datagramChannel(this.dnsServer.getAddress() instanceof Inet4Address ? InternetProtocolFamily.IPv4 : InternetProtocolFamily.IPv6);
channel.config().setOption(ChannelOption.DATAGRAM_CHANNEL_ACTIVE_ON_REGISTRATION, true);
MaxMessagesRecvByteBufAllocator bufAllocator = channel.config().getRecvByteBufAllocator();

private void applyConnectionOptions(boolean domainSocket, ServerBootstrap bootstrap) {
 vertx.transport().configure(options, domainSocket, bootstrap);
}

@Override
public void configure(NetServerOptions options, boolean domainSocket, ServerBootstrap bootstrap) {
 if (!domainSocket) {
  bootstrap.option(KQueueChannelOption.SO_REUSEPORT, options.isReusePort());
 }
 super.configure(options, domainSocket, bootstrap);
}

 @Override
 public void configure(ClientOptionsBase options, boolean domainSocket, Bootstrap bootstrap) {
  if (options.isTcpFastOpen()) {
   bootstrap.option(EpollChannelOption.TCP_FASTOPEN_CONNECT, options.isTcpFastOpen());
  }
  bootstrap.option(EpollChannelOption.TCP_QUICKACK, options.isTcpQuickAck());
  bootstrap.option(EpollChannelOption.TCP_CORK, options.isTcpCork());
  super.configure(options, domainSocket, bootstrap);
 }
}

private void applyConnectionOptions(boolean domainSocket, Bootstrap bootstrap) {
 client.getVertx().transport().configure(options, domainSocket, bootstrap);
}

@Override
public void configure(NetServerOptions options, boolean domainSocket, ServerBootstrap bootstrap) {
 if (!domainSocket) {
  bootstrap.option(EpollChannelOption.SO_REUSEPORT, options.isReusePort());
 }
 if (options.isTcpFastOpen()) {
  bootstrap.option(EpollChannelOption.TCP_FASTOPEN, options.isTcpFastOpen() ? pendingFastOpenRequestsThreshold : 0);
 }
 bootstrap.childOption(EpollChannelOption.TCP_QUICKACK, options.isTcpQuickAck());
 bootstrap.childOption(EpollChannelOption.TCP_CORK, options.isTcpCork());
 super.configure(options, domainSocket, bootstrap);
}

@Override
public void configure(DatagramChannel channel, DatagramSocketOptions options) {
 channel.config().setOption(EpollChannelOption.SO_REUSEPORT, options.isReusePort());
 super.configure(channel, options);
}

 @Override
 public void configure(DatagramChannel channel, DatagramSocketOptions options) {
  channel.config().setOption(KQueueChannelOption.SO_REUSEPORT, options.isReusePort());
  super.configure(channel, options);
 }
}