使用之前首先需要Netty的Maven包:
<dependency>
<groupId>io.netty</groupId>
<artifactId>netty-all</artifactId>
<version>4.1.84.Final</version>
</dependency>
GitHub地址:
https://github.com/zhao458114067/netty-demo
服务声明类,TcpServer.class
package com.supcon.supfusion.oms.tankinfo.service.closedpath.tcp;
import cn.hutool.core.collection.CollectionUtil;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import lombok.extern.slf4j.Slf4j;
import java.util.Map;
/**
* @author ZhaoXu
* @date 2022/11/22 16:42
*/
@Slf4j
public class TcpServer {
private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();
private EventLoopGroup bossGroup;
private EventLoopGroup workerGroup;
private ServerBootstrap server;
private ChannelFuture channelFuture;
private Integer port;
public TcpServer(Integer port) {
this.port = port;
// nio连接处理池
this.bossGroup = new NioEventLoopGroup();
// 处理事件池
this.workerGroup = new NioEventLoopGroup();
server = new ServerBootstrap();
server.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
// 自定义处理类
ch.pipeline().addLast(new TcpServerHandler());
ch.pipeline().addLast(new NettyDecoder());
ch.pipeline().addLast(new NettyEncoder());
}
});
server.option(ChannelOption.SO_BACKLOG, 128);
server.childOption(ChannelOption.SO_KEEPALIVE, true);
}
public synchronized void startListen() {
try {
// 绑定到指定端口
channelFuture = server.bind(port).sync();
log.info("netty服务器在[{}]端口启动监听", port);
} catch (Exception e) {
log.error("netty服务器在[{}]端口启动监听失败", port);
e.printStackTrace();
}
}
public void sendMessageToClient(String clientIp, Object msg) {
Map<String, Channel> channelMap = TcpServerHandler.channelSkipMap.get(port);
Channel channel = channelMap.get(clientIp);
String sendStr;
try {
sendStr = OBJECT_MAPPER.writeValueAsString(msg);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
try {
log.info("向客户端 {} 发送消息内容:{}", clientIp, sendStr);
channel.writeAndFlush(sendStr);
} catch (Exception var4) {
log.error("向客户端 {} 发送消息失败,消息内容:{}", clientIp, sendStr);
throw new RuntimeException(var4);
}
}
public void pushMessageToClients(Object msg) {
Map<String, Channel> channelMap = TcpServerHandler.channelSkipMap.get(port);
if (CollectionUtil.isNotEmpty(channelMap)) {
channelMap.forEach((k, v) -> sendMessageToClient(k, msg));
}
}
}
handler接收处理类,继承SimpleChannelInboundHandler
package com.supcon.supfusion.oms.tankinfo.service.closedpath.tcp;
import cn.hutool.core.collection.CollectionUtil;
import io.netty.buffer.ByteBuf;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import lombok.extern.slf4j.Slf4j;
import java.net.InetSocketAddress;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentSkipListMap;
/**
* @author ZhaoXu
* @date 2022/11/22 16:43
*/
@Slf4j
public class TcpServerHandler extends SimpleChannelInboundHandler<Object> {
/**
* 用跳表存储连接channel
*/
public static Map<Integer, Map<String, Channel>> channelSkipMap = new ConcurrentSkipListMap<>();
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
log.error("应用程序的监听通道异常!");
cause.printStackTrace();
}
@Override
public void handlerAdded(ChannelHandlerContext ctx) throws Exception {
Channel channel = ctx.channel();
// 获取每个用户端连接的ip
InetSocketAddress ipSocket = (InetSocketAddress) channel.remoteAddress();
String clientIp = ipSocket.getAddress().getHostAddress();
InetSocketAddress localSocket = (InetSocketAddress) channel.localAddress();
// 本地端口做键
int localPort = localSocket.getPort();
Map<String, Channel> channelMap = channelSkipMap.get(localPort);
if (CollectionUtil.isEmpty(channelMap)) {
channelMap = new HashMap<>(4);
}
channelMap.put(clientIp, channel);
channelSkipMap.put(localPort, channelMap);
log.info("应用程序添加监听通道,与客户端:{} 建立连接成功!", clientIp);
}
@Override
public void handlerRemoved(ChannelHandlerContext ctx) throws Exception {
// 获取每个用户端连接的ip
Channel channel = ctx.channel();
InetSocketAddress localSocket = (InetSocketAddress) channel.localAddress();
int localPort = localSocket.getPort();
InetSocketAddress ipSocket = (InetSocketAddress) channel.remoteAddress();
String clientIp = ipSocket.getAddress().getHostAddress();
Map<String, Channel> channelMap = channelSkipMap.get(localPort);
channelMap.remove(clientIp);
log.info("应用程序移除监听通道,与客户端:{} 断开连接!", clientIp);
}
@Override
protected void channelRead0(ChannelHandlerContext channelHandlerContext, Object msg) throws Exception {
ByteBuf buf = (ByteBuf) msg;
byte[] req = new byte[buf.readableBytes()];
buf.readBytes(req);
String result = new String(req, StandardCharsets.UTF_8);
log.info("接收到应用数据:{}", result);
}
}
编码器 NettyEncoder
package com.supcon.supfusion.oms.tankinfo.service.closedpath.tcp;
import com.supcon.supfusion.oms.tankinfo.service.closedpath.ClosedPathConstants;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.PooledByteBufAllocator;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;
/**
* @author ZhaoXu
* @date 2022/11/8 16:23
*/
public class NettyEncoder extends MessageToByteEncoder<String> {
@Override
protected void encode(ChannelHandlerContext ctx, String msg, ByteBuf out) throws Exception {
byte[] byteMsg = msg.getBytes(ClosedPathConstants.CHARSET_GBK);
int msgLength = byteMsg.length;
ByteBuf buf = PooledByteBufAllocator.DEFAULT.buffer(4 + byteMsg.length);
buf.writeInt(msgLength);
buf.writeBytes(byteMsg);
out.writeBytes(buf);
buf.release();
}
}
解码器 NettyDecoder
package com.supcon.supfusion.oms.tankinfo.service.closedpath.tcp;
import com.supcon.supfusion.oms.tankinfo.service.closedpath.ClosedPathConstants;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import lombok.extern.slf4j.Slf4j;
import java.util.List;
/**
* @author ZhaoXu
* @date 2022/11/22 17:03
*/
@Slf4j
public class NettyDecoder extends ByteToMessageDecoder {
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
int beginReader = in.readerIndex();
int dataLength = in.readInt();
if (in.readableBytes() < dataLength) {
in.readerIndex(beginReader);
} else {
byte[] data = new byte[dataLength];
in.readBytes(data);
String str = new String(data, 0, dataLength, ClosedPathConstants.CHARSET_GBK);
out.add(str);
}
}
}
使用的时候:
TcpServer tcpServer = new TcpServer(40004);
tcpServer.startListen();
TcpClient.class
package com.supcon.supfusion.dataforward.tcp;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.supcon.supfusion.dataforward.constants.Constants;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import lombok.extern.slf4j.Slf4j;
/**
* @author ZhaoXu
* @date 2022/11/8 13:39
*/
@Slf4j
public class TcpClient {
private EventLoopGroup group;
private ChannelFuture channelFuture;
private final String ip;
private final Integer port;
private final ObjectMapper objectMapper = new ObjectMapper();
public Long lastUseTime = 0L;
public TcpClient(String ip, Integer port) {
this.ip = ip;
this.port = port;
}
/**
* 建立连接
*
*/
public synchronized void connectServer() {
log.info("开始建立连接,ip:{}, port:{}", ip, port);
// 生命nio连接池
this.group = new NioEventLoopGroup();
try {
Bootstrap b = new Bootstrap();
// 配置解码器以及消息处理类
b.group(this.group)
.channel(NioSocketChannel.class)
.option(ChannelOption.TCP_NODELAY, true)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast(new TcpClientHandler());
pipeline.addLast(new NettyEncoder());
pipeline.addLast(new NettyDecoder());
}
});
// 开始连接
this.channelFuture = b.connect(ip, port).sync();
} catch (Exception var4) {
log.error("连接建立失败,ip:{}, port:{}", ip, port);
this.group.shutdownGracefully();
var4.printStackTrace();
}
}
/**
* 关闭连接
*/
public void close() {
this.group.shutdownGracefully();
}
/**
* 发送消息
*
* @param msg
*/
public synchronized void sendCommonMsg(Object msg) {
String sendStr;
if (!Constants.CONNECTED_STATUS.equals(getConnectStatus())) {
connectServer();
}
try {
sendStr = objectMapper.writeValueAsString(msg);
} catch (JsonProcessingException e) {
throw new RuntimeException(e);
}
try {
log.info("发送消息内容:{}", sendStr);
this.channelFuture.channel().writeAndFlush(sendStr);
} catch (Exception var4) {
log.error("发送消息失败,消息内容:{}", sendStr);
throw new RuntimeException(var4);
}
}
/**
* 获取当前连接状态
*/
public Boolean getConnectStatus() {
return group != null && !group.isShutdown() && !group.isShuttingDown();
}
}
客户端也需要使用编码器与解码器,将服务端的拷过来就可以,双向通信时也需要继承SimpleChannelInboundHandler处理类处理消息
使用:
TcpClient tcpClient = new TcpClient("192.168.89.138", 40004);
tcpClient.connectServer();
Channel
Channel 是 Netty 网络操作抽象类,它除了包括基本的 I/O 操作,如 bind、connect、read、write 之外,还包括了 Netty 框架相关的一些功能,如获取该 Channe l的 EventLoop
ChannelFuture
Netty 为异步非阻塞,即所有的 I/O 操作都为异步的,因此,我们不能立刻得知消息是否已经被处理了。Netty 提供了 ChannelFuture 接口,通过该接口的 addListener() 方法注册一个 ChannelFutureListener,当操作执行成功或者失败时,监听就会自动触发返回结果
EventLoop
Netty 基于事件驱动模型,使用不同的事件来通知我们状态的改变或者操作状态的改变。它定义了在整个连接的生命周期里当有事件发生的时候处理的核心抽象
Channel 为Netty 网络操作抽象类,EventLoop 主要是为Channel 处理 I/O 操作,两者配合参与 I/O 操作
当一个连接到达时,Netty 就会注册一个 Channel,然后从 EventLoopGroup 中分配一个 EventLoop 绑定到这个Channel上,在该Channel的整个生命周期中都是有这个绑定的 EventLoop 来服务的
ChannelHandler
ChannelHandler 为 Netty 中最核心的组件,它充当了所有处理入站和出站数据的应用程序逻辑的容器。ChannelHandler 主要用来处理各种事件,这里的事件很广泛,比如可以是连接、数据接收、异常、数据转换等。
ChannelHandler 有两个核心子类 ChannelInboundHandler 和 ChannelOutboundHandler,其中 ChannelInboundHandler 用于接收、处理入站数据和事件,而 ChannelOutboundHandler 则相反
ChannelPipeline
ChannelPipeline 为 ChannelHandler 链提供了一个容器并定义了用于沿着链传播入站和出站事件流的 API
一个数据或者事件可能会被多个 Handler 处理,在这个过程中,数据或者事件经流 ChannelPipeline,由 ChannelHandler 处理。在这个处理过程中,一个 ChannelHandler 接收数据后处理完成后交给下一个 ChannelHandler,或者什么都不做直接交给下一个 ChannelHandler