传输

最新推荐文章于 2024-04-13 15:05:54 发布
最新推荐文章于 2024-04-13 15:05:54 发布
阅读量188 收藏 1
点赞数
分类专栏： Netty编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/xzx4959/article/details/102690240
版权

目录

1.案例研究

1.1 使用Java的OIO和NIO实现

1.2 Netty使用OIO和NIO

2.传输API

3 内置的传输

3.1 NIO-非阻塞IO

3.2 Epoll-用于Linux的本地非阻塞传输

3.3 用于JVM内部通信的Local传输

3.4 Embedded传输

4.小结

本章中，我们将学习Netty传输相关的通用的API，并通过和JDK的对比来证明它的简单易用。

1.案例研究

我们将从一个应用程序开始我们对传输的学习，这个应用程序只简单地接受连接，向客户端写“Hi!”，然后关闭连接。

1.1 使用Java的OIO和NIO实现

使用Java的OIO（阻塞）实现代码：

package com.martin.learn.netty.chapter4;

import java.io.IOException;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.nio.charset.Charset;

/**
 * @author: martin
 * @date: 2019/10/22 20:43
 * @description:
 */
public class JavaOioServer {
    public void serve(int port) throws IOException {
        ServerSocket serverSocket = new ServerSocket(port);
        while (true) {
            Socket clientSocket = serverSocket.accept();
            System.out.println("接收连接来自:" + clientSocket);
            new Thread(() -> {
                try {
                    OutputStream outputStream = clientSocket.getOutputStream();
                    outputStream.write("Hi!\r\n".getBytes(Charset.forName("UTF-8")));
                    outputStream.flush();
                    clientSocket.close();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    try {
                        clientSocket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

上面这段代码完全可以处理中等数量的并发客户端，但是如果我们要支持成千上万的并发连接，就需要改为异步网络编程。但是Java中的OIO和NIO的API是完全不同的，以至于我们不得不重写应用程序。代码实现如下：

package com.martin.learn.netty.chapter4;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

/**
 * @author: martin
 * @date: 2019/10/22 20:57
 * @description:
 */
public class JavaNioServer {
    public void serve(int port) throws IOException {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.configureBlocking(false);

        ServerSocket serverSocket = serverSocketChannel.socket();
        InetSocketAddress socketAddress = new InetSocketAddress(port);
        //将服务器绑定到选定的端口
        serverSocket.bind(socketAddress);
        //打开Selector来处理Channel
        Selector selector = Selector.open();
        //将ServerSocket注册到Selector以接受连接
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        final ByteBuffer msg = ByteBuffer.wrap("Hi\r\n".getBytes());
        while (true) {
            //等待需要处理的新事件，阻塞将一直持续到下一个传入事件
            selector.select();
            //获取所有接收事件的SelectionKey实例
            Set<SelectionKey> readyKeys = selector.selectedKeys();
            Iterator<SelectionKey> iterator = readyKeys.iterator();
            while (iterator.hasNext()) {
                SelectionKey selectionKey = iterator.next();
                iterator.remove();
                try {
                    //检查事件是否是一个新的已经就绪可以被接受的连接
                    if (selectionKey.isAcceptable()) {
                        ServerSocketChannel server = (ServerSocketChannel) selectionKey.channel();
                        SocketChannel client = server.accept();
                        client.configureBlocking(false);
                        //接受客户端，并将它注册到选择器
                        client.register(selector, SelectionKey.OP_WRITE | SelectionKey.OP_READ, msg.duplicate());

                        System.out.println("Accepted connection from" + client);
                    }
                    //检查套接字是否已经准备好写数据
                    if (selectionKey.isWritable()) {
                        SocketChannel client = (SocketChannel) selectionKey.channel();
                        ByteBuffer buffer = (ByteBuffer) selectionKey.attachment();
                        while (buffer.hasRemaining()) {
                            //将数据写到已连接的客户端
                            if (client.write(buffer) == 0) {
                                break;
                            }
                        }

                        client.close();
                    }
                }catch (Exception e){
                    selectionKey.cancel();
                    selectionKey.channel().close();
                }
            }
        }
    }
}

如同你所看到的，虽然这段代码所做的事情与之前的同步方式完全相同，但是代码却截然不同。如果为了用于非阻塞IO而重新实现这个简单的应用程序，都需要一次完全重写的话，这对我们的程序升级迁移会造成巨大的困难。

1.2 Netty使用OIO和NIO

我们先编写Netty的阻塞版本：

package com.martin.learn.netty.chapter4;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.oio.OioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.oio.OioServerSocketChannel;

import java.net.InetSocketAddress;
import java.nio.charset.Charset;

/**
 * @author: martin
 * @date: 2019/10/23 10:20
 * @description:
 */
public class NettyOioServer {
    public void server(int port) throws Exception {
        final ByteBuf buf = Unpooled.unreleasableBuffer(Unpooled.copiedBuffer("Hi!\r\n", Charset.forName("UTF-8")));
        EventLoopGroup group = new OioEventLoopGroup();
        try {
            //创建ServerBootstrap
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(group)
                    //使用OIOEventLoopGroup以允许阻塞模式
                    .channel(OioServerSocketChannel.class)
                    .localAddress(new InetSocketAddress(port))
                    //指定ChannelInitializer，对于每个已接受的连接都调用它
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            //添加一个ChannelInboundHandlerAdapter以拦截和处理事件
                            ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                                //将消息写到客户端，并添加ChannelFutureListener以便消息一被写完就关闭连接
                                @Override
                                public void channelActive(ChannelHandlerContext ctx) throws Exception {
                                    ctx.writeAndFlush(buf.duplicate()).addListener(ChannelFutureListener.CLOSE);
                                }
                            });
                        }
                    });
            ChannelFuture future = bootstrap.bind().sync();
            //绑定服务器以接受连接
            future.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully().sync();
        }
    }
}

接着我们使用Netty的非阻塞版本：

package com.martin.learn.netty.chapter4;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
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 java.net.InetSocketAddress;
import java.nio.charset.Charset;

/**
 * @author: martin
 * @date: 2019/10/23 10:20
 * @description:
 */
public class NettyNioServer {
    public void server(int port) throws Exception {
        final ByteBuf buf = Unpooled.unreleasableBuffer(Unpooled.copiedBuffer("Hi!\r\n", Charset.forName("UTF-8")));
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            //创建ServerBootstrap
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(group)
                    //非阻塞模式
                    .channel(NioServerSocketChannel.class)
                    .localAddress(new InetSocketAddress(port))
                    //指定ChannelInitializer，对于每个已接受的连接都调用它
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            //添加一个ChannelInboundHandlerAdapter以拦截和处理事件
                            ch.pipeline().addLast(new ChannelInboundHandlerAdapter() {
                                //将消息写到客户端，并添加ChannelFutureListener以便消息一被写完就关闭连接
                                @Override
                                public void channelActive(ChannelHandlerContext ctx) throws Exception {
                                    ctx.writeAndFlush(buf.duplicate()).addListener(ChannelFutureListener.CLOSE);
                                }
                            });
                        }
                    });
            ChannelFuture future = bootstrap.bind().sync();
            //绑定服务器以接受连接
            future.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully().sync();
        }
    }
}

从上面的代码看出，我们仅仅是更换EventLoopGroup为NioEventLoopGroup，Channel更换为NioServerSocketChannel。因为Netty为每种传输的实现都暴露了相同的API，所以无论使用哪一种传输的实现，代码仍然几乎不受影响。

2.传输API

Netty传输API的核心是interface Channel，它被用于所有的IO操作。Channel类的层次结构如图所示：

如图所示，每个Channel都将会被分配一个ChannelPipeline和ChannelConfig。ChannelConfig包含了该Channel的所有配置设置，并且支持热更新。由于Channel是独一无二的，因此为了保证顺序将Channel声明为Comparable的一个子接口。ChannelPipeline持有全部的ChannelHandler实例，这些ChannelHandler实现了处理状态变化以及数据的逻辑。

ChannelHandler的典型用途包括：

  • 将数据从一种格式转换为另外一种格式
  • 提供异常通知
  • 提供Channel变为活动的或者非活动的通知
  • 提供当Channel注册到EventLoop或者从EventLoop注销时的通知
  • 提供有关用户自定义事件的通知

我们还可以根据需要添加或者移除ChannelHandler实例来修改ChannelPipeline，通过利用Netty的这项能力可以构建出高度灵活的应用程序。

除了访问所分配的ChannelPipeline和ChannelConfig之外，也可以利用Channel的其他方法，其中主要方法如下表：

考虑一下写数据并将其冲刷到远程节点的任务，如下代码使用了Channel.writeAndFlush()来实现这一目的：

public void testWriteAndFlush() {
        Channel channel = new NioServerSocketChannel();
        ByteBuf buf = Unpooled.copiedBuffer("data", CharsetUtil.UTF_8);
        //写数据并冲刷它
        ChannelFuture channelFuture = channel.writeAndFlush(buf);
        //添加ChannelFutureListener以便在写操作完成后接受通知
        channelFuture.addListener(new ChannelFutureListener() {
            @Override
            public void operationComplete(ChannelFuture future) throws Exception {
                //写操作完成，并且没有错误发生
                if (future.isSuccess()) {
                    System.out.println("Write Success");
                } else {
                    //记录错误
                    System.err.println("Write error");
                    future.cause().printStackTrace();
                }
            }
        });
    }

Netty的Channel实现是线程安全的，因此可以存储一个到Channel引用，并且每当需要向远程节点写数据时，都可以使用它，即使当时许多线程都在使用它。如下代码展示了一个多线程写数据的简单例子。

 public void multiThread() {
        Channel channel = new NioServerSocketChannel();
        ByteBuf buf = Unpooled.copiedBuffer("data", CharsetUtil.UTF_8);
        Runnable writer = (() -> {
            channel.writeAndFlush(buf);
        });

        Executor executor = Executors.newCachedThreadPool();
        //多线程执行
        executor.execute(writer);
        executor.execute(writer);
        executor.execute(writer);
    }

3 内置的传输

Netty内置了一些开箱即用的传输，因为并不是所有的传输都支持每一种协议，所以必须选择一个和应用程序所使用的协议相容的传输。Netty提供的传输如下所示：

名称描述
NIO使用java.nio.channels包作为基础，基于选择器的方式 
Epoll由JNI驱动的epoll()和非阻塞IO。只有在Linux上支持，比NIO传输更快，而且是完全非阻塞的
OIO使用java.net包作为基础，使用阻塞流，基本不再使用
Local可以在JVM内部通过管道进行通信的本地传输
EmbeddedEmbedded传输，允许使用ChannelHandler而又不需要一个真正的基于网络的传输。在测试ChannelHandler实现时，非常有用

 

 

 

 

 

 

 

 

3.1 NIO-非阻塞IO

NIO基于JDK中的选择器实现了IO操作的全异步，选择器背后的基本概念是充当一个注册表，当请求在Channel中的状态发生变更时会得到通知。可能的状态变化有：

  • 新的Channel已被接受并且就绪
  • Channel连接已经完成
  • Channel有已经就绪的可供读取的数据
  • Channel可用于写数据

选择器运行在一个检查状态变化并对其做出相应响应的线程上，在应用程序对状态的变化做出响应以后，选择器将会被重置，并将重复这个过程。下面的常量值代表了class java.nio.channels.SelectionKey定义的位模式。这些位模式可以组合在一起来定义请求通知的状态变化集：

  • OP_ACCEPT：请求在接受新连接并创建Channel时获得通知
  • OP_CONNECT：请求在建立一个连接时获得通知
  • OP_READ：当数据已经就绪，可以从Channel中读取时获得通知
  • OP_WRITE：当可以向Channel中写更多的数据时获得通知。这处理了套接字缓冲区被完全填满的情况，这种情况通常发生在数据的发送速度比远程节点可处理的速度更快的时候。

当然，我们在使用的时候无需关心底层的实现细节，Netty的API完全隐藏了这些NIO的内部实现细节。

零拷贝：

零拷贝是一种目前只有在使用NIO和Epoll传输时，才使用的特性。它使你可以快速高效地将数据从文件系统移动到网络接口，而不需要将其从内核空间复制到用户空间，在FTP或者HTTP这些的协议中可以显著的提高性能。但是并不是所有的操作系统都支持。当然，对于实现了数据加密或者压缩的文件系统是不可用的，只能传输文件的原始内容。

3.2 Epoll-用于Linux的本地非阻塞传输

Netty的NIO传输基于Java提供的异步/非阻塞网络编程的通用抽象。这虽然保证了Netty的跨平台性，但是如果我们的网络服务是运行在Linux上的，更优的选择是使用Epoll。你会发现在高负载下它的性能要优于JDK的NIO实现。

Epoll是Linux提供的一个高度可扩展的IO事件通知特性，这个API相比旧的select和poll系统调用拥有更加优异的性能，同时也是Linux上非阻塞网络编程的事实标准。

Netty中使用Epoll是非常简单直接的，只需要将NIOEventLoopGroup替换为EpollEventLoopGroup，并且将NioServerSocketChannel替换为EpollServerSocketChannel即可。

3.3 用于JVM内部通信的Local传输

Netty提供了一个Local传输，用于在同一个JVM中运行的客户端和服务器程序之间的异步通信。这种传输方式并不会接受真正的网络流量，所以它并不能够和其他传输实现相互操作。

3.4 Embedded传输

Embedded传输时一种额外的传输方式，使得你可以将一组ChannelHandler作为帮助器类嵌入到其他的ChannelHandler内部。这种方式，你将可以扩展一个ChannelHandler的功能，而又不需要修改其内部代码。

4.小结

我们现在已经详细了解了所有的传输，那么让我们总结一下各种传输方式的使用场景：

Netty笔记（三）
qq_36905908的博客
06-13 790
netty学习笔记
FANUC 以太网传输DNC-FTP软件
09-01
FANUC 以太网传输DNC-FTP软件是该公司为提高生产效率和便利性而开发的一款重要工具。本文将深入探讨这款软件的功能、工作原理以及在数控机床DNC（Direct Numerical Control，直接数字控制）加工中的应用。 首先，...
netty中pipeline分析_2(handler添加和删除)
guntun8987的博客
06-24 1320
netty源码分析
Netty pipeline执行机制
qq_2908411009的博客
08-31 961
pipeline结构如下 ChannelPipeline pipeline = ch.pipeline(); pipeline.addLast("decoder", new MyClientDecoder()); pipeline.addLast(new MyServerHandler()); pipeline.addLast("encoder", new MyClientEncoder()); MyServerHandler.java代码如
Netty粘包拆包详细总结
彪锅锅来啦
03-23 1008
TCP黏包拆包 TCP是一个流协议，就是没有界限的一长串二进制数据。TCP作为传输层协议并不不了解上层业务数据的具体含义，它会根据TCP缓冲区的实际情况进行数据包的划分，所以在业务上认为是一个完整的包，可能会被TCP拆分成多个包进行发送，也有可能把多个小的包封装成一个大的数据包发送，这就是所谓的TCP粘包和拆包问题。 怎么解决？ 消息定长度，传输的数据大小固定长度，例如每段的长度固定为100...
通过 USRP、OFDM 进行视频传输的 GNURadio 流程图
最新发布
08-28
通过 USRP、OFDM 进行视频传输的 GNURadio 流程图存储库 FFMPEG 的 Tx 和 Rx 命令 在包含 ffmpeg 和 x264 的根文件夹中执行。 接收：./ffplay -f h264 udp://127.0.0.1:1234 TX：./ffmpeg -f v4l2 -i /dev/video0 ...
FANUC程序传输V16.0.7z
11-30
FANUC程序传输V16.0是一款专为FANUC数控系统设计的程序传输工具，主要用于在计算机和FANUC数控机床之间高效、安全地交换加工程序。这个7z压缩包包含了该软件的最新版本16.0，旨在提供更稳定、功能更丰富的程序管理与...
fanuc cnc程序传输软件
06-16
《Fanuc CNC程序传输软件详解》 在现代工业生产中，数控系统（CNC）扮演着至关重要的角色，尤其在精密制造领域。其中，Fanuc作为全球知名的CNC系统供应商，其产品以其稳定性和高效性享誉业界。Fanuc CNC程序传输...
传输矩阵法分析微环谐振器阵列传输特性
02-10
基于定向耦合器、环形谐振腔、直波导腔的基本单元传输矩阵,建立了用于分析微环谐振器阵列传输特性的传输矩阵模型。讨论了列间距对传输特性的影响,并数值模拟了不同尺度的奇数行和偶数行情况下谐振器阵列的传输特性。...
Pipeline添加与删除ChannelHandler
学无止境
01-12 1294
添加ChannelHandler ChannelHandler是在服务端启动过程中，Channel初始化时通过addLast方法添加的。 public static void main(String[] args) throws Exception { // 配置服务端的 NIO线程组 // boss线程组用于网络事件的监听 Even...
netty pipeline 执行顺序解读
nightrainljh的专栏
07-12 4153
最近在做netty 部标开发，顺便研究了下pipeline执行顺序，发现中文博客，网站讲的都不太透彻。 自己结合网上例子，实验，再最后看源码，总结下，希望能讲的透彻。 借用网上博客一个例子https://blog.csdn.net/u013252773/article/details/21195593： 如添加pipelinehandler顺序是： pipeline.addLast(new...
长连接和短连接
sayoko06的博客
09-04 1153
在HTTP/1.0中默认使用短连接。也就是说，客户端和服务器每进行一次HTTP操作，就建立一次连接，任务结束就中断连接。当客户端浏览器访问的某个HTML或其他类型的Web页中包含有其他的Web资源（如JavaScript文件、图像文件、CSS文件等），每遇到这样一个Web资源，浏览器就会重新建立一个HTTP会话。 而从HTTP/1.1起，默认使用长连接，用以保持连...
编码和解码
joeyin
03-15 1833
概述 编码器操作出站数据，而解码器处理入站数据。编码器是将消息转换为适合于传输的格式，而对应的解码器则是将网络字节流转换回应用程序的消息格式。 解码器 将字节解码为消息：ByteToMessageDecoder、ReplayingDecoder 将一种消息类型解码为另外一种：MessageToMessageDecoder 因为解码器是负责将入站数据从一种格式转换到另外一种格式，所以Netty的解码器实现了ChannelInboundHandler。每当需要为ChannelPipeline中的下一个C
netty hander 执行顺序
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
12-06 292
hander 的执行顺序： client 中pipeline 顺序： //first,add codec pipeline.addLast(new BigIntegferdecoder); pipeline.addlast(new numberEncodeer); pipeline.addLast(new FactoriesClientHander); //first.codec pipeline.addlast（new BigIntegerdecoder）； pipeLine.add.
netty->[组件] ChannelPipeline的addLast方法解析
u013657993的专栏
10-11 2996
随处可见的addLast方法，分两种情况。channel未注册和channel已注册 public final ChannelPipeline addLast(EventExecutorGroup group, String name, ChannelHandler handler) { final AbstractChannelHandlerContext newCtx...
Netty入门-pipeline 与 channelHandler
小毛贼_哪里逃
05-15 341
pipeline 与 channelHandler 的构成 无论是从服务端来看，还是客户端来看，在 Netty 整个框架里面，一条连接对应着一个 Channel，这条 Channel 所有的处理逻辑都在一个叫做ChannelPipeline的对象里面，ChannelPipeline是一个双向链表结构，他和 Channel 之间是一对一的关系。 ChannelPipeline里面每个节点都是一个ChannelHandlerContext对象，这个对象能够拿到和 Channel 相...
netty 的学习
hyhanyu的博客
05-25 206
客户端代码：public class Server { private int port; public Server(int port) { this.port = port; } public void run() throws Exception { EventLoopGroup bossGrou...
认真的 Netty 源码解析（一）
2401_84048671的博客
04-13 639
分布式技术专题+面试解析+相关的手写和学习的笔记pdf《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》点击传送门即可获取！到这里就更加诡异了，NioEventLoop 的父类是 SingleThreadEventLoop，而 SingleThreadEventLoop 的父类是，它的名字告诉我们，它是一个 Executor，是一个线程池，而且是 Single Thread 单线程的。
三菱CNC传输软件：高效数控编程传输工具
三菱CNC传输软件是一种专为三菱数控系统（CNC）设计的数据交换工具。CNC系统广泛应用于机械加工行业，用于控制机床和机器人，完成精密的加工任务。传输软件在机床的编程、设置、监控和维护过程中起着至关重要的作用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值