io、nio、tcp协议、socket、websocket、netty、tomcat

已于 2023-04-26 11:39:38 修改
阅读量723 收藏 4
点赞数
分类专栏： Java 文章标签： nio tcp/ip websocket
于 2022-08-10 15:54:35 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yiguang_820/article/details/126268281
版权 
io->socket->应用tomcat（7.0版本Tomcat的底层是Socket编程）
nio->SocketChannel->tomcat（8.0版本）
tcp协议->socket-netty
socket（网络通信）
磁盘与IO基础知识：http://t.zoukankan.com/iwehdio-p-14248593.html
nio介绍：https://baijiahao.baidu.com/s?id=1709430016589717829&wfr=spider&for=pc
    https://www.jb51.net/article/211036.htm
    
一.慨念
    1.Buffer
        ByteBuffer详解：https://blog.csdn.net/t000818/article/details/79023134
        allocate方式
            核心参数capacity：
            核心参数 position:
            核心参数limit:
        allocateDirect方式
    2.Channel
        1.FileChannel file
        2.SocketChannel与ServerSocketChannel TCP
        3.DatagramChannel UDP
        4.Pipe
    3.Selector
一.nio比io快的原理
个人理解：
1、io是面向流的，字节流和字符流，其读与写是频繁与磁盘交互，是用户态和内核态频繁切换，也就是io是用户态，不能直接操作内核，需要操作系统调用内核来读写磁盘，切换本身就耗时；
nio是面向缓冲区的，使用内存映射，直接操作内存中数据(类似于c语言中allocateMemery等方法，这一点类似cas直接操作内存)，避免了用户态和内核态的频繁奇切换
2、io是线程阻塞的，一个连接或者说一个线程读取，在没有数据之后进入阻塞，等待；
nio是线程非阻塞，其使用的buffer和channel(双向通道),当前通道没有数据读取时，可以切换到另一个通道（数据的来源或目的地）中;
3、io是一个线程一个连接
nio使用selector选择器，响应式处理客户端的请求，一个线程可以解决多个连接的数据处理；



二.nio使用
在io上使用
1.nio文件读写
2.io与nio实现大文件复制的效率对比：https://blog.csdn.net/zhangcongyi420/article/details/103099441
3.nio实现文件上传下载：https://blog.51cto.com/u_14693305/5529441
4.BIO、NIO、AIO按行读取文件汇总：https://blog.csdn.net/judyjie/article/details/86608283

在socket上使用
5.java nio简单示例：实现客户端与服务器一问一答：https://blog.csdn.net/qq_37855749/article/details/116190818

三.例子
1.nio文件读写例子
    /**
	 * nio 使用缓冲区，非直接缓冲区读写文件
	 */
	public void test3() {
	    try (
	    		FileInputStream fis = new FileInputStream("1.jpg");
	    		FileOutputStream fos = new FileOutputStream("2.jpg");
	    		FileChannel fisChannel = fis.getChannel();
	    	    FileChannel fosChannel = fos.getChannel();
	    		){
	    	// 分配指定大小的缓冲区
	    	ByteBuffer buf = ByteBuffer.allocateDirect(1024);
	    	// 将通道中的数据存取缓冲区
	    	while (fisChannel.read(buf) != -1) {
	    		// 读取信息
	    		buf.flip();
	    		fosChannel.write(buf);
	    		buf.clear();
	    	}
	    } catch (FileNotFoundException e) {
	    	// TODO Auto-generated catch block
	    	e.printStackTrace();
	    } catch (IOException e) {
	    	// TODO Auto-generated catch block
	    	e.printStackTrace();
	    }
	}
	
	/**
	 * 使用nio读写文件 :使用直接缓冲区读写文件，速度快，不建议使用，占内存，适用于小文件
	 */
	public static void test4(String file) throws IOException {
		// 读模式
        FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
        // StandardOpenOption.CREATE没有就创建，有就覆盖,StandardOpenOption.CREATE_NEW有就报错
        FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
        // 内存映射文件和ByteBuffer.allocateDirect(1024);直接获取缓冲区一模一样
        // 缓存区目前在物理内存中,直接缓冲区只有ByteBuffer支持
        MappedByteBuffer map = inChannel.map(MapMode.READ_ONLY, 0, inChannel.size());
        MappedByteBuffer map2 = outChannel.map(MapMode.READ_WRITE, 0, inChannel.size());

        // 直接操作缓冲区
        byte[] bs = new byte[map.limit()];
        map.get(bs);
        map2.put(bs);
        
    }
	
	/**
     * 通道之间传输数据，直接缓冲区复制文件
     */
    public void test5() throws IOException {
         // 读模式
         FileChannel inChannel = FileChannel.open(Paths.get("1.jpg"), StandardOpenOption.READ);
         // StandardOpenOption.CREATE没有就创建，有就覆盖,StandardOpenOption.CREATE_NEW有就报错
         FileChannel outChannel = FileChannel.open(Paths.get("2.jpg"), StandardOpenOption.WRITE, StandardOpenOption.READ, StandardOpenOption.CREATE);
         // 从哪到哪去
         inChannel.transferTo(0, inChannel.size(), outChannel);
         outChannel.transferFrom(inChannel, 0, inChannel.size());
         inChannel.close();
         outChannel.close();
    }
	
	/**
     * 分散与读取,将通道中的内容分散到缓冲区中
     */
    public void test6() throws Exception {
         // 分散读取
         RandomAccessFile raf = new RandomAccessFile("1.txt", "rw");
         // 获取通道
         FileChannel channel = raf.getChannel();

         // 分配指定大小缓冲区
         ByteBuffer allocate = ByteBuffer.allocate(100);
         ByteBuffer allocate2 = ByteBuffer.allocate(1000);
         // 分散读取
         ByteBuffer[] bio = { allocate, allocate2 };
         channel.read(bio);
         for (ByteBuffer byteBuffer : bio) {
             // 改编读模式
             byteBuffer.flip();
         }
         // 将缓冲区转换为数组，从第0个转换到limit
         System.out.println(new String(bio[0].array(), 0, bio[0].limit()));
         System.out.println("======================");
         System.out.println(new String(bio[0].array(), 0, bio[1].limit()));

         // 聚集写入
         RandomAccessFile rsf = new RandomAccessFile("2.txt", "rw");
         FileChannel channel2 = rsf.getChannel();

         channel2.write(bio);
    }

    
	/**
	 * 使用nio读取文件所有内容
	 */
	public static String readByNIO(String file){
		StringBuffer result = new StringBuffer();
		//第一步 获取通道
		try (
				FileInputStream fis = new FileInputStream(file);
				FileChannel channel=fis.getChannel();
				){
			//文件内容的大小
			int size=(int) channel.size();
			//第二步 指定缓冲区
			ByteBuffer buffer=ByteBuffer.allocate(size);
			//第三步 将通道中的数据读取到缓冲区中
			while(channel.read(buffer)!=-1) {
				Buffer bf= buffer.flip();
				byte[] bt=buffer.array();
				result.append(new String(bt,0,bt.length));
				buffer.clear();
			}
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		return result.toString();
	}
	
	/**
	  * 利用NIO将内容输出到文件中
	  */
	public static void writeFileByNIO(String file){
	    try (
	    		FileOutputStream fos = new FileOutputStream(file);
	    		//第一步 获取一个通道
	    	    FileChannel fc = fos.getChannel();
	    	    
	    	){
	    	//第二步 定义缓冲区
	    	ByteBuffer buffer = ByteBuffer.allocate(10);
	    	for(int i=0; i<100; i++) {
	    		String aaa = new String("aaa"+i);
	    		byte[] bytes = aaa.getBytes();
	    		for(int m=0; m<bytes.length; m++) {
	    			buffer.put(bytes[m]);
	    			if(buffer.remaining()==0) {
	    				buffer.flip();
	    				//将内容写到缓冲区
	    				fc.write(buffer);
	    				//fos.flush();
	    				buffer.clear();
	    			}
	    		}
	    	}
	    } catch (FileNotFoundException e) {
	    	e.printStackTrace();
	    } catch (IOException e) {
	    	e.printStackTrace();
	    }
	 }


四.io实现socket
Java 网络编程 TCP 传输文件：https://zhuanlan.zhihu.com/p/79377902
改进：服务端多线程处理业务逻辑： Socket 流传输的实现 —— 基于TCP协议：https://zhuanlan.zhihu.com/p/33103147

五.nio实现socket 多线程
https://blog.csdn.net/yiguang_820/article/details/126245942?spm=1001.2014.3001.5501
io和nio使用最大区别在网络通信方面，io是同步阻塞，nio是同步非阻塞
例子：https://blog.csdn.net/dhrtyuhrthfgdhtgfh/article/details/90271123

六.springboot实现socket
io、nio、netty：https://blog.csdn.net/smltq/article/details/103534704

七.springboot整合netty实现socket
Netty检查连接断开的几种方法（只用过第三种方法）：https://www.cnblogs.com/alan6/p/11715722.html

八.websocket
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
springboot+websocket：https://blog.csdn.net/qq_18432653/article/details/109579829
springboot+netty实现websocket：

九：netty
1.官网示例：https://github.com/YeautyYE/netty-websocket-spring-boot-starter/blob/master/README_zh.md
例子：https://blog.csdn.net/qq_27248637/article/details/102552840
2.websocket可实现聊天系统

问题：
1.websocket连接1分钟后自动断开的解决方法：https://blog.csdn.net/rockstreet/article/details/113826562
WebSocket的心跳重连机制：https://blog.csdn.net/qq_33922980/article/details/102646295

十.问题：
1.请问 TCP、Socket、Servlet 、Tomcat 是如何通信的？https://www.zhihu.com/question/399406330
Tomcat 约等于 HTTP服务器（socket连接器） + Servlet容器
2.socket和servlet
socket是应用层与运输层之间的接口，一次连接在客户端和服务器分别有一个socket和server Socket，HTTP 报文经过socket接口进入运输层。
（1）Socket是最底层的通信机制
（2）HTTP是Socket之上的封装层，例如 HttpClient 等。
（3）Servlet是Java 对 HTTP的封装层，目的是为了更好的处理HTTP请求（包括参数）和HTTP响应，毕竟HTTP就分为请求和响应两大部分。
（4）Tomcat是Servlet容器。Servlet必须运行在容器之上。
Tomcat 实现了网络编程，通过servlet处理HTTP报文，再通过socket接口通信。因此我们只需编写经过封装了的servlet程序，容器通过反射等实现通信。
3.那么再来说说Socket和Tomcat的关系：https://www.cnblogs.com/zhangrj9/p/11678048.html
4.阻塞和非阻塞、同步和异步：https://baike.baidu.com/item/%E9%98%BB%E5%A1%9E%E5%92%8C%E9%9D%9E%E9%98%BB%E5%A1%9E/23734057?fr=aladdin
看完此链接后，同步异步在于是否需要等待结果返回；阻塞非阻塞在于当前线程在结果未返回之前是否可以做其他事情。

yigg
关注
专栏目录
利用IO完成端口实现高性能的UDP或TCP通信
gongbenwen的专栏
09-30 1390
在重构通信层的过程中，因为需要增加连接会话处理，
TCP/IP协议、网络IO编程（BIO/NIO）
weixin_36279234的博客
04-13 2939
ISO网络模型与TCP/IP模型对比 TCP/IP协议族 IP网络协议是tcp/ip协议中非常重要的协议，它一般用来确定网络中唯一的一台计算设备。TCP协议是一个面向连接的可靠的协议，TCP通过三次握手建立连接和四次挥手关闭连接，通过带重传机制的肯定确认来确保数据的可靠性。UDP是不可靠的协议，数据发出去以后不管对端有没有接收到，可能会出现丢包的现象。 数据传输 为什么端口号有 65535 个？ 因为在 TCP、UDP 协议报文的开头，会分别有 16 位二进制来存储源端口号和目标端口号
netty和websocket的区别
最新发布
字节叔叔
09-06 1251
Netty是一个底层网络框架，提供了灵活、异步的网络通信能力，可以支持多种协议，包括 WebSocket。WebSocket是一个应用层协议，专注于在浏览器与服务器之间提供低延迟、全双工的通信。
netty与socket对比_Netty之WebSocket和四种IO介绍
weixin_39975900的博客
12-21 6489
Netty简介一、什么是netty？高性能 事件驱动异步非堵塞 基于NIO的客户端，服务器端编程框架稳定性和伸缩性二、Netty的使用场景高性能领域多线程并发领域异步通信领域四种IO介绍1、BIO通信(1)一个线程负责连接(2)一个请求一个应答(3)缺乏弹性伸缩能力 当客户端访问增大，线程造成进程宕机。不能对外服务。2、伪异步IO通信(1)线程池负责连接 当有新的客户端进来，将客户端...
IO模型与TCP并发服务器
08-04 863
IO模型与TCP并发服务器 IO模型 1、阻塞IO 2、非阻塞IO 3、IO多路复用 4、信号驱动IO 1、阻塞IO ===》最常用 默认设置    IO：       scanf()/printf() ====>默认的IO设备       fgetc()/fputc()  ====》标准IO       fgets()/fput
java网络io和tcp_程序员：Java网络编程-TCP协议的模拟
weixin_36269334的博客
02-28 135
关于TCP 先通俗的说一下客户端先与服务端会先建立一条通信管道，之后客户端向服务端发请求，服务端进行回应如下图管道里的操作用到了Java中的IO流基本步骤：客户端1.建立连接：调用Socket(String host,int port)连接服务端2.操作：IO流(输入还是输出)3.释放资源服务端1.使用ServerSocket(int port)创建服务端2.阻塞式等待连接3.操作：IO流(输入还...
TCP协议+IO多路复用 --- select，poll，epoll分析
本末实验室
09-08 2108
select、poll、epoll select，poll，epoll都是IO多路复用的机制。I/O多路复用就是通过一种机制，一个进程可以监视多个描述符，一旦某个描述符就绪（一般是读就绪或者写就绪），能够通知程序进行相应的读写操作。但select，poll，epoll本质上都是同步I/O，因为他们都需要在读写事件就绪后自己负责进行读写，也就是说这个读写过程是阻塞的，而异步I/O则无需自己...
【websocket】与Spring集成 Netty-SocketIO：最好用的Java版即时消息推送
热门推荐
新思维软件
04-27 1万+
Netty-SocketIO是一个开源的、基于Netty的、Java版的即时消息推送项目。通过Netty-SocketIO，我们可以轻松的实现服务端主动向客户端推送消息的场景，比如说股票价格变化、K线图、消息提醒等。它和websocket有相同的作用，只不过Netty-SocketIO可支持所有的浏览器。 GitHub项目地址为： https://github.com/mrniko/netty-s...
Netty源码解析系列三：Netty与Tomcat的区别
Running666的博客
05-20 412
Netty源码解析系列3
搭建百万连接服务，使用netty完成websocke的推送
码农研习社
05-28 1250
一）使用websocket ① 介绍 webSocket协议是基于TCP的一种新的网络协议。他的出现实现了网络和浏览器全双工通信，允许服务器主动发送信息给客户端。客户端 给 服务器发消息是半双工，服务器给客户端也发送消息就是全双工。 多客户端多语言多浏览器支持：浏览器，php，Java，ruby，nginx，python，Tomcat，erlang，.net等等。 ② websocket实现 服务端和客户端交流，通过的是websocket这种协议，内部传输的协议，通过w.
Java IO模型：BIO、NIO、AIO讲解
流楚丶格念的博客
10-17 1989
IO，Input/Output 简写，是指内存和外设之间的数据复制的过程。输入是指数据从外设复制到内存中， 输出则是指数据从内存复制到外设。目前，IO 可以通过数据流、序列化和文件系统为系统提供输入和输出而Java中IO是以流为基础进行输入输出的，所有数据被串行化写入输出流，或者从输入流读入。Java IO的方式通常分为几种，同步阻塞的BIO、同步非阻塞的NIO、异步非阻塞的AIO。
多路复用IO以及TCP并发服务器的实现（练习）
07-20
代码简略的描述了IO复用的流程，以及TCP并发服务器的实现
Netty-WebSocket长连接推送服务
产品应用事业部
12-22 6066
Netty-WebSocket长连接推送服务  November 25, 2015 推送服务 推送服务 几种消息推送技术比较 AJAX轮询 轮询：缺点，糟糕的用户体验；对服务器压力很大，并造成带宽的极大浪费。 Comet：长连接机制，同样由浏览器端主动发起，但Server端以一种很慢的方式给出回应，优点是实时性好，缺点，长时间占用链接，丧失了无状态高并发的缺 点 Fla
SpringBoot+Netty实现WebSocket服务器
u013374645的博客
10-22 1万+
前言 传统的请求-应答模式（http）越来越不能满足现实需求，服务器过于被动，而采用轮训或者long poll的方式过于浪费资源，这便有了WebSocket。WebSocket是HTML5出的东西（协议），也就是说HTTP协议没有变化，或者说没关系，但HTTP是不支持持久连接的（长连接，循环连接的不算）首先，Websocket是一个持久化的协议，相对于HTTP这种非持久的协议来...
计算机网络 | I/O模型、网络模型（OSI七层及TCP/IP四层）
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
06-01 3767
五种IO模型、OSI七层网络模型、TCP/IP四层网络模型详解。
socket、websoket、netty、socket.io 对比
qq_38542834的博客
08-05 4534
socket、websoket、netty、socket.io 含义之间的对比
基于Netty实现的netty-socketio实现WebSocket
weixin_34315189的博客
05-28 967
2019独角兽企业重金招聘Python工程师标准>>> ...
scoket.io
Dason_yu的博客
07-26 944
socket理解 原文：http://www.cnblogs.com/xiezhengcai/p/3957314.html  socket.io 系统api 原文：http://www.cnblogs.com/xiezhengcai/p/3956401.html  因为http协议是无状态的，要实现浏览器与服务器的实时通讯，如果不使用 flash、applet 等浏览器插件的话，就需要定期轮询
springboot netty实现socket_springboot集成netty-socketio实现websocket
weixin_39963287的博客
11-26 890
springboot中消息推送系统设计与实现 这里采用的是springboot+netty-socketio+rabbitmq消息中心设计1.服务端消息推送，采用netty-socketio开源框架，这里选择的是netty-socketio:1.7.17 版本 注意：选择的版本要注意netty的版本一致问题，其他框架如果也用了netty,一定要保持netty版本一致，否则会影响websocket服...
写一个TCP协议下的netty服务器
03-23
import io.netty.channel.socket.nio.NioServerSocketChannel; public class NettyServer { private int port; public NettyServer(int port) { this.port = port; } public void run() throws Exception {...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值