物联网架构中的NETTY中间件应用之一

朱晶

已于 2024-09-08 21:30:50 修改

阅读量1.3k

点赞数 20

分类专栏： netty 文章标签： nio

于 2024-09-08 21:03:39 首次发布

本文链接：https://blog.csdn.net/weixin_43385741/article/details/142032633

版权

netty 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

概要

`物联网架构设计中Netty的应用
在海量物联网设备的连接和控制领域，我们经常使用Netty作为设备的消息控制网关。Netty作为一种高效的网络应用框架，非常适合用于对接物联网设备。使用Netty，我们可以构建一个高性能的服务器，用于处理来自物联网设备的请求和响应。我们可以使用Netty构建一个HTTP服务器，或者是WEB SOCKET服务器，也可以是基于私有二进制协议的服务器。

Netty 简介

Netty是一个由Java编写的网络应用框架，它提供了对TCP、UDP和文件传输的支持，使得开发者能够快速地开发网络应用。Netty的核心特性包括：
非阻塞I/O：基于NIO的异步模型，大大提高了系统的吞吐量。
简单易用：提供了一套简洁的API，使得开发者能够快速地构建网络应用。
高性能：通过优化内存使用和减少不必要的对象创建，Netty提供了高性能的网络通信。
可扩展性：Netty的设计允许开发者扩展和定制框架的各个方面。

Netty的定义

Netty的主要组成部分包括：

Channel：Netty网络抽象的核心，代表了一个到实体（如硬件设备、文件、网络套接字或可以执行I/O操作的程序组件）的开放连接，如读、写操作。
EventLoop：处理I/O操作的多线程事件循环。每个Channel都会被注册到一个EventLoop，并由它处理所有的事件。
ChannelHandler：处理网络事件的组件，如连接、断开连接、接收数据等。开发者可以通过实现ChannelHandler接口来定义自己的处理器。
ChannelPipeline：一个处理网络事件的处理器链。当事件发生时，它会按照处理器在管道中的顺序依次调用每个处理器。
Bootstrap：用于启动客户端或服务端的辅助启动类。通过Bootstrap，我们可以设置各种参数，如线程模型、处理器等。

使用Netty对接物联网Socket设备的步骤：

要使用Netty对接物联网的Socket设备，通常需要以下几个步骤：

定义ChannelHandler：首先，我们需要定义一个或多个ChannelHandler，用于处理来自物联网设备的请求和响应。例如，我们可以定义一个用于解析设备发送的数据的解码器，以及一个用于将响应数据发送回设备的编码器。
配置ChannelPipeline：然后，我们需要配置ChannelPipeline，将定义的处理器添加到管道中。这样，当事件发生时，管道会按照处理器的顺序依次调用它们。
创建Bootstrap：接下来，我们需要创建一个Bootstrap实例，用于启动服务器或客户端。在创建Bootstrap时，我们需要指定线程模型、处理器等参数。
启动服务器或客户端：最后，我们可以调用Bootstrap的bind()或connect()方法来启动服务器或客户端，开始与物联网设备的通信。

最佳实践

1.构建一个普通的http 服务器。

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
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;
 
public class HttpSimpleServer {
 
    private int port;
 
    public HttpSimpleServer(int port) {
        this.port = port;
    }
 
    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        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) throws Exception {
                     ch.pipeline().addLast("http-codec", new HttpServerCodec());
                     ch.pipeline().addLast("aggregator", new HttpObjectAggregator(512 * 1024));
                     ch.pipeline().addLast("http-handler", new HttpSimpleServerHandler());
                 }
             });
 
            ChannelFuture f = b.bind(port).sync();
            System.out.println("HTTP服务器启动，监听端口：" + port);
            f.channel().closeFuture().sync();
        } finally {
            workerGroup.shutdownGracefully();
            bossGroup.shutdownGracefully();
        }
    }
 
    public static void main(String[] args) throws Exception {
        int port;
        if (args.length > 0) {
            port = Integer.parseInt(args[0]);
        } else {
            port = 8080;
        }
        new HttpSimpleServer(port).run();
    }
}
 
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.HttpHeaderNames;
import io.netty.handler.codec.http.HttpHeaderUtil;
import io.netty.handler.codec.http.HttpHeaders;
import io.netty.handler.codec.http.HttpMethod;
import io.netty.handler.codec.http.HttpRequest;
 
public class HttpSimpleServerHandler extends SimpleChannelInboundHandler<HttpRequest> {
 
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, HttpRequest msg) {
        if (msg.method() != HttpMethod.GET) {
            sendError(ctx, HttpHeaderUtil.createUnsupportedMethodResponse(msg));
            return;
        }
 
        String content = "Hello, World!";
        FullHttpResponse response = new DefaultFullHttpResponse(
                msg.protocolVersion(),
                HttpHeaders.Values.OK,
                Unpooled.copiedBuffer(content, HttpHeaders.Values.TEXT_PLAIN)
        );
 
        response.headers().set(HttpHeaderNames.CONTENT_TYPE, HttpHeaders.Values.TEXT_PLAIN);
        response.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, content.length());
 
        ctx.writeAndFlush(response);
    }
 
    private static void sendError(ChannelHandlerContext ctx, FullHttpResponse response) {
        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    }
}

2.构建一个websocket服务器，在后端和前端的交互过程中，很多时候，前端不仅仅需要调用后端的接口，很多时候还必须和后端实时通讯，后端要能及时通知到前端。这个时候，HTTP服务器已经不能满足需要了。我们需要构建一个WEB SOCKET 服务器完成和前端的实时交互。

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 io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
 
public class WebSocketServer {
    private int port;
 
    public WebSocketServer(int port) {
        this.port = port;
    }
 
    public void run() throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup)
             .channel(NioServerSocketChannel.class)
             .handler(new LoggingHandler(LogLevel.INFO))
             .childHandler(new ChannelInitializer<SocketChannel>() {
                 @Override
                 public void initChannel(SocketChannel ch) throws Exception {
                     ChannelPipeline pipeline = ch.pipeline();
                     pipeline.addLast("http-codec", new HttpServerCodec());
                     pipeline.addLast("aggregator", new HttpObjectAggregator(65536));
                     pipeline.addLast("handler", new WebSocketServerHandler());
                 }
             });
 
            Channel ch = b.bind(port).sync().channel();
            System.out.println("Web socket server started at port " + port + '.');
            ch.closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
 
    public static void main(String[] args) throws Exception {
        int port;
        if (args.length > 0) {
            port = Integer.parseInt(args[0]);
        } else {
            port = 8080;
        }
        new WebSocketServer(port).run();
    }
}
 
class WebSocketServerHandler extends SimpleChannelInboundHandler<Object> {
    @Override
    protected void channelRead0(ChannelHandlerContext ctx, Object msg) throws Exception {
        if (msg instanceof FullHttpRequest) {
            handleHttpRequest(ctx, (FullHttpRequest) msg);
        } else if (msg instanceof WebSocketFrame) {
            handleWebSocketFrame(ctx, (WebSocketFrame) msg);
        }
    }
 
    private void handleHttpRequest(ChannelHandlerContext ctx, FullHttpRequest req) {
        // Handle HTTP requests
    }
 
    private void handleWebSocketFrame(ChannelHandlerContext ctx, WebSocketFrame frame) {
        // Handle WebSocket frames
    }
}

3.构建一个私有协议的服务器
在硬件设备中，经常采用嵌入式系统。这类硬件设备由于系统资源有限，可能并未部署操作系统在设备上面，往往只能支持二进制协议和服务端进行通讯。
这种类型的服务器往往要根据协议内容进行定制，在下一篇博客中将对此进行专门的讲解

总结

Netty作为一个高性能、异步的网络应用框架，非常适合用于对接物联网中的Socket设备。通过定义合适的ChannelHandler、配置ChannelPipeline、创建Bootstrap并启动服务器或客户端，我们可以实现与物联网设备的高效通信。在实际应用中，我们还需要注意异常处理、资源管理和安全性等方面的问题。