Netty UDT网络通信示例

netty 网络通信示例一 :[url]http://donald-draper.iteye.com/blog/2383326[/url]
netty 网络通信示例二:[url]http://donald-draper.iteye.com/blog/2383328[/url]
netty 网络通信示例三:[url]http://donald-draper.iteye.com/blog/2383392[/url]
netty 网络通信示例四:[url]http://donald-draper.iteye.com/blog/2383472[/url]
Netty 构建HTTP服务器示例:[url]http://donald-draper.iteye.com/blog/2383527[/url]
前面的文章我们看了Netty tcp,http协议通信实例,大部分项目用Netty一般用TCP协议,很少用UDP协议,官方文档中,UDP协议的实例都很少,我们在实例可以看到一个UDT的实例包,UDT协议是基于UDP的数据传输协议(UDP-based Data Transfer Protocol,简称UDT),是一种互联网数据传输协议。UDT的主要目的是支持高速广域网上的海量数据传输,而互联网上的标准数据传输协议TCP在高带宽长距离网络上性能很差。 顾名思义,UDT建于UDP之上,并引入新的拥塞控制和数据可靠性控制机制。UDT是面向连接的双向的应用层协议。它同时支持可靠的数据流传输和部分可靠的数据报传输。 由于UDT完全在UDP上实现,它也可以应用在除了高速数据传输之外的其它应用领域,例如点到点技术(P2P),防火墙穿透,多媒体数据传输等等。
关于UDT协议,可以参见以下这个一些的文章:
UDT协议-基于UDP的可靠数据传输协议的实现分析(1)-准备工作:[url]http://jimmee.iteye.com/blog/2037451[/url],以后再认真研究一下UDT协议。
在netty实例中,UDT实例有UDT Byte Stream(TCP-like byte streaming mode) ,UDT Message Flow(UDP-like message delivery mode)及相关的对等Peer通信,测试结果UDT Message Flow类型的实例存在bug, see #https://github.com/netty/netty/issues/6934. Netty官方显示UDT将被丢弃,不在维护。所以我们只看下UDT Byte Stream的实例及Peer通信:
[b]服务端:[/b]
package netty.main.udt.bytes;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.udt.UdtChannel;
import io.netty.channel.udt.nio.NioUdtProvider;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.util.concurrent.DefaultThreadFactory;
import netty.handler.udt.bytes.ByteEchoServerHandler;

import java.net.InetSocketAddress;
import java.util.concurrent.ThreadFactory;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
* UDT Byte Stream Server
* use UDT in TCP-like byte streaming mode
* @author donald
* 2017年7月1日
* 下午4:11:20
*/
public final class ByteEchoServer {
private static final Logger log = LoggerFactory.getLogger(ByteEchoServer.class);
public static final String ip = System.getProperty("host", "192.168.31.153");
static final int port = Integer.parseInt(System.getProperty("port", "10020"));
@SuppressWarnings("deprecation")
public static void main(String[] args) throws Exception {
final ThreadFactory acceptFactory = new DefaultThreadFactory("accept");
final ThreadFactory connectFactory = new DefaultThreadFactory("connect");
final NioEventLoopGroup acceptGroup = new NioEventLoopGroup(1, acceptFactory, NioUdtProvider.BYTE_PROVIDER);
final NioEventLoopGroup connectGroup = new NioEventLoopGroup(1, connectFactory, NioUdtProvider.BYTE_PROVIDER);

// Configure the server.
try {
final ServerBootstrap boot = new ServerBootstrap();
boot.group(acceptGroup, connectGroup)
.channelFactory(NioUdtProvider.BYTE_ACCEPTOR)
.option(ChannelOption.SO_BACKLOG, 10)
.handler(new LoggingHandler(LogLevel.INFO))
.childHandler(new ChannelInitializer<UdtChannel>() {
@Override
public void initChannel(final UdtChannel ch)
throws Exception {
ch.pipeline().addLast(
new LoggingHandler(LogLevel.INFO),
new ByteEchoServerHandler());
}
});
InetSocketAddress inetSocketAddress = new InetSocketAddress(ip,port);
// Start the server.
final ChannelFuture future = boot.bind(inetSocketAddress).sync();
log.info("=========UDT Server is start=========");
// Wait until the server socket is closed.
future.channel().closeFuture().sync();
} finally {
// Shut down all event loops to terminate all threads.
acceptGroup.shutdownGracefully();
connectGroup.shutdownGracefully();
}
}
}

[b]服务端处理器:[/b]
package netty.handler.udt.bytes;

import io.netty.channel.ChannelHandler.Sharable;

import java.io.UnsupportedEncodingException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.udt.nio.NioUdtProvider;

/**
*
* @author donald
* 2017年7月1日
* 下午4:53:46
*/
@Sharable
public class ByteEchoServerHandler extends ChannelInboundHandlerAdapter {
private static final Logger log = LoggerFactory.getLogger(ByteEchoServerHandler.class);

@SuppressWarnings("deprecation")
@Override
public void channelActive(final ChannelHandlerContext ctx) {
log.info("ECHO active " +
NioUdtProvider.socketUDT(ctx.channel()).toStringOptions());
}

@Override
public void channelRead(final ChannelHandlerContext ctx, Object msg) {
ByteBuf in = (ByteBuf)msg;
byte[] bytes = new byte[in.writerIndex()];
in.readBytes(bytes);
//针对堆buf,direct buf不支持
// byte[] bytes = in.array();
String message = null;
try {
message = new String(bytes,"UTF-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
try{
log.info("===Server reciever message:" +message);
}
finally{
//如果msg为引用计数对象,在使用后注意释放,一般在通道handler中释放
// ReferenceCountUtil.release(msg);
}
String ackMessage = "hello client ...";
in.clear();
try {
in.writeBytes(ackMessage.getBytes("UTF-8"));
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
ctx.write(in);
}

@Override
public void channelReadComplete(ChannelHandlerContext ctx) {
ctx.flush();
}

@Override
public void exceptionCaught(final ChannelHandlerContext ctx, final Throwable cause) {
cause.printStackTrace();
ctx.close();
}
}

[b]客户端:[/b]
package netty.main.udt.bytes;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.udt.UdtChannel;
import io.netty.channel.udt.nio.NioUdtProvider;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.util.concurrent.DefaultThreadFactory;
import netty.handler.udt.bytes.ByteEchoClientHandler;

import java.net.InetSocketAddress;
import java.util.concurrent.ThreadFactory;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
* UDT Byte Stream Client
* use UDT in TCP-like byte streaming mode
* Sends one message when a connection is open and echoes back any received data
* to the server. Simply put, the echo client initiates the ping-pong traffic
* between the echo client and server by sending the first message to the
* server.
* @author donald
* 2017年7月1日
* 下午4:11:20
*/
public final class ByteEchoClient {
private static final Logger log = LoggerFactory.getLogger(ByteEchoClient.class);
public static final String ip = System.getProperty("host", "192.168.31.153");
static final int port = Integer.parseInt(System.getProperty("port", "10020"));
public static final int SIZE = Integer.parseInt(System.getProperty("size", "256"));

@SuppressWarnings("deprecation")
public static void main(String[] args) throws Exception {
// Configure the client.
final ThreadFactory connectFactory = new DefaultThreadFactory("connect");
final NioEventLoopGroup connectGroup = new NioEventLoopGroup(1,
connectFactory, NioUdtProvider.BYTE_PROVIDER);
try {
final Bootstrap boot = new Bootstrap();
boot.group(connectGroup)
.channelFactory(NioUdtProvider.BYTE_CONNECTOR)
.handler(new ChannelInitializer<UdtChannel>() {
@Override
public void initChannel(final UdtChannel ch)
throws Exception {
ch.pipeline().addLast(
new LoggingHandler(LogLevel.INFO),
new ByteEchoClientHandler());
}
});
InetSocketAddress inetSocketAddress = new InetSocketAddress(ip,port);
// Start the client.
final ChannelFuture f = boot.connect(inetSocketAddress).sync();
log.info("=========UDT Client is start=========");
// Wait until the connection is closed.
f.channel().closeFuture().sync();
} finally {
// Shut down the event loop to terminate all threads.
connectGroup.shutdownGracefully();
}
}
}

[b]客户端处理器:[/b]
package netty.handler.udt.bytes;

import java.io.UnsupportedEncodingException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.udt.nio.NioUdtProvider;
import netty.main.udt.bytes.ByteEchoClient;

/**
* Handler implementation for the echo client. It initiates the ping-pong
* traffic between the echo client and server by sending the first message to
* the server on activation.
* @author donald
* 2017年7月1日
* 下午4:53:59
*/
public class ByteEchoClientHandler extends SimpleChannelInboundHandler<ByteBuf> {
private static final Logger log = LoggerFactory.getLogger(ByteEchoClientHandler.class);
private final ByteBuf message;
public ByteEchoClientHandler() {
super(false);
String hello = "Hello peer...";
message = Unpooled.buffer(ByteEchoClient.SIZE);//堆buffer
try {
message.writeBytes(hello.getBytes("UTF-8"));
message.retainedDuplicate();
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
}

@SuppressWarnings("deprecation")
@Override
public void channelActive(final ChannelHandlerContext ctx) {
log.info("ECHO active " +
NioUdtProvider.socketUDT(ctx.channel()).toStringOptions());
ctx.writeAndFlush(message);
}

@Override
public void channelRead0(ChannelHandlerContext ctx, ByteBuf msg) {
ByteBuf in = (ByteBuf)msg;
byte[] bytes = new byte[in.writerIndex()];
in.readBytes(bytes);
//针对堆buf,direct buf不支持
// byte[] bytes = in.array();
String message = null;
try {
message = new String(bytes,"UTF-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
log.info("=== reciever ack message from peer:" +message);
}

@Override
public void channelReadComplete(ChannelHandlerContext ctx) {
// ctx.flush();
}

@Override
public void exceptionCaught(final ChannelHandlerContext ctx, final Throwable cause) {
cause.printStackTrace();
ctx.close();
}

}

启动服务端与客户端,控制台输出:
[b]服务端:[/b]
[INFO ] 2017-07-06 22:50:43 com.barchart.udt.SocketUDT library location : ./lib/bin
[INFO ] 2017-07-06 22:50:43 com.barchart.udt.SocketUDT loader provider : com.barchart.udt.lib.LibraryLoaderUDT
[INFO ] 2017-07-06 22:50:43 com.barchart.udt.lib.PluginPropsUDT ARCH/OS/LINK = amd64/Windows/gpp
[INFO ] 2017-07-06 22:50:43 com.barchart.udt.lib.LibraryLoaderUDT Platform supported.
[INFO ] 2017-07-06 22:50:43 com.barchart.udt.lib.LibraryLoaderUDT Loading release libraries.
[INFO ] 2017-07-06 22:50:43 com.barchart.udt.lib.LibraryLoaderUDT Release libraries loaded.
[INFO ] 2017-07-06 22:50:44 io.netty.handler.logging.LoggingHandler [id: 0xf9f14d4c] REGISTERED
[INFO ] 2017-07-06 22:50:44 io.netty.handler.logging.LoggingHandler [id: 0xf9f14d4c] BIND: /192.168.31.153:10020
[INFO ] 2017-07-06 22:50:44 netty.main.udt.bytes.ByteEchoServer =========UDT Server is start=========
[INFO ] 2017-07-06 22:50:44 io.netty.handler.logging.LoggingHandler [id: 0xf9f14d4c, L:/192.168.31.153:10020] ACTIVE
[INFO ] 2017-07-06 22:50:54 io.netty.handler.logging.LoggingHandler [id: 0xf9f14d4c, L:/192.168.31.153:10020] READ: [id: 0xf515214b, L:/192.168.31.153:10020 - R:/192.168.31.153:53767]
[INFO ] 2017-07-06 22:50:54 io.netty.handler.logging.LoggingHandler [id: 0xf9f14d4c, L:/192.168.31.153:10020] READ COMPLETE
[INFO ] 2017-07-06 22:50:54 io.netty.handler.logging.LoggingHandler [id: 0xf515214b, L:/192.168.31.153:10020 - R:/192.168.31.153:53767] REGISTERED
[INFO ] 2017-07-06 22:50:54 io.netty.handler.logging.LoggingHandler [id: 0xf515214b, L:/192.168.31.153:10020 - R:/192.168.31.153:53767] ACTIVE
[INFO ] 2017-07-06 22:50:54 netty.handler.udt.bytes.ByteEchoServerHandler ECHO active
[id: 0x04f589e8]
0) Maximum_Transfer_Unit = 1,500
1) Is_Send_Synchronous = false
2) Is_Receive_Synchronous = false
3) Custom_Congestion_Control = null
4) Flight_Window_Size = 25,600 (25 K)
5) Protocol_Send_Buffer_Size = 12,058,624
6) Protocol_Receive_Buffer_Size = 12,058,624
7) Time_To_Linger_On_Close = 180
8) System_Send_Buffer_Size = 65,536
9) System_Receive_Buffer_Size = 12,288,000
12) Is_Randezvous_Connect_Enabled = false
13) Send_Timeout = -1
14) Receive_Timeout = -1
15) Is_Address_Reuse_Enabled = true
16) Maximum_Bandwidth = -1
17) Status_Code = 5
18) Epoll_Event_Mask = 4
19) Send_Buffer_Consumed = 0
20) Receive_Buffer_Available = 0
[INFO ] 2017-07-06 22:50:54 io.netty.handler.logging.LoggingHandler [id: 0xf515214b, L:/192.168.31.153:10020 - R:/192.168.31.153:53767] READ: 13B
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 65 6c 6c 6f 20 70 65 65 72 2e 2e 2e |Hello peer... |
+--------+-------------------------------------------------+----------------+
[INFO ] 2017-07-06 22:50:54 netty.handler.udt.bytes.ByteEchoServerHandler ===Server reciever message:Hello peer...
[INFO ] 2017-07-06 22:50:54 io.netty.handler.logging.LoggingHandler [id: 0xf515214b, L:/192.168.31.153:10020 - R:/192.168.31.153:53767] WRITE: 16B
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 65 6c 6c 6f 20 63 6c 69 65 6e 74 20 2e 2e 2e |hello client ...|
+--------+-------------------------------------------------+----------------+
[INFO ] 2017-07-06 22:50:54 io.netty.handler.logging.LoggingHandler [id: 0xf515214b, L:/192.168.31.153:10020 - R:/192.168.31.153:53767] READ COMPLETE
[INFO ] 2017-07-06 22:50:54 io.netty.handler.logging.LoggingHandler [id: 0xf515214b, L:/192.168.31.153:10020 - R:/192.168.31.153:53767] FLUSH
[b]
客户端:[/b]
[INFO ] 2017-07-06 22:50:53 com.barchart.udt.SocketUDT library location : ./lib/bin
[INFO ] 2017-07-06 22:50:53 com.barchart.udt.SocketUDT loader provider : com.barchart.udt.lib.LibraryLoaderUDT
[INFO ] 2017-07-06 22:50:53 com.barchart.udt.lib.PluginPropsUDT ARCH/OS/LINK = amd64/Windows/gpp
[INFO ] 2017-07-06 22:50:53 com.barchart.udt.lib.LibraryLoaderUDT Platform supported.
[INFO ] 2017-07-06 22:50:53 com.barchart.udt.lib.LibraryLoaderUDT Loading release libraries.
[INFO ] 2017-07-06 22:50:53 com.barchart.udt.lib.LibraryLoaderUDT Release libraries loaded.
[INFO ] 2017-07-06 22:50:54 io.netty.handler.logging.LoggingHandler [id: 0xa43a1a55] REGISTERED
[INFO ] 2017-07-06 22:50:54 io.netty.handler.logging.LoggingHandler [id: 0xa43a1a55] CONNECT: /192.168.31.153:10020
[INFO ] 2017-07-06 22:50:54 netty.main.udt.bytes.ByteEchoClient =========UDT Client is start=========
[INFO ] 2017-07-06 22:50:54 io.netty.handler.logging.LoggingHandler [id: 0xa43a1a55, L:/192.168.31.153:53767 - R:/192.168.31.153:10020] ACTIVE
[INFO ] 2017-07-06 22:50:54 netty.handler.udt.bytes.ByteEchoClientHandler ECHO active
[id: 0x0d729ae4]
0) Maximum_Transfer_Unit = 1,500
1) Is_Send_Synchronous = false
2) Is_Receive_Synchronous = false
3) Custom_Congestion_Control = null
4) Flight_Window_Size = 25,600 (25 K)
5) Protocol_Send_Buffer_Size = 10,485,056
6) Protocol_Receive_Buffer_Size = 10,485,056
7) Time_To_Linger_On_Close = 0
8) System_Send_Buffer_Size = 1,048,576
9) System_Receive_Buffer_Size = 1,048,576
12) Is_Randezvous_Connect_Enabled = false
13) Send_Timeout = -1
14) Receive_Timeout = -1
15) Is_Address_Reuse_Enabled = true
16) Maximum_Bandwidth = -1
17) Status_Code = 5
18) Epoll_Event_Mask = 4
19) Send_Buffer_Consumed = 0
20) Receive_Buffer_Available = 0
[INFO ] 2017-07-06 22:50:54 io.netty.handler.logging.LoggingHandler [id: 0xa43a1a55, L:/192.168.31.153:53767 - R:/192.168.31.153:10020] WRITE: 13B
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 65 6c 6c 6f 20 70 65 65 72 2e 2e 2e |Hello peer... |
+--------+-------------------------------------------------+----------------+
[INFO ] 2017-07-06 22:50:54 io.netty.handler.logging.LoggingHandler [id: 0xa43a1a55, L:/192.168.31.153:53767 - R:/192.168.31.153:10020] FLUSH
[INFO ] 2017-07-06 22:50:54 io.netty.handler.logging.LoggingHandler [id: 0xa43a1a55, L:/192.168.31.153:53767 - R:/192.168.31.153:10020] READ: 16B
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 68 65 6c 6c 6f 20 63 6c 69 65 6e 74 20 2e 2e 2e |hello client ...|
+--------+-------------------------------------------------+----------------+
[INFO ] 2017-07-06 22:50:54 netty.handler.udt.bytes.ByteEchoClientHandler === reciever ack message from peer:hello client ...
[INFO ] 2017-07-06 22:50:54 io.netty.handler.logging.LoggingHandler [id: 0xa43a1a55, L:/192.168.31.153:53767 - R:/192.168.31.153:10020] READ COMPLETE

再来看一个peer对等UDT Byte Stream示例:
[b]peer端:[/b]
package netty.main.udt.peer;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.udt.UdtChannel;
import io.netty.channel.udt.nio.NioUdtProvider;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.util.concurrent.DefaultThreadFactory;
import netty.handler.udt.peer.ByteEchoPeerHandler;
import java.net.SocketAddress;
import java.util.concurrent.ThreadFactory;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
* UDT Byte Stream Peer
* @author donald
* 2017年7月3日
* 上午9:01:35
*/
public class ByteEchoPeerBase {
private static final Logger log = LoggerFactory.getLogger(ByteEchoPeerBase.class);
protected final String peerName;
protected final int messageSize;
protected final SocketAddress myAddress;
protected final SocketAddress peerAddress;

public ByteEchoPeerBase(String peerName,int messageSize, SocketAddress myAddress, SocketAddress peerAddress) {
this.peerName = peerName;
this.messageSize = messageSize;
this.myAddress = myAddress;
this.peerAddress = peerAddress;
}

@SuppressWarnings("deprecation")
public void run() throws Exception {
final ThreadFactory connectFactory = new DefaultThreadFactory("rendezvous");
final NioEventLoopGroup connectGroup = new NioEventLoopGroup(1,
connectFactory, NioUdtProvider.BYTE_PROVIDER);
try {
final Bootstrap bootstrap = new Bootstrap();
bootstrap.group(connectGroup)
.channelFactory(NioUdtProvider.BYTE_RENDEZVOUS)
.handler(new ChannelInitializer<UdtChannel>() {
@Override
protected void initChannel(UdtChannel ch) throws Exception {
ch.pipeline().addLast(
new LoggingHandler(LogLevel.INFO),
new ByteEchoPeerHandler(messageSize));
}
});
final ChannelFuture future = bootstrap.connect(peerAddress, myAddress).sync();
log.info("========="+peerName +" is start=========");
future.channel().closeFuture().sync();
} finally {
connectGroup.shutdownGracefully();
}
}
}


[b]peer one:[/b]
package netty.main.udt.peer;

import io.netty.util.internal.SocketUtils;
import netty.constant.udt.Config;

import java.net.InetSocketAddress;
import java.net.SocketAddress;

/**
* UDT Byte Stream Peer one
* @author donald
* 2017年7月3日
* 上午9:01:58
*/
public class ByteEchoPeerOne extends ByteEchoPeerBase {
private static final String PEER_NAME = "peerOne";
public ByteEchoPeerOne(int messageSize, SocketAddress myAddress, SocketAddress peerAddress) {
super(PEER_NAME,messageSize, myAddress, peerAddress);
}

public static void main(String[] args) throws Exception {
final int messageSize = 64 * 1024;
final InetSocketAddress myAddress = SocketUtils.socketAddress(Config.hostOne, Config.portOne);
final InetSocketAddress peerAddress = SocketUtils.socketAddress(Config.hostTwo, Config.portTwo);
new ByteEchoPeerOne(messageSize, myAddress, peerAddress).run();
}
}

[b]peer two:[/b]
package netty.main.udt.peer;

import io.netty.util.internal.SocketUtils;
import netty.constant.udt.Config;

import java.net.InetSocketAddress;
import java.net.SocketAddress;

/**
* UDT Byte Stream Peer two
* @author donald
* 2017年7月3日
* 上午9:02:14
*/
public class ByteEchoPeerTwo extends ByteEchoPeerBase {
private static final String PEER_NAME = "peerTwo";
public ByteEchoPeerTwo(int messageSize, SocketAddress myAddress, SocketAddress peerAddress) {
super(PEER_NAME,messageSize, myAddress, peerAddress);
}
public static void main(String[] args) throws Exception {
final int messageSize = 64 * 1024;
final InetSocketAddress myAddress = SocketUtils.socketAddress(Config.hostTwo, Config.portTwo);
final InetSocketAddress peerAddress = SocketUtils.socketAddress(Config.hostOne, Config.portOne);
new ByteEchoPeerTwo(messageSize, myAddress, peerAddress).run();
}
}


[b]peer ip和port配置:[/b]
package netty.constant.udt;

/**
* Peer to Peer Config
* @author donald
* 2017年7月3日
* 上午9:22:01
*/
public final class Config {
private Config() {
}
public static final String hostOne = "192.168.31.153";
public static final int portOne = 10010;
public static final String hostTwo = "192.168.31.153";
public static final int portTwo = 10011;

}

启动peer one&two,控制台输出:
[b]peer one:[/b]
[INFO ] 2017-07-06 22:54:56 com.barchart.udt.SocketUDT library location : ./lib/bin
[INFO ] 2017-07-06 22:54:56 com.barchart.udt.SocketUDT loader provider : com.barchart.udt.lib.LibraryLoaderUDT
[INFO ] 2017-07-06 22:54:56 com.barchart.udt.lib.PluginPropsUDT ARCH/OS/LINK = amd64/Windows/gpp
[INFO ] 2017-07-06 22:54:56 com.barchart.udt.lib.LibraryLoaderUDT Platform supported.
[INFO ] 2017-07-06 22:54:56 com.barchart.udt.lib.LibraryLoaderUDT Loading release libraries.
[INFO ] 2017-07-06 22:54:56 com.barchart.udt.lib.LibraryLoaderUDT Release libraries loaded.
[INFO ] 2017-07-06 22:54:56 io.netty.handler.logging.LoggingHandler [id: 0xbd0fcb89] REGISTERED
[INFO ] 2017-07-06 22:54:56 io.netty.handler.logging.LoggingHandler 17CONNECT218218[id: 0xbd0fcb89] CONNECT: /192.168.31.153:10011, /192.168.31.153:10010
[INFO ] 2017-07-06 22:55:03 netty.main.udt.peer.ByteEchoPeerBase =========peerOne is start=========
[INFO ] 2017-07-06 22:55:03 io.netty.handler.logging.LoggingHandler [id: 0xbd0fcb89, L:/192.168.31.153:10010 - R:/192.168.31.153:10011] ACTIVE
[INFO ] 2017-07-06 22:55:03 netty.handler.udt.peer.ByteEchoPeerHandler ECHO active
[id: 0x1c7738ed]
0) Maximum_Transfer_Unit = 1,500
1) Is_Send_Synchronous = false
2) Is_Receive_Synchronous = false
3) Custom_Congestion_Control = null
4) Flight_Window_Size = 25,600 (25 K)
5) Protocol_Send_Buffer_Size = 10,485,056
6) Protocol_Receive_Buffer_Size = 10,485,056
7) Time_To_Linger_On_Close = 0
8) System_Send_Buffer_Size = 1,048,576
9) System_Receive_Buffer_Size = 1,048,576
12) Is_Randezvous_Connect_Enabled = true
13) Send_Timeout = -1
14) Receive_Timeout = -1
15) Is_Address_Reuse_Enabled = true
16) Maximum_Bandwidth = -1
17) Status_Code = 5
18) Epoll_Event_Mask = 4
19) Send_Buffer_Consumed = 0
20) Receive_Buffer_Available = 0
[INFO ] 2017-07-06 22:55:03 io.netty.handler.logging.LoggingHandler [id: 0xbd0fcb89, L:/192.168.31.153:10010 - R:/192.168.31.153:10011] WRITE: 13B
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 65 6c 6c 6f 20 70 65 65 72 2e 2e 2e |Hello peer... |
+--------+-------------------------------------------------+----------------+
[INFO ] 2017-07-06 22:55:03 io.netty.handler.logging.LoggingHandler [id: 0xbd0fcb89, L:/192.168.31.153:10010 - R:/192.168.31.153:10011] FLUSH
[INFO ] 2017-07-06 22:55:03 io.netty.handler.logging.LoggingHandler [id: 0xbd0fcb89, L:/192.168.31.153:10010 - R:/192.168.31.153:10011] READ: 13B
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 65 6c 6c 6f 20 70 65 65 72 2e 2e 2e |Hello peer... |
+--------+-------------------------------------------------+----------------+
[INFO ] 2017-07-06 22:55:03 netty.handler.udt.peer.ByteEchoPeerHandler ===reciever message from UDT Byte Stream Peer:Hello peer...
[INFO ] 2017-07-06 22:55:03 io.netty.handler.logging.LoggingHandler [id: 0xbd0fcb89, L:/192.168.31.153:10010 - R:/192.168.31.153:10011] READ COMPLETE

[b]peer two:[/b]
[INFO ] 2017-07-06 22:55:02 com.barchart.udt.SocketUDT library location : ./lib/bin
[INFO ] 2017-07-06 22:55:02 com.barchart.udt.SocketUDT loader provider : com.barchart.udt.lib.LibraryLoaderUDT
[INFO ] 2017-07-06 22:55:02 com.barchart.udt.lib.PluginPropsUDT ARCH/OS/LINK = amd64/Windows/gpp
[INFO ] 2017-07-06 22:55:02 com.barchart.udt.lib.LibraryLoaderUDT Platform supported.
[INFO ] 2017-07-06 22:55:02 com.barchart.udt.lib.LibraryLoaderUDT Loading release libraries.
[INFO ] 2017-07-06 22:55:02 com.barchart.udt.lib.LibraryLoaderUDT Release libraries loaded.
[INFO ] 2017-07-06 22:55:03 io.netty.handler.logging.LoggingHandler [id: 0x703f93fe] REGISTERED
[INFO ] 2017-07-06 22:55:03 io.netty.handler.logging.LoggingHandler 17CONNECT218218[id: 0x703f93fe] CONNECT: /192.168.31.153:10010, /192.168.31.153:10011
[INFO ] 2017-07-06 22:55:03 netty.main.udt.peer.ByteEchoPeerBase =========peerTwo is start=========
[INFO ] 2017-07-06 22:55:03 io.netty.handler.logging.LoggingHandler [id: 0x703f93fe, L:/192.168.31.153:10011 - R:/192.168.31.153:10010] ACTIVE
[INFO ] 2017-07-06 22:55:03 netty.handler.udt.peer.ByteEchoPeerHandler ECHO active
[id: 0x02f505e9]
0) Maximum_Transfer_Unit = 1,500
1) Is_Send_Synchronous = false
2) Is_Receive_Synchronous = false
3) Custom_Congestion_Control = null
4) Flight_Window_Size = 25,600 (25 K)
5) Protocol_Send_Buffer_Size = 10,485,056
6) Protocol_Receive_Buffer_Size = 10,485,056
7) Time_To_Linger_On_Close = 0
8) System_Send_Buffer_Size = 1,048,576
9) System_Receive_Buffer_Size = 1,048,576
12) Is_Randezvous_Connect_Enabled = true
13) Send_Timeout = -1
14) Receive_Timeout = -1
15) Is_Address_Reuse_Enabled = true
16) Maximum_Bandwidth = -1
17) Status_Code = 5
18) Epoll_Event_Mask = 4
19) Send_Buffer_Consumed = 0
20) Receive_Buffer_Available = 0
[INFO ] 2017-07-06 22:55:03 io.netty.handler.logging.LoggingHandler [id: 0x703f93fe, L:/192.168.31.153:10011 - R:/192.168.31.153:10010] WRITE: 13B
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 65 6c 6c 6f 20 70 65 65 72 2e 2e 2e |Hello peer... |
+--------+-------------------------------------------------+----------------+
[INFO ] 2017-07-06 22:55:03 io.netty.handler.logging.LoggingHandler [id: 0x703f93fe, L:/192.168.31.153:10011 - R:/192.168.31.153:10010] FLUSH
[INFO ] 2017-07-06 22:55:03 io.netty.handler.logging.LoggingHandler [id: 0x703f93fe, L:/192.168.31.153:10011 - R:/192.168.31.153:10010] READ: 13B
+-------------------------------------------------+
| 0 1 2 3 4 5 6 7 8 9 a b c d e f |
+--------+-------------------------------------------------+----------------+
|00000000| 48 65 6c 6c 6f 20 70 65 65 72 2e 2e 2e |Hello peer... |
+--------+-------------------------------------------------+----------------+
[INFO ] 2017-07-06 22:55:03 netty.handler.udt.peer.ByteEchoPeerHandler ===reciever message from UDT Byte Stream Peer:Hello peer...
[INFO ] 2017-07-06 22:55:03 io.netty.handler.logging.LoggingHandler [id: 0x703f93fe, L:/192.168.31.153:10011 - R:/192.168.31.153:10010] READ COMPLETE
Netty入门-选择Netty的理由 前言 网络编程无处不在,Java JDK内置提供了OIO(BIO)、NIO的支持;没有看过Java BIO浅析、Java NIO浅析的小伙伴可以去看下BIO/NIO的小示例。但说到Java 网络编程少不了Netty;自它问世起就一直火到现在,像阿里的Dubbo框架、Jetty等都使用了Netty框架做为网络通信框架。 上篇Netty框架:用Service与Client示例入门中通过实现一个服务端与客户端互发消息功能的示例讲解了Netty框架NIO模型的网络编程方法,通过这样一个小示例了解决了Netty的使用 阅读详情

相关推荐

UDT-基于UDP的可靠数据传输协议【中文版】

本文档描述了UDT数据传输协议。UDT被设计为一种用于TCP数据传输协议不能高效运行场合下的替代方案。UDT可有效克服TCP在高带宽延迟(BDP)网络环境中的低效率传输问题,这也是开发UDT的初衷。另一个重要的应用场景是,允许网络研究人员、学生和应用程序开发人员在UDT框架下轻松地实现和部署新的数据传输算法和协议。此外,UDT也可用于更好地支持防火墙穿透。 UDT完全构建在UDP之上。但是,UDT是有连接的,支持单播(不支持多播),数据收发全双工。它支持可靠的数据流传输和部分可靠的消息传递。拥塞控制模块是一个开放的框架,可以用来实现和部署不同的控制算法。UDT采用AIMD速率拥塞控制算法作为原生、默认的控制算法。

netty系列之:请netty再爱UDT一次

文章目录简介netty对UDT的支持搭建一个支持UDT的netty服务异常来袭TypeUDT和KindUDT构建ChannelFactorySelectorProviderUDT使用UDT总结 简介 UDT是一个非常优秀的协议,可以提供在UDP协议基础上进行高速数据传输。但是可惜的是在netty 4.1.7中,UDT传输协议已经被标记为Deprecated了! 意味着在后面的netty版本中,你可能再也看不到UDT协议了. 优秀的协议怎么能够被埋没,让我们揭开UDT的面纱,展示其优秀的特性,让netty再爱

程序那些事 7031

netty-transport-udt-4.0.0.CR4.zip

spring-context-template.zip,本项目的目的是提供一个可重用的spring配置模块模板机制,用于创建基于xml的spring上下文定义。

netty系列之:真正的平等–UDT中的Rendezvous

文章目录简介建立支持Rendezvous的服务器处理不同的消息节点之间的交互总结 简介 在我们之前提到的所有netty知识中,netty好像都被分为客户端和服务器端两部分。服务器端监听连接,并对连接中的消息进行处理。而客户端则向服务器端建立请求连接,从而可以发送消息。 但是这一切都要在UDT协议中被终结,因为UDT提供了Rendezvous,一种平等的连接类型,节点之间是对等关系。 从来都没有救世主,也没有神仙和皇帝,只有同为节点的好兄弟。 建立支持Rendezvous的服务器 因为是对等的关系,所以这里不

程序那些事 4006

达梦数据库(DM)的备份与恢复功能

本文系统介绍了达梦数据库(DM)的备份与恢复功能,主要包括作业系统和物理/逻辑备份还原两大模块。作业系统部分详细说明了通过代理环境创建定时备份和删除备份作业的步骤;物理备份还原部分阐述了联机和脱机备份方式,包括数据库、表空间、表和归档的备份还原操作;逻辑备份还原部分介绍了dexp/dimp工具的使用方法及四种级别的导入导出功能。文章还介绍了图形化管理工具进行备份还原的操作流程,全面覆盖了达梦数据库的数据保护方案,为数据库管理员提供了详细的技术指导。

weixin_48812832的博客 1209

手把手教你用QEMU虚拟化华为路由器固件(附完整网络配置指南)

本文提供了一份详尽的QEMU虚拟化华为路由器固件的实战指南。从固件解包、网络桥接配置到QEMU虚拟机启动,手把手教你搭建完整的嵌入式设备沙箱环境,特别适合安全研究、逆向分析和学习嵌入式系统工作原理。

tgb3456789的博客 937

netty系列之:选byte还是选message?这是一个问题

简介 UDT给了你两种选择,byte stream或者message,到底选哪一种呢?经验告诉我们,只有小学生才做选择题,而我们应该全都要! 类型的定义 UDT的两种类型是怎么定义的呢? 翻看com.barchart.udt包,可以发现这两种类型定义在TypeUDT枚举类中。 STREAM(1), DATAGRAM(2), 复制代码 一个叫做STREAM,它的code是1。一个叫做DATAGRAM,他的code是2. 根据两个不同的类型我们可以创建不同的selectorProvider

yangjnsjbad的博客 448

CentOS校园网Web Portal认证自动化实战

Web Portal认证是一种基于HTTP重定向与表单提交的强制网络准入机制,其原理是网关劫持未认证流量并跳转至登录页,验证通过后通过Cookie维持会话授权。该技术广泛应用于高校、机场、酒店等场景,核心价值在于细粒度访问控制与用户身份绑定。典型应用包括Linux命令行环境下的校园网接入、无GUI设备的自动联网、以及实验室集群的集中认证管理。本文聚焦CentOS系统,深入解析curl、cookie持久化、动态表单参数提取等关键技术环节,提供可调试、可复现、可工程化的完整认证流水线。

weixin_30522983的博客 264

1、netty系列-计算机网络通信及TCP/IP协议详细知识点

计算机网络是通过通信线路将地理上分散的计算机系统和通信设备连接起来,以实现资源共享和信息传递的系统。局域网(LAN):作用范围一般为几米到几十公里,通常用于企业、学校或家庭内部的网络。城域网(MAN):作用范围介于局域网和广域网之间,通常覆盖一个城市或大都市区。广域网(WAN):作用范围一般为几十到几千公里,覆盖范围可以跨越城市、国家甚至大陆。按拓扑结构:如总线型、环型、星型、网状。按信息的交换方式:如电路交换、报文交换、报文分组交换。

qq_29434541的博客 1047

ChatGPT搭配Claude 4写文献综述效果出奇的好!四步法直接写出逻辑清晰、层次分明的文献综述(附复制即用专业提示词)

请梳理【研究领域】中核心理论的发展演进过程,包括每一阶段理论的核心观点、提出背景与推动力,并指出理论演化中的关键节点或范式转变。请根据以下文献摘要内容,帮助我梳理该主题的研究趋势,包括:常见研究视角、研究方法的演变、研究对象的变化方向等。请根据以下研究空白与我已有的研究基础,帮我生成一个清晰的研究定位,包括:研究主题、研究对象、方法路径和理论框架。先要明确这个研究领域中一个主导或热门的理论,比如社会支持理论、认知负荷理论等,强调这个理论内部的不一致性、适用性争议,通过交代这⼀争议的背景,引发读者兴趣。

智能AI让学术科研更容易 568

光通量与辐射通量之间的换算

由理论和实验可知存在两种定义: 1W1W1W(瓦特)的频率为540×1012Hz540\times10^{12}Hz540×1012Hz(赫兹)的单色辐射的辐射通量等于683lm(流明)683lm(流明)683lm(流明).。 1lm1lm1lm的频率为540×1012Hz540\times10^{12}Hz540×1012Hz的单色通量等于1683=0.001464W\frac{1}{683}=0.001464W6831​=0.001464W。 从上述定义中我们可以得到什么呢?我们知道光速: c=3×

u011699626的博客 3270

netty 监听多个udp端口_【NIO系列】——之Netty

这是NIO系列的第四篇,欢迎继续关注:【NIO系列】——之TCP探秘【NIO系列】——之IO模型【NIO系列】——之Reactor模型如果你看过前面三篇文章,我们从最低层来分解NIO底层原理和使用方式,帮忙我们理解了NIO是什么,解决了什么问题,以及又有那些不足。原则上NIO的出现,已经提升和加快了网络IO的处理方式,但它只能帮忙我们解决了IO层次的读写问题,在软件层次上我们需要更好的编程架构模型...

weixin_39644713的博客 1062

泛微系统流程表单获取节点操作者

泛微系统流程表单获取节点操作者 select typename 流程类型, workflowname 流程名称, nodename 节点名称, (case when nodetype=0 then '创建' when nodetype=1 then '审批' when nodetype=2 then '提交' when nodetype=3 then '归档' else '' end) as 节点类型, groupname 节点操作组, (case when type=1 then '部门+安

烧硬盘 4611

【Netty】——之Netty(what、why、how)

目录 一、netty是什么 1、是什么 2、有何不同 二、为何要用Netty 1.Fast 2.更少的内存使用 3.Easy,快速开发 4.可靠稳定 三、如何用 四、最后 原则上NIO的出现,已经提升和加快了网络IO的处理方式,但它只能帮忙我们解决了IO层次的读写问题,在软件层次上我们需要更好的编程架构模型,来解决扩展性以及高并发的问题。Netty正是用来解决这些问题的,这一...

凡是过往,皆为序章 285

GEE案例:计算区域生态总体脆弱性分析

计算区域生态总体脆弱性分析需要考虑多个指标和因素。下面是一个基本的方法:选择指标:选择一组能够反映区域生态系统脆弱性的指标。这些指标可以包括生物多样性指数、森林覆盖率、湿地保护率、土地退化程度等。为每个指标分配权重:为了使得各指标在计算中的重要性相对均衡,可以为每个指标分配一个权重。权重可以根据各指标的重要性和可利用的数据进行确定。数据收集和处理:收集每个指标的数据,并对其进行处理,确保数据的准确性和一致性。如果有需要,可以对数据进行归一化处理。计算指标值:根据收集的数据和权重,计算每个指标的值。

此星光明博客 464

6-2 GPU GART 绑定机制与 TLB 失效

本文详细解析了AMD GPU的GART(Graphics Address Remapping Table)绑定机制实现。主要内容包括: 绑定流程:从ttm_tt_bind()到硬件PTE更新的完整调用链,重点分析amdgpu_gart_bind()函数实现。 关键函数: amdgpu_gart_bind():执行安全检查、记录映射关系、更新页表等操作 amdgpu_gart_map():将CPU页映射为多个GPU页并填充PTE amdgpu_gmc_set_pte_pde():处理硬件特定的PTE格式 内存

图形/计算GPU的驱动与虚拟化技术分享园地 2644

Java-68 深入浅出 分布式服务 Netty实现自定义RPC 附详细代码

Netty 是基于 Java NIO 的高性能网络通信框架,采用异步事件驱动模型,简化高并发网络程序开发。通过封装 I/O 多路复用、缓冲区管理、线程调度等底层机制,开发者只需关注业务逻辑。借助 Netty 可构建高效稳定的 RPC 框架:定义公共接口,服务端实现接口并通过 Netty 启动监听,客户端利用动态代理调用远程方法,底层通过 TCP 协议传输自定义消息并返回结果。该方式可实现服务间解耦、高并发通信和跨 JVM 分布式调用,适用于微服务架构中的内部通信。

谢谢你的喜欢 我们一起无限进步 1497

android 蓝牙通讯demo

android 下蓝牙通讯demo,实现了发现蓝牙,使能蓝牙,通过蓝牙发送消息。

【NIO系列】——之Netty(四)

这是NIO系列的第四篇,欢迎继续关注: 【NIO系列】——之TCP探秘 【NIO系列】——之IO模型 【NIO系列】——之Reactor模型 如果你看过前面三篇文章,我们从最低层来分解NIO底层原理和使用方式,帮忙我们理解了NIO是什么,解决了什么问题,以及又有那些不足。 原则上NIO的出现,已经提升和加快了网络IO的处理方式,但它只能帮忙我们解决了IO层次的读写问题,在软件层次上我们需要更好的编程架构模型,来解决扩展性以及高并发的问题。Netty正是用来解决这些问题的,这一篇我们将详细介绍Nett

Java圈全能架构师的博客 547

温度PID控制PLC程序

温度PID稳定控制程序,适用于欧姆龙PLC,对其他PLC也具有很大参考价值

华为的C语言编程规范.pdf

华为技术有限公司内部技术规范。本规范制定了编写C语言程序的基本原则、规则和建议。从代码的清晰、简洁、可测试、安全、程序效率、可移植各个方面对C语言编程作出了具体指导。

Java-67 深入浅出 分布式服务 Netty 实现服务端与客户端 附Java代码

Netty 是一个基于 Java NIO 的高性能网络通信框架,具备异步非阻塞、事件驱动等特性,广泛用于高并发场景下的网络开发。其内部采用 Reactor 模型与线程池协作,封装了底层的 I/O 多路复用、缓冲区管理与协议编解码,极大简化了开发难度。核心结构包括 Channel、EventLoop、Pipeline、ByteBuf 等,支持 Epoll、KQueue、io_uring 等平台优化。Netty 提供了零拷贝、内存池、动态编解码等高级特性,支持 HTTP/1.1、WebSocket、HTTP/2

谢谢你的喜欢 我们一起无限进步 884

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

网络(六)——netty

目录一、netty是什么1、是什么2、有何不同二、为何要用Netty1、快2、更少的内存使用3、快速开发4、可靠稳定三、如何用四、源码 原则上NIO的出现,已经提升和加快了网络IO的处理方式,但它只能帮忙我们解决了IO层次的读写问题,在软件层次上我们需要更好的编程架构模型,来解决扩展性以及高并发的问题。Netty正是用来解决这些问题的,这一篇我们将详细介绍Netty的知识点; 一、netty是什么...

中都 1195

什么时候会用到netty开发服务器?

定义 Netty是异步的 事件驱动的基于NIO实现的开源框架,用以快速轻松的实现高性能、高可靠性的网络客户端和服务器端最基础的通信组件,通俗的讲:Netty是Jboss开发做的JAR包,很好的封装了Socket,处理网络通信的一个开源通信框架。 一、Netty的特性 1)设计 统一的API,适用于不同的协议(阻塞和非阻塞) 基于灵活、可扩展的事件驱动模型 高度可定制的线程模型 可靠的无连接数据So...

xihuanyuye的博客 2264

详解即时通讯开发框架Netty 4.x之Channel和Pipeline

在这个过程中,我也是捡简单的、流程性的代码总结,像EventLoop、EventExecutor这种核心部分并没有深入总结,压后再详细解说。write不会主动flush。从逻辑的角度,它则是netty的逻辑处理链,每个节点均包含一个逻辑处理器(ChannelHandler),用以实现网络通信的编/解码、处理等功能。从AbstractChannel分析,它提供了一些IO操作方法,read、write等,Channel仅仅做了一个封装,方法中将参数直接传递给了Channel的Pipeline成员的相应方法。

蔚可云的博客 544

Netty 通道处理器ChannelHandler和适配器定义ChannelHandlerAdapter

:[url]http://donald-draper.iteye.com/blog/2383392[/url] netty 网络通信示例四:[url]http://donald-draper.iteye.com/blog/2383472[/url] Netty 构建HTTP服务器示例:[url]http://donald-draper.iteye.com/blog/2383527[/url] Netty UDT网络通信示例:[url]http://donald-draper.iteye.com/blo

Donald_Draper的专栏 2722

【NIO系列】——之Netty

这是NIO系列的第四篇,欢迎继续关注:【NIO系列】——之TCP探秘【NIO系列】——之IO模型【NIO系列】——之Reactor模型如果你看过前面三篇文章,我们从最低层来分解NIO底层原理和使用方式,帮忙我们理解了NIO是什么,解决了什么问题,以及又有那些不足。原则上NIO的出现,已经提升和加快了网络IO的处理方式,但它只能帮忙我们解决了IO层次的读写问题,在软件层次上我们需要更好的编程架构模型...

weixin_33672400的博客 330

为什么说mpush是分布式消息推送的最佳选择?

还在为构建实时通信系统而烦恼吗?面对高并发、多平台、低延迟的推送需求,传统方案往往力不从心。今天我们要介绍的开源项目mpush,或许正是你一直在寻找的解决方案。 ## mpush的核心优势是什么? ### 高性能架构设计 mpush基于Netty构建异步网络通信框架,采用主备模式的分布式集群设计。系统支持动态扩容缩容,能够轻松应对流量波动,在百万级并发连接下依然保持稳定运行。 ### 多协议

gitblog_00012的博客 459

Netty实例

Netty是基于JDK NIO的网络框架 简化了NIO编程, 不用程序自己维护selector, 将网络通信和数据处理的部分做了分离 多用于做底层的数据通信, 心跳检测(keepalived) 1. 数据通信 1.1 Hello World public class Server { public static void main(String[] args)...

weixin_33670713的博客 613
上一篇: Netty 构建HTTP服务器示例
下一篇: No operation was found with the name解决方法总结
Donald_Draper
博客等级 码龄14年 9粉丝 106原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符  | 博主筛选后可见
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值