Netty通过多种协议实现IM通信

最新推荐文章于 2024-06-18 15:10:22 发布

ByteTranslator

最新推荐文章于 2024-06-18 15:10:22 发布

阅读量404

点赞数 4

文章标签：网络 Java Netty

本文链接：https://blog.csdn.net/u012903034/article/details/139109151

版权

Netty通过多种协议实现IM通信

一、引言

即时通讯（IM）系统是现代互联网应用中不可或缺的一部分。Netty作为一个高性能的网络应用框架，广泛应用于IM系统的开发中。本文将详细介绍Netty实现IM时可以使用的三种协议：TCP、UDP和WebSocket。并详细介绍三种协议的使用场景、如何控制协议包的大小、以及如何对协议进行编解码。

二、Netty简介

Netty是一个异步事件驱动的网络应用框架，主要用于构建高性能的协议服务器和客户端。Netty极大地简化了TCP和UDP socket服务器的编程。

三、TCP协议

1. 使用场景

TCP（Transmission Control Protocol）是一个面向连接的、可靠的、基于字节流的传输层通信协议。适用于需要高可靠性传输的场景，例如文件传输、邮件传输和即时通讯。

2. 控制协议包的大小

通过Netty提供的LengthFieldBasedFrameDecoder和LengthFieldPrepender类可以控制TCP协议包的大小。

LengthFieldBasedFrameDecoder：用于解码消息，根据长度字段来拆分消息。
LengthFieldPrepender：用于编码消息，在消息前添加长度字段。

例如：

ch.pipeline().addLast(new LengthFieldBasedFrameDecoder(65535, 0, 2, 0, 2));
ch.pipeline().addLast(new LengthFieldPrepender(2));

3. 编解码

Netty提供了许多编解码器，例如StringDecoder和StringEncoder。

编码器

ch.pipeline().addLast(new StringEncoder(CharsetUtil.UTF_8));

解码器

ch.pipeline().addLast(new StringDecoder(CharsetUtil.UTF_8));

4. 实现代码

TCP服务器

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;

public class TCPServer {

    private final int port;

    public TCPServer(int port) {
        this.port = port;
    }

    public void start() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class)
             .childHandler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 public void initChannel(SocketChannel ch) {
                     ChannelPipeline pipeline = ch.pipeline();
                     pipeline.addLast(new LengthFieldBasedFrameDecoder(65535, 0, 2, 0, 2));
                     pipeline.addLast(new LengthFieldPrepender(2));
                     pipeline.addLast(new StringDecoder(CharsetUtil.UTF_8));
                     pipeline.addLast(new StringEncoder(CharsetUtil.UTF_8));
                     pipeline.addLast(new TCPServerHandler());
                 }
             });

            ChannelFuture f = b.bind(port).sync();
            System.out.println("TCP Server started on port: " + port);
            f.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        new TCPServer(8080).start();
    }
}

TCP客户端

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.LengthFieldPrepender;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.util.CharsetUtil;

public class TCPClient {

    private final String host;
    private final int port;

    public TCPClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group)
             .channel(NioSocketChannel.class)
             .handler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 public void initChannel(SocketChannel ch) {
                     ChannelPipeline pipeline = ch.pipeline();
                     pipeline.addLast(new LengthFieldBasedFrameDecoder(65535, 0, 2, 0, 2));
                     pipeline.addLast(new LengthFieldPrepender(2));
                     pipeline.addLast(new StringDecoder(CharsetUtil.UTF_8));
                     pipeline.addLast(new StringEncoder(CharsetUtil.UTF_8));
                     pipeline.addLast(new TCPClientHandler());
                 }
             });

            ChannelFuture f = b.connect(host, port).sync();
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        new TCPClient("127.0.0.1", 8080).start();
    }
}

TCP消息处理器

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;

public class TCPServerHandler extends SimpleChannelInboundHandler<String> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) {
        System.out.println("Received message: " + msg);
        ctx.writeAndFlush("Message received: " + msg);
    }

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

public class TCPClientHandler extends SimpleChannelInboundHandler<String> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, String msg) {
        System.out.println("Received from server: " + msg);
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        ctx.writeAndFlush("Hello, Server!");
    }

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

四、UDP协议

1. 使用场景

UDP（User Datagram Protocol）是一个简单的、无连接的传输层协议。适用于需要快速传输且对可靠性要求不高的场景，例如视频直播、在线游戏和实时语音聊天。

2. 控制协议包的大小

由于UDP本身不提供可靠传输，需要手动控制每个数据包的大小。Netty中的DatagramPacket类可以直接控制发送和接收的数据。

ByteBuf buf = Unpooled.copiedBuffer("Hello, Server!", CharsetUtil.UTF_8);
DatagramPacket packet = new DatagramPacket(buf, new InetSocketAddress(host, port));

3. 编解码

对于UDP，需要手动编码和解码数据。使用ByteBuf来处理数据。

编码

ByteBuf buf = Unpooled.copiedBuffer("Hello, Server!", CharsetUtil.UTF_8);
DatagramPacket packet = new DatagramPacket(buf, new InetSocketAddress(host, port));

解码

String msg = packet.content().toString(CharsetUtil.UTF_8);

4. 实现代码

UDP服务器

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.DatagramPacket;
import io.netty.channel.socket.nio.NioDatagramChannel;
import io.netty.util.CharsetUtil;
import io.netty.buffer.Unpooled;

import java.net.InetSocketAddress;

public class UDPServer {

    private final int port;

    public UDPServer(int port) {
        this.port = port;
    }

    public void start() throws Exception {
        NioEventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group)
             .channel(NioDatagramChannel.class)
             .handler(new SimpleChannelInboundHandler<DatagramPacket>() {
                 @Override
                 protected void channelRead0(ChannelHandlerContext ctx, DatagramPacket packet) {
                     String msg = packet.content().toString(CharsetUtil.UTF_8);
                     System.out.println("Received message: " + msg);
                     ctx.writeAndFlush(new DatagramPacket(
                         Unpooled.copiedBuffer("Message received: " + msg, CharsetUtil.UTF_8),
                         packet.sender()
                     ));
                 }
             });

            ChannelFuture f = b.bind(port).sync();
            System.out.println("UDP Server started on port: " + port);
            f.channel().closeFuture().sync();
        } finally {
           

 group.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        new UDPServer(8081).start();
    }
}

UDP客户端

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.DatagramPacket;
import io.netty.channel.socket.nio.NioDatagramChannel;
import io.netty.util.CharsetUtil;
import io.netty.buffer.Unpooled;

import java.net.InetSocketAddress;

public class UDPClient {

    private final String host;
    private final int port;

    public UDPClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() throws Exception {
        NioEventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group)
             .channel(NioDatagramChannel.class)
             .handler(new ChannelInitializer<NioDatagramChannel>() {
                 @Override
                 public void initChannel(NioDatagramChannel ch) {
                     ch.pipeline().addLast(new SimpleChannelInboundHandler<DatagramPacket>() {
                         @Override
                         protected void channelRead0(ChannelHandlerContext ctx, DatagramPacket packet) {
                             String msg = packet.content().toString(CharsetUtil.UTF_8);
                             System.out.println("Received from server: " + msg);
                         }
                     });
                 }
             });

            Channel ch = b.bind(0).sync().channel();
            ch.writeAndFlush(new DatagramPacket(
                Unpooled.copiedBuffer("Hello, Server!", CharsetUtil.UTF_8),
                new InetSocketAddress(host, port)
            )).sync();

            ch.closeFuture().await();
        } finally {
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        new UDPClient("127.0.0.1", 8081).start();
    }
}

五、WebSocket协议

1. 使用场景

WebSocket是一种在单个TCP连接上进行全双工通信的协议。适用于需要在浏览器和服务器之间保持长连接的场景，例如即时通讯、在线协作和实时数据更新。

2. 控制协议包的大小

WebSocket协议可以通过Netty提供的HttpObjectAggregator类控制每个消息的最大大小。

ch.pipeline().addLast(new HttpObjectAggregator(65536));

3. 编解码

WebSocket协议通过TextWebSocketFrame来编码和解码文本数据。

编码

ctx.channel().writeAndFlush(new TextWebSocketFrame("Hello, Server!"));

解码

if (frame instanceof TextWebSocketFrame) {
    String msg = ((TextWebSocketFrame) frame).text();
}

4. 实现代码

WebSocket服务器

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.websocketx.TextWebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import io.netty.handler.codec.http.websocketx.WebSocketFrameAggregator;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.ChannelHandlerContext;

public class WebSocketServer {

    private final int port;

    public WebSocketServer(int port) {
        this.port = port;
    }

    public void start() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class)
             .childHandler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 public void initChannel(SocketChannel ch) {
                     ChannelPipeline pipeline = ch.pipeline();
                     pipeline.addLast(new HttpServerCodec());
                     pipeline.addLast(new HttpObjectAggregator(65536));
                     pipeline.addLast(new WebSocketServerProtocolHandler("/ws"));
                     pipeline.addLast(new WebSocketFrameHandler());
                 }
             });

            ChannelFuture f = b.bind(port).sync();
            System.out.println("WebSocket Server started on port: " + port);
            f.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        new WebSocketServer(8082).start();
    }
}

class WebSocketFrameHandler extends SimpleChannelInboundHandler<WebSocketFrame> {

    @Override
    protected void channelRead0(ChannelHandlerContext ctx, WebSocketFrame frame) {
        if (frame instanceof TextWebSocketFrame) {
            String msg = ((TextWebSocketFrame) frame).text();
            System.out.println("Received message: " + msg);
            ctx.channel().writeAndFlush(new TextWebSocketFrame("Message received: " + msg));
        }
    }

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

WebSocket客户端

通过HTML和JavaScript实现一个简单的WebSocket客户端。

<!DOCTYPE html>
<html>
<head>
    <title>WebSocket Client</title>
</head>
<body>
    <h1>WebSocket Client</h1>
    <div id="output"></div>
    <input type="text" id="input" placeholder="Type a message..." />
    <button onclick="sendMessage()">Send</button>

    <script type="text/javascript">
        var ws;

        function connect() {
            ws = new WebSocket("ws://127.0.0.1:8082/ws");

            ws.onopen = function() {
                log("Connected to the server");
            };

            ws.onmessage = function(event) {
                log("Received: " + event.data);
            };

            ws.onclose = function() {
                log("Disconnected from the server");
            };

            ws.onerror = function(error) {
                log("Error: " + error.message);
            };
        }

        function sendMessage() {
            var input = document.getElementById("input").value;
            if (ws && ws.readyState === WebSocket.OPEN) {
                ws.send(input);
                log("Sent: " + input);
            } else {
                log("WebSocket is not connected.");
            }
        }

        function log(message) {
            var output = document.getElementById("output");
            output.innerHTML += message + "<br/>";
        }

        window.onload = connect;
    </script>
</body>
</html>

六、总结

本文介绍了Netty在IM通信中使用的三种协议：TCP、UDP和WebSocket。通过对比三种协议的使用场景和特点，展示了如何控制协议包的大小以及如何进行编解码。通过完整的服务端和客户端实现代码，展示了如何在Netty中实现这三种协议的IM通信。Netty强大的功能和灵活性使其成为构建高性能IM系统的理想选择。

ByteTranslator

关注

4
点赞
踩
7

收藏

觉得还不错? 一键收藏
0
评论
Netty通过多种协议实现IM通信

Netty是一个异步事件驱动的网络应用框架，主要用于构建高性能的协议服务器和客户端。Netty极大地简化了TCP和UDP socket服务器的编程。本文介绍了Netty在IM通信中使用的三种协议：TCP、UDP和WebSocket。通过对比三种协议的使用场景和特点，展示了如何控制协议包的大小以及如何进行编解码。通过完整的服务端和客户端实现代码，展示了如何在Netty中实现这三种协议的IM通信。Netty强大的功能和灵活性使其成为构建高性能IM系统的理想选择。
复制链接

扫一扫