Socket、Netty、NIO、WebSocket

最新推荐文章于 2024-05-06 16:23:13 发布
最新推荐文章于 2024-05-06 16:23:13 发布
阅读量2.5k 收藏 5
点赞数 3
分类专栏： # 通讯socket和io和nio

转自

https://www.jianshu.com/p/7d9814fd0efd

1.什么是Socket？

Socket就是为网络服务提供的一种机制。

通讯的两端都有Sokcet

网络通讯其实就是Sokcet间的通讯

数据在两个Sokcet间通过IO传输。

2.TCP与UDP在概念上的区别

udp: a、是面向无连接, 将数据及源的封装成数据包中,不需要建立建立连接

        b、每个数据报的大小在限制64k内

        c、因无连接,是不可靠协议

        d、不需要建立连接,速度快

tcp：a、建议连接，形成传输数据的通道.

         b、在连接中进行大数据量传输，以字节流方式

         c 通过三次握手完成连接,是可靠协议

         d 必须建立连接m效率会稍低

TCP三次握手

①客户端发送SYN报文,并设置发送序号为X 给服务端 这是第一次握手

②服务器端接受到SYN报文 并发送SYN+ACK报文,并设置发送序号为Y 给客户端 这是第二次握手

③客户端第三次握手 告诉服务端 准备给服务端发数据 建立起连接 开始传输数据

为什么不是两次或者四次:

三次是保证双方互相明确对方能收能够接收与发送。三次已经足够了.

TCP四次挥手

①客户端像服务端发起请求,表示没有数据要发送了

②服务端像客户端发起请求,确认客户端的断开请求请求

③客户端像服务端发送信号,请求断开连接

④服务端接收客户端请求,发送确认断开连接信号,同意断开 b收到 断开

为什么2、3次挥手不能合在一次挥手中

因为客户端不发生数据了,但是还可以接收数据,服务端可能还有数据发送给客户端,所以两次不能合并.

3.什么是NIO?

 Java NIO(New IO)是一个可以替代标准Java IO API的IO

API（从Java 1.4开始)，Java NIO提供了与标准IO不同的IO工作方式。

Java NIO: Channels and Buffers（通道和缓冲区）

标准的IO基于字节流和字符流进行操作的，而NIO是基于通道（Channel）和缓冲区（Buffer）进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。

Java NIO: Non-blocking IO（非阻塞IO）

Java NIO可以让你非阻塞的使用IO，例如：当线程从通道读取数据到缓冲区时，线程还是可以进行其他事情。当数据被写入到缓冲区时，线程可以继续处理它。从缓冲区写入通道也类似。

Java NIO: Selectors（选择器）

Java NIO引入了选择器的概念，选择器用于监听多个通道的事件（比如：连接打开，数据到达）。因此，单个的线程可以监听多个数据通道。

注意:传统IT是单向。 NIO类似

4.Buffer的数据存取

         一个用于特定基本数据类行的容器。有java.nio包定义的，所有缓冲区都是抽象类Buffer的子类。

Java NIO中的Buffer主要用于与NIO通道进行交互，数据是从通道读入到缓冲区，从缓冲区写入通道中的。

Buffer就像一个数组，可以保存多个相同类型的数据。

5.Buffer的概述

1）容量（capacity）：表示Buffer最大数据容量，缓冲区容量不能为负，并且建立后不能修改。

2）限制（limit）：第一个不应该读取或者写入的数据的索引，即位于limit后的数据不可以读写。缓冲区的限制不能为负，并且不能大于其容量（capacity）。

3）位置（position）：下一个要读取或写入的数据的索引。缓冲区的位置不能为负，并且不能大于其限制（limit）。

4）标记（mark）与重置（reset）：标记是一个索引，通过Buffer中的mark()方法指定Buffer中一个特定的position，之后可以通过调用reset()方法恢复到这个position。

6.直接缓冲区与非直接缓冲区别

非直接缓冲区：通过 allocate() 方法分配缓冲区，将缓冲区建立在 JVM 的内存中

直接缓冲区：通过 allocateDirect() 方法分配直接缓冲区，将缓冲区建立在物理内存中。可以提高效率

7.分散读取与聚集写入

分散读取(scattering Reads)：将通道中的数据分散到多个缓冲区中

聚集写入(gathering Writes)：将多个缓冲区的数据聚集到通道中

8.BIO与NIO

IO(BIO)和NIO区别:其本质就是阻塞和非阻塞的区别

阻塞概念:应用程序在获取网络数据的时候,如果网络传输数据很慢，就会一直等待,直到传输完毕为止。

非阻塞概念:应用程序直接可以获取已经准备就绪好的数据,无需等待。

IO为同步阻塞形式,NIO为同步非阻塞形式,NIO并没有实现异步,在JDK1.7后升级NIO库包，支持异步非阻塞同学模型NIO2.0(AIO)

BIO：同步阻塞式IO，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。 

NIO：同步非阻塞式IO，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。 

AIO(NIO.2)：异步非阻塞式IO，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理。

同步时，应用程序会直接参与IO读写操作,并且我们的应用程序会直接阻塞到某一个方法上,直到数据准备就绪:或者采用轮训的策略实时检查数据的就绪状态,如果就绪则获取数据.异步时,则所有的IO读写操作交给操作系统,与我们的应用程序没有直接关系，我们程序不需要关系IO读写，当操作系统完成了IO读写操作时,会给我们应用程序发送通知,我们的应用程序直接拿走数据极即可。

9.什么是Netty

 Netty 是一个基于 JAVA NIO 类库的异步通信框架，它的架构特点是：异步非阻塞、基于事件驱动、高性能、高可靠性和高可定制性。

10.Netty应用场景

1.分布式开源框架中dubbo、Zookeeper，RocketMQ底层rpc通讯使用就是netty。

2.游戏开发中，底层使用netty通讯。

11.TCP粘包、拆包问题解决方案

消息定长，报文大小固定长度，不够空格补全，发送和接收方遵循相同的约定，这样即使粘包了通过接收方编程实现获取定长报文也能区分。

包尾添加特殊分隔符，例如每条报文结束都添加回车换行符（例如FTP协议）或者指定特殊字符作为报文分隔符，接收方通过特殊分隔符切分报文区分。

将消息分为消息头和消息体，消息头中包含表示信息的总长度（或者消息体长度）的字段

12.为什么需要 WebSocket？

因为 HTTP 协议有一个缺陷：通信只能由客户端发起。WebSocket 协议在2008年诞生，2011年成为国际标准。所有浏览器都已经支持了。

它的最大特点就是，服务器可以主动向客户端推送信息，客户端也可以主动向服务器发送信息，是真正的双向平等对话，属于服务器推送技术的一种。

其他特点包括：

（1）建立在 TCP 协议之上，服务器端的实现比较容易。

（2）与 HTTP 协议有着良好的兼容性。默认端口也是80和443，并且握手阶段采用 HTTP 协议，因此握手时不容易屏蔽，能通过各种 HTTP 代理服务器。

（3）数据格式比较轻量，性能开销小，通信高效。

（4）可以发送文本，也可以发送二进制数据。

（5）没有同源限制，客户端可以与任意服务器通信。

（6）协议标识符是ws（如果加密，则为wss），服务器网址就是 URL。



作者：污萌萌小虎牙
链接：https://www.jianshu.com/p/7d9814fd0efd
來源：简书
简书著作权归作者所有，任何形式的转载都请联系作者获得授权并注明出处。

踟蹰千年
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
太厉害了！阿里P8推荐的Netty学习方案，让你轻松吊打面试官
weixin_47066028的博客
11-03 444
前言 想要学好一门技术，最起码要对他有一定的了解，起码听说过相应的底层原理的东西吧，最起码你要有一点能和别人交流的内容吧，下面是我精简的一点内容，希望对于大家了解netty能有一点帮助 Netty是建立在NIO基础之上，Netty在NIO之上又提供了更高层次的抽象。 在Netty里面，Accept连接可以使用单独的线程池去处理，读写操作又是另外的线程池来处理。 Accept连接和读写操作也可以使用同一个线程池来进行处理。而请求处理逻辑既可以使用单独的线程池进行处理，也可以跟放在读写线程一块处理。线程池中的每
Netty一个端口支持tcp和websocket
09-29
在本文中，我们将深入探讨如何利用 Netty 实现一个端口同时支持 TCP 和 WebSocket，从而减少资源消耗并简化服务器配置。 TCP（传输控制协议）是一种面向连接的、可靠的传输层协议，它保证了数据的顺序传输和错误...
Java-WebSocket：以100％Java编写的准系统WebSocket客户端和服务器实现
02-22
Java WebSockets 该存储库包含使用100％Java编写的准系统WebSocket服务器和客户端实现。 基础类实现为java.nio ，它允许使用非阻塞事件驱动模型（类似于Web浏览器的 ）。 已实现的WebSocket协议版本为： 有关协议版本/草案的更多详细信息。 启用同时引用服务器和客户端示例的扩展。 入门 依赖管理工具 以下是使用依赖管理工具（如maven或gradle）的简要指南。 Maven 要使用maven，请将此依赖项添加到pom.xml中： < dependency> < groupId>org.java-websocket</ groupId> < artifactId>Java-WebSocket</ artifactId> < version>1.5.1</ version> </ dependency> Gradle
Netty:基于Java NIO的网络服务器Netty生产实例
05-14
Netty 作为之前及现在不断学习Netty道路上持续集成项目 Netty心跳实现 客户端及服务端聊天实现 完成Netty回声服务器 使用WebSocket实现点对点聊天功能 WebSocket实现群聊功能及上下线提醒 增加Netty UDP协议实现 使用第三方IM聊天框架实现 AttributeMap使用 自定义消息协议实现 技术讨论 & 如果对项目有任何疑问或者建议,欢迎到我的博客留言及交流!
基于Netty的websocket的简单介绍
最新发布
static_coder的博客
05-06 736
WebSocket」是一种在单个TCP连接上进行全双工通信的协议。「WebSocket」使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在「WebSocket API」中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。TCP连接是一种可靠的、面向连接的网络通信协议。它通过三次握手建立连接，然后通过数据包的传输和确认来保证数据的可靠性和顺序性。
WebSocket NIO服务端--连接部分
weixin_34396103的博客
01-02 284
2019独角兽企业重金招聘Python工程师标准>>> ...
Socket通信与WebSocket协议
qq_55648724的博客
08-24 1130
目录文章目录前言一、Socket通信1.1 BIO1.2 NIO1.3 AIO二、WebSocket协议总结 Socket是一种用于网络通信的编程接口（API），它提供了一种机制，使不同主机之间可以通过网络进行数据传输和通信。Socket是支持TCP/IP协议栈的应用层与传输层之间的接口。在Socket编程中，有两种常见的角色：客户端和服务器端。客户端负责发起连接请求，服务器端负责接收并处理连接请求。Socket通信的基本流程如下：通过Socket编程，可以实现不同设备之间的网络通信。例如，可以使用Soc
Netty与Spring WebSocket
Leon_Jinhai_Sun的博客
07-03 5291
刚开始的时候，我尝试着用netty实现了websocket服务端的搭建。在netty里面，并没有websocket session这样的概念，与其类似的是channel，每一个客户端连接都代表一个channel。前端的ws请求通过netty监听的端口，走websocket协议进行ws握手连接之后，通过一些列的handler（责链模式）进行消息处理。与websocket session类似地，服务端在连接建立后有一个channel，我们可以通过channel进行与客户端的通信 /** * TO
NIO、BIO、AIO、Netty网络编程及websocket实现
m0_67394006的博客
04-07 274
网络基础编程及WebSocket实现 什么是Socket 网络上的两个程序通过一个双向的通信连接实现数据的交换，这个连接的一端称为一个socket。 建立网络通信连接至少要一个端口号。socket本质是编程接口(API)，对TCP/IP的封装，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口;HTTP是轿车，提供了封装或者显示数据的具体形式;Socket是发动机，提供了网络通信的能力。Socket的英文原义是“孔”或“插座”。作为BSDUNIX的进程通信机制，取后一种意思。通常
WebSocket，Socket，Http之间的区别及使用Netty实现WebSocket服务端
ZloveH______的博客
08-01 8233
WebSocket(转自CSDN博客王卫东) WebSocket介绍与原理 WebSocket protocol 是HTML5一种新的协议。它实现了浏览器与服务器全双工通信(full-duplex)。一开始的握手需要借助HTTP请求完成。 ——百度百科 目的：即时通信，替代轮询   网站上的即时通讯是很常见的，比如网页的QQ，聊天系统等。按照以往的技术能力通常是采用轮询、Comet技术解决。 ...
Netty入门之WebSocket初体验
weixin_34114823的博客
11-04 332
说一说IO通信 BIO通信： BIO即同步阻塞模式一请求一应答的通信模型，该模型最大的问题就是缺乏弹性伸缩能力，当客户端并发访问量增加后，服务端的线程个数和客户端并发访问数呈1：1的正比关系，由于线程是JAVA虚拟机非常宝贵的系统资源，当线程数膨胀之后，系统的性能将急剧下降，随着并发访问量的继续增大，系统会发生线程堆栈溢出、创建新线程失败等问题，并最终导致进程宕机或者僵死，不能对外提供服务。 BI...
Nio的方式实现Websocket通讯（解决websocket手机端经常连接不上）
05-11
这个Demo是通过NioSession实现的，Tomcat自带的websockt使用手机端连接会经常链接不上，这个Demo非常有效解决了手机端连接不上websocket的bug。demo是SE项目，执行main启动服务器后，web端通过ws的方式连接即可，端口在代码里面有，自己下代码琢磨下就行，通俗易懂！
Spring+Netty+WebSocket实例
12-06
Spring+Netty+WebSocket实例，通用性还行，比较贴近生产，注释什么写的比较全
基于netty编写的socket服务端
12-05
Netty是一个高性能、异步事件驱动的网络应用框架，用于快速...在实际项目中，Netty不仅用于socket服务端，还可以用于构建HTTP服务器、WebSocket服务器、RPC框架等，是现代分布式系统和微服务架构中不可或缺的一部分。
netty-socket实时在线人数统计
09-19
本文将深入探讨如何使用SpringBoot 2.0与Netty-socket来实现一个实时在线人数统计的功能，并涉及到WebSocket协议的相关知识。 **SpringBoot 2.0** SpringBoot是Spring框架的一个轻量级容器，它简化了Spring应用...
netty技术文档，socket技术 多线程
06-15
1. **异步非阻塞I/O**：Netty基于NIO（非阻塞I/O）和EPOLL事件驱动模型，提高了系统的并发处理能力，降低了CPU的等待时间。 2. **高度可定制的编码解码器**：Netty提供了一系列的编解码器，用于处理各种数据类型，...
前台用html5 websocket 后台用netty实现聊天系统
09-16
在WebSocket服务器端，Netty提供了一个WebSocketServerProtocolHandler，用于处理WebSocket的升级请求和数据帧的解析。 首先，你需要在项目中引入Netty库，并定义一个WebSocket处理器，该处理器将处理来自客户端的...
网络框架（bio，nio，netty，socket）
远行的博客
05-06 1289
文章目录参考资料bionio（单线程模型）nio（响应式模型）aio 参考资料 马士兵io模型和netty原理-视频讲解 马士兵io模型和netty原理-视频讲解-视频源码 socket的原理，http原理 bio socket里面的 bind（）–绑定ip，端口 listen（）–接受客户端的连接请求 accept（）–把建立好连接的socket从就绪队列里取出来返回而已，当然了如果就绪队列为空（没有就绪连接） 则会阻塞 ServerSocket ss = new ServerSocke
SpringBoot整合Netty搭建高性能Websocket服务器（实现聊天功能）
冯冬冬的博客
12-27 5465
之前使用Springboot整合了websocket，实现了一个后端向前端推送信息的基本小案例，这篇文章主要是增加了一个新的框架就是Netty，实现一个高性能的websocket服务器，并结合前端代码，实现一个基本的聊天功能。你可以根据自己的业务需求进行更改。 这里假设你已经了解了Netty和websocket的相关知识，仅仅是想通过Springboot来整合他们。根据之前大家的需求，代码已经上...
写一个netty 实现的websocket协议的服务端和客户端案例，用java代码
06-03
以下是一个简单的Netty实现WebSocket协议的服务端和客户端案例： 服务端代码： ```java 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; public class WebSocketServer { private final int port; public WebSocketServer(int port) { this.port = port; } public void start() throws Exception { EventLoopGroup bossGroup = new NioEventLoopGroup(); EventLoopGroup workerGroup = new NioEventLoopGroup(); try { ServerBootstrap bootstrap = new ServerBootstrap() .group(bossGroup, workerGroup) .channel(NioServerSocketChannel.class) .childHandler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); pipeline.addLast(new HttpServerCodec()); pipeline.addLast(new HttpObjectAggregator(65536)); pipeline.addLast(new WebSocketServerProtocolHandler("/websocket")); pipeline.addLast(new WebSocketServerHandler()); } }) .option(ChannelOption.SO_BACKLOG, 128) .childOption(ChannelOption.SO_KEEPALIVE, true); ChannelFuture future = bootstrap.bind(port).sync(); System.out.println("WebSocket Server started on port " + port); future.channel().closeFuture().sync(); } finally { workerGroup.shutdownGracefully(); bossGroup.shutdownGracefully(); } } public static void main(String[] args) throws Exception { new WebSocketServer(8080).start(); } } ``` 客户端代码： ```java 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 io.netty.handler.codec.http.*; import io.netty.handler.codec.http.websocketx.*; import io.netty.util.CharsetUtil; import java.net.URI; public class WebSocketClient { private final URI uri; private final WebSocketClientHandler handler = new WebSocketClientHandler(); private Channel channel; public WebSocketClient(URI uri) { this.uri = uri; } public void start() throws Exception { EventLoopGroup group = new NioEventLoopGroup(); try { Bootstrap bootstrap = new Bootstrap() .group(group) .channel(NioSocketChannel.class) .handler(new ChannelInitializer<SocketChannel>() { @Override public void initChannel(SocketChannel ch) throws Exception { ChannelPipeline pipeline = ch.pipeline(); pipeline.addLast(new HttpClientCodec()); pipeline.addLast(new HttpObjectAggregator(8192)); pipeline.addLast(new WebSocketClientProtocolHandler(uri, WebSocketVersion.V13, null, true, HttpHeaders.EMPTY_HEADERS, 65536)); pipeline.addLast(handler); } }); channel = bootstrap.connect(uri.getHost(), uri.getPort()).sync().channel(); handler.handshakeFuture().sync(); System.out.println("WebSocket Client connected to " + uri); } catch (Exception e) { group.shutdownGracefully(); } } public void stop() { channel.writeAndFlush(new CloseWebSocketFrame()); try { channel.closeFuture().sync(); } catch (InterruptedException e) { e.printStackTrace(); } } public void sendMessage(String message) { channel.writeAndFlush(new TextWebSocketFrame(message)); } public static void main(String[] args) throws Exception { WebSocketClient client = new WebSocketClient(new URI("ws://localhost:8080/websocket")); client.start(); client.sendMessage("Hello, Netty WebSocket!"); Thread.sleep(1000); client.stop(); } private static class WebSocketClientHandler extends SimpleChannelInboundHandler<Object> { private final WebSocketClientHandshaker handshaker; private ChannelPromise handshakeFuture; public WebSocketClientHandler() { URI uri = URI.create("ws://localhost:8080/websocket"); handshaker = WebSocketClientHandshakerFactory.newHandshaker(uri, WebSocketVersion.V13, null, true, HttpHeaders.EMPTY_HEADERS, 65536); } public ChannelFuture handshakeFuture() { return handshakeFuture; } @Override public void handlerAdded(ChannelHandlerContext ctx) { handshakeFuture = ctx.newPromise(); } @Override public void channelActive(ChannelHandlerContext ctx) { handshaker.handshake(ctx.channel()); } @Override public void channelInactive(ChannelHandlerContext ctx) { System.out.println("WebSocket Client disconnected!"); } @Override public void channelRead0(ChannelHandlerContext ctx, Object msg) { Channel ch = ctx.channel(); if (!handshaker.isHandshakeComplete()) { handshaker.finishHandshake(ch, (FullHttpResponse) msg); System.out.println("WebSocket Client connected!"); handshakeFuture.setSuccess(); return; } if (msg instanceof FullHttpResponse) { FullHttpResponse response = (FullHttpResponse) msg; throw new IllegalStateException( "Unexpected FullHttpResponse (getStatus=" + response.status() + ", content=" + response.content().toString(CharsetUtil.UTF_8) + ')'); } WebSocketFrame frame = (WebSocketFrame) msg; if (frame instanceof TextWebSocketFrame) { TextWebSocketFrame textFrame = (TextWebSocketFrame) frame; System.out.println("WebSocket Client received message: " + textFrame.text()); } else if (frame instanceof PongWebSocketFrame) { System.out.println("WebSocket Client received pong"); } else if (frame instanceof CloseWebSocketFrame) { System.out.println("WebSocket Client received closing"); ch.close(); } } @Override public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) { cause.printStackTrace(); if (!handshakeFuture.isDone()) { handshakeFuture.setFailure(cause); } ctx.close(); } } } ``` 使用时，先启动服务端，再启动客户端。客户端启动后，会向服务端发送一条消息，并在接收到服务端的响应后关闭连接。在控制台上可以看到客户端和服务端的交互过程。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值