基于Netty实现TCP连接的服务端、客户端

简介

Netty是一个异步事件驱动的网络应用框架,可快速开发可维护的高性能协议服务器和客户端。基于NIO实现的高性能网络IO框架,极大简化基于常用网络协议的编程(TCP、UDP等)。

架构模型

完整版:

基于Netty实现TCP连接的服务端、客户端_第1张图片

根据自己的理解,简单版的工作模型架构图:

基于Netty实现TCP连接的服务端、客户端_第2张图片

如上图所示,Netty是基于主从Reactor的架构模型;主EventLoopGroup负责处理客户端的连接请求事件,客户端连接成功后交由从EventLoopGroup,具体的数据IO由从EventLoopGroup的EventLoop处理。

EventLoop顾名思义为事件循环,它的工作就是循环监听事件;

每个EventLoop中有自己的Channel(通道),Channel中包含Pipeline(管道),Pipeline是数据传输的管道,二者为一一对应关系;在Pipeline中可添加多个handler,对Pipeline中的出站、入站数据处理,所有handler由Pipeline中的一个双向链表管理,入站数据顺着链表顺序依次被所有的ChannelInboundHandler处理,出站数据逆着链表顺序被所有的ChannelOutboundHandler处理。

入站:对服务端或者客户端来说,数据传入则为入站

出站:对服务端或者客户端来说,数据写出则为出站

比如,客户端向服务端发送数据时,对客户端来说是出站,对服务端来说是入站。

主要模块

  • BootStrap、ServerBootStrap

    Netty的启动器类,将多个EventLoopGroup组合起来,并引导其启动运行。

  • NioEventLoopGroup

    类似一个线程池,管理内部的EventLoop的调度。

  • NioEventLoop

    顾名思义,是一个事件循环,其工作就是循环的获取连接设备的事件。其内部维护一个Selector用来监听Channel,和一个TaskQueue用于处理IO事件。

  • Channel

    数据传输的通道,更多的是对数据传输通道的状态、行为控制;

  • ChannelFuture

    异步任务的返回值,相当于是一个票据,凭票据可以在未来获取异步任务的执行结果。和JUC中的Future一样。

  • ChannelPipeline

    管理出站入站的各类ChannelHandler,将管理的ChannelHandler应用到对应通道的出站入站数据,对数据进行处理。

  • ChannelHandler

    处理具体的IO事件,一般用来对IO数据流编解码、转换、处理等操作。


下面开始实操,实现一个TCP服务器

服务端实现

启动引导类实现
public class ChatServer {
    private Integer port;
    private ServerBootstrap serverBootstrap;
    public ChatServer(Integer port) {
        if (null == port) {
            throw new NettyChatException("服务端口为空");
        }
        this.port = port;
        this.serverBootstrap = setup();
    }
    private ServerBootstrap setup() {
      	//负责接收客户端连接请求的group
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
      	//负责和客户端数据交互的group
        EventLoopGroup workerGroup = new NioEventLoopGroup();
      	//ServerBootstrap是一个启动器类,用来启动EventLoopGroup
        return new ServerBootstrap().group(bossGroup, workerGroup)
                .channel(NioServerSocketChannel.class)
                .childHandler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel socketChannel) throws Exception {
                        ChannelPipeline pipeline = socketChannel.pipeline();
                      	//添加解码器,将数据从byte解析为对象
                        pipeline.addLast(new ByteToChatMessageDecoder());
                      	//自定义handler,处理业务相关
                        pipeline.addLast(new ServerChatMessageReadHandler());
                    }
                });
    }

    public void run() throws InterruptedException {
        serverBootstrap.bind(port).sync()
                .channel().closeFuture().sync();
    }
}	
自定义解码器,解决粘包、拆包

什么是粘包、拆包?

通过TCP协议进行数据发送时候,由于数据的大小不一定,数据太小时有可能会将多个数据包一起发送,数据太大有可能会把数据包拆分后发送。但是对于数据接收端来说,并不知道数据究竟是如何划分,有可能接收的是一个被拆分后的数据包,也有可能是一个由多个数据包拼接一起的数据包,这就是拆包和粘包。

Netty实现的粘包、拆包解决方案

  • FixedLengthFrameDecoder 定长读取
  • LineBasedFrameDecoder 按行读取
  • DelimiterBasedFrameDecoder 按自定义分割符读取
  • LengthFieldBasedFrameDecoder 将数据包的长度作为头部传输,接收方得到长度后在按长度读取

下面的自定义解码器,解决粘包、拆包的方案类似于LengthFieldBasedFrameDecoder,通过自定义协议将数据长度和数据一起发送。

//主要功能:
//1.将接收到的ByteBuf转换为数据字符串
//2.解决粘包、拆包的问题
//3.将处理后的对象交到handler链中下一个handler处理
public class ByteToChatMessageDecoder extends ByteToMessageDecoder {
    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List<Object> out) throws Exception {
        if (in == null) return;
      	//因为使用自定义协议解决粘包、拆包问题,自定义协议内部先传输数据长度,所以需在这里先接收长度
        if (in.readableBytes() <= 4) return;;
        in.markReaderIndex();
        int len = in.readInt();
        if (in.readableBytes() < len) {
            in.resetReaderIndex();
            return;
        }
        byte[] bytes = new byte[len];
        in.readBytes(bytes);
        String json = new String(bytes, CharsetUtil.UTF_8);
        in.markReaderIndex();
      	//将处理后的数据,交由handler链中的下一个处理
        out.add(json);
    }
}
public class ServerChatMessageReadHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
				//得到在上一个Handler中处理完成的数据,用于实现自己的业务逻辑
    }
}

客户端

启动引导类实现
public class ChatClient {
    private String host;
    private Integer port;
    private Bootstrap bootstrap;
    public ChatClient(String host, Integer port) {
        this.host = host;
        this.port = port;
        this.bootstrap = setup();
    }
    private Bootstrap setup() {
        EventLoopGroup group = new NioEventLoopGroup();
        return new Bootstrap()
                .group(group)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer<SocketChannel>() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ChannelPipeline pipeline = ch.pipeline();
                        pipeline.addLast(new ChatMessageToByteEncoder());
                        pipeline.addLast(new ClientChatMessageSendHandler());
                    }
                });
    }

    public void run() throws InterruptedException {
        bootstrap.connect(host, port).sync()
                .channel().closeFuture().sync();
    }

}

自定义编码器
//业务处理类
//通过该类发送数据后,数据会交由handler链中的上一个handler处理(出站数据逆序执行)
public class ClientChatMessageSendHandler extends ChannelInboundHandlerAdapter {
    private Channel channel;
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        super.channelActive(ctx);
        channel = ctx.channel();
        ChatTextMessage message = new ChatTextMessage("今天天气下雨了,有点微冷☔️!!!");
        message.setFromIp("67.5.5.4");
        message.setFromUid("7834875435");
        for (int i = 0; i < 100; i++) {
            sendMessage(message);
        }
    }
    public void sendMessage(TransferPackage transferPackage) {
        if (channel != null && channel.isWritable()) {
            TransferPackageWrap transfer = new TransferPackageWrap<>(transferPackage);
            channel.writeAndFlush(transfer);
        }
    }
}

为了解决服务端(接收端)的粘包、拆包问题,通过自定义协议发送数据长度和数据包到接收端。

public class ChatMessageToByteEncoder extends MessageToByteEncoder<TransferPackageWrap> {
    @Override
    protected void encode(ChannelHandlerContext ctx, TransferPackageWrap msg, ByteBuf out) throws Exception {
      	//这里发送数据顺序必须和数据接收端(服务端)的接收顺序保持一致(TCP保证数据顺序)
        //发送数据包长度
        out.writeInt(msg.getLength());
        //发送数据包
        out.writeBytes(msg.getBytes());
    }
}

代码附件

你可能感兴趣的:(网络编程,Java,netty,网络)