day24-网络编程02【NIO-HTTP协议-未完】

最新推荐文章于 2024-05-06 17:30:00 发布
最新推荐文章于 2024-05-06 17:30:00 发布
阅读量110 收藏 1
点赞数
文章标签： 网络 nio http
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42929213/article/details/128747107
版权

文章目录

1、NIO

1.1、NIO通道客户端

  • 客户端实现步骤
    1. 打开通道
    2. 指定IP和端口号
    3. 写出数据
    4. 释放资源
  • 示例代码
public class NIOClient {
    public static void main(String[] args) throws IOException {
        //1.打开通道
        SocketChannel socketChannel = SocketChannel.open();

        //2.指定IO和端口号
        socketChannel.connect(new InetSocketAddress("127.0.0.1",10000));

        //3.写出数据
        ByteBuffer byteBuffer = ByteBuffer.wrap("一点寒芒先到".getBytes());
        socketChannel.write(byteBuffer);

        //释放资源
        socketChannel.close();
    }
}

1.2、NIO通道服务端

  • NIO通道
    • 服务端通道：只负责建立，不负责传递数据
    • 客户端通道：建立并将数据传递给服务端
    • 缓冲区：客户端发送的数据都在缓冲区中
    • 服务端通道内部创建出来的客户端通道：相当于客户端通道的延伸来传递数据
  • 服务端实现步骤
    1. 打开一个服务端通道
    2. 绑定对应的端口号
    3. 通道默认是阻塞的，需要设置为非阻塞
    4. 此时没有门卫大爷，所以需要经常看一下有没有连接发过来没有？
    5. 如果由客户端来连接了，则在服务端通道内部，再创建一个客户端通道，相当于是客户端通道的延伸
    6. 获取客户端传递过来的数据，并把数据放在byteBuffer1这个缓冲区中
    7. 给客户端写数据
    8. 释放资源
  • 示例代码
public class NIOServer {
    public static void main(String[] args) throws IOException {
        //1.打开一个服务端通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //2.绑定对应的端口号
        serverSocketChannel.bind(new InetSocketAddress(10000));
        //3.通道默认是阻塞的，需要设置为非阻塞的
        //如果传递true,表示通道设置为阻塞通道...默认值
        //如果传递false,表示通道设置为非阻塞通道
        serverSocketChannel.configureBlocking(false);
        //4.此时没有门卫大爷，所以需要经常看一下有么有连接发送过来
        while(true){
            //5.如果有客户端来连接了，则在服务端通道内部，再创建一个客户端通道，相当于客户端通道的延伸
            //此时已经设置了通道为非阻塞
            //所以在调用方法的时候，如果有客户来连接，那么就会创建一个SocketChannel对象
            //如果在调用方法的时候，没有客户端来连接，那么他会返回一个null
            SocketChannel socketChannel = serverSocketChannel.accept();
            System.out.println(socketChannel);
            if(socketChannel!=null){
                //6.客户端将缓冲区通过通道传递给服务端，就到了这个延伸通道socketChannel里面
                //7.服务端创建一个空的缓冲区装数据并输出
                ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                //获取传递过来的数据，并把它们放在byteBuffer缓冲区中
                //返回值：
                    //正数：表示本次读到的有效字节个数
                    //0:表示本次没有读到有效字节
                    //-1:表示读到了末尾
                int len = socketChannel.read(byteBuffer);
                System.out.println(new String(byteBuffer.array(),0,len));
                //释放资源
                socketChannel.close();
            }
        }
    }
}

1.3、NIO通道练习

  • 客户端
    • 实现步骤
      1. 打开通道
      2. 指定IP和端口号
      3. 写出数据
      4. 读取服务器写回的数据
      5. 释放资源
  • 示例代码
public class Client {
    public static void main(String[] args) throws IOException {
        //1.打开通道
        SocketChannel socketChannel = SocketChannel.open();
        //2.指定IP和端口号
        socketChannel.connect(new InetSocketAddress(("127.0.0.1"),10000));
        //3.写出数据
        ByteBuffer byteBuffer1 = ByteBuffer.wrap("吃俺老孙一棒棒".getBytes());
        socketChannel.write(byteBuffer1);
        //手动写入结束标记
        socketChannel.shutdownOutput();
        //4.读取服务器写回的数据
        ByteBuffer byteBuffer2 = ByteBuffer.allocate(1024);
        int len;
        while((len=socketChannel.read(byteBuffer2))!=-1){
            byteBuffer2.flip();
            System.out.println(new String(byteBuffer2.array(),0,len));
            byteBuffer2.clear();
        }
        //5.释放资源
        socketChannel.close();
    }
}
  • 服务端
    • 实现步骤
      1. 打开一个服务端通道
      2. 绑定对应的端口号
      3. 通道默认是阻塞的，需要设置为非阻塞
      4. 此时没有门卫大爷，所以需要经常看一下有没有连接发过来？
      5. 如果有客户端来连接了，则在服务端通道内部，再创建一个客户端通道，相当于是客户端通道的延伸
      6. 获取客户单传递过来的数据，并把数据放在byteBuffer1这个缓冲区中
      7. 给客户端回写数据
      8. 释放资源
  • 示例代码
public class Server {
    public static void main(String[] args) throws IOException {
        //1.打开一个服务端通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //2.绑定对应的端口号
        serverSocketChannel.bind(new InetSocketAddress(10003));
        //3.通道默认是阻塞的，需要设置为非阻塞
        serverSocketChannel.configureBlocking(false);
        //4.此时没有门卫大爷，所以需要经常看一下有没有连接发送过来
        while(true){
            //5.如果有客户端来连接了，则在服务器端通道内部，再创建一个客户端通道，相当于是客户端通道的延伸
            SocketChannel socketChannel = serverSocketChannel.accept();
            if(socketChannel != null){
                System.out.println("此时有客户端来连接了");
                //6.获取客户端传递过来的数据，并把数据放在byteBuffer1这个缓冲区中
                ByteBuffer byteBuffer1 = ByteBuffer.allocate(1024);
                int len;
                //针对于缓冲区来讲
                    //如果 从添加数据 ---> 获取数据 flip
                    //如果 从获取数据 ---> 添加数据 clear
                while((len = socketChannel.read(byteBuffer1))!=-1){
                    byteBuffer1.flip();
                    System.out.println(new String(byteBuffer1.array(),0,len));
                    byteBuffer1.clear();
                }
                System.out.println("接收数据完毕，准备开始往客户端回写数据");
                //7.给客户端回写数据
                ByteBuffer byteBuffer2 = ByteBuffer.wrap("哎哟，真疼啊！！！！".getBytes());
                socketChannel.write(byteBuffer2);
                //释放资源
                socketChannel.close();
            }
        }
    }
}

1.4、NIO通道练习优化

  • 存在问题：服务端内部获取客户端通道在读取时，如果读取不到结束标记就会一直阻塞
  • 解决方案：将服务端内部获取的客户端通道设置为非阻塞的
  • 示例代码
public class Client {
    public static void main(String[] args) throws IOException {
        SocketChannel socketChannel = SocketChannel.open();
        socketChannel.connect(new InetSocketAddress("127.0.0.1",10003));
        ByteBuffer byteBuffer1 = ByteBuffer.wrap("吃俺老孙一棒".getBytes());
        socketChannel.write(byteBuffer1);
        System.out.println("数据已经写给服务器");
        ByteBuffer byteBuffer2 = ByteBuffer.allocate(1024);
        int len;
        while((len = socketChannel.read(byteBuffer2))!=-1){
            System.out.println("客户端接收回写数据");
            byteBuffer2.flip();
            System.out.println(new String(byteBuffer2.array(),0,len));
            byteBuffer2.clear();
        }
        socketChannel.close();
    }
}
----------------------------------------------------
public class Server {
    public static void main(String[] args) throws IOException {
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(10003));
        serverSocketChannel.configureBlocking(false);
        while (true){
            SocketChannel socketChannel = serverSocketChannel.accept();
            if(socketChannel != null){
                System.out.println("此时有客户端来连接了");
                //将服务端内部获取的客户端通道设置为非阻塞的
                socketChannel.configureBlocking(false);
                //获取客户端传递过来的数据，并把数据放在byteBuffer1这个缓冲区中
                ByteBuffer byteBuffer1 = ByteBuffer.allocate(1024);
                int len;
                //针对于缓冲区来讲
                    //如果从添加数据--->获取数据 flip
                    //如果从获取数据--->添加数据 clear
                while ((len=socketChannel.read(byteBuffer1))>0){
                    System.out.println("服务端接收发送数据");
                    byteBuffer1.flip();
                    System.out.println(new String(byteBuffer1.array(),0,len));
                    byteBuffer1.clear();
                }
                System.out.println("接收数据完毕，准备开始往客户端回写数据");
                ByteBuffer byteBuffer2 = ByteBuffer.wrap("哎哟，真疼啊!!!".getBytes());
                socketChannel.write(byteBuffer2);
                socketChannel.close();
            }
        }
    }
}

1.5、NIO选择器

  • 概述
    • 选择器可以监视通道的状态，多路复用
      在这里插入图片描述
      在这里插入图片描述
  • 选择器对象
    • Selector:选择器对象
    • SelectionKey:绑定的key
    • SelectableChannel:能使用选择器的通道
      • SocketChannel
      • ServerSocketChannel

1.6、NIO选择器改写服务端

  • 实现步骤
    1. 打开一个服务端通道(open)
    2. 绑定对应的端口号
    3. 通道默认是阻塞的，需要设置为非阻塞
    4. 打开一个选择器（门卫大爷）
    5. 将选择器绑定服务器通道，并监视服务端是否准备好
    6. 如果有客户端来连接了，大爷会遍历所有的服务端通道，谁准备好了，就让谁来连接，连接后，在服务端通道内部，再创建一个客户端延伸通道
    7. 如果客户端把数据传递过来了，大爷会遍历所有的延伸通道，谁准备好了，谁去接收数据
      在这里插入图片描述
  • 代码实现
//客户端
public class Client {
    public static void main(String[] args) throws IOException {
        SocketChannel socketChannel = SocketChannel.open();

        socketChannel.connect(new InetSocketAddress("127.0.0.1", 10005));

        ByteBuffer byteBuffer1 = ByteBuffer.wrap("吃俺老孙一棒".getBytes());
        socketChannel.write(byteBuffer1);

        System.out.println("数据已经写给服务器");

        ByteBuffer byteBuffer2 = ByteBuffer.allocate(1024);
        int len;
        while ((len = socketChannel.read(byteBuffer2)) != -1) {
            System.out.println("客户端接收回写数据");
            byteBuffer2.flip();
            System.out.println(new String(byteBuffer2.array(), 0, len));
            byteBuffer2.clear();
        }
        socketChannel.close();
    }
}
---------------------------------------------
//服务端
public class Server {
    public static void main(String[] args) throws IOException {
        //1.打开服务端通道
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //2.让这个通道绑定一个端口
        serverSocketChannel.bind(new InetSocketAddress(10005));
        //3.设置通道为非阻塞
        serverSocketChannel.configureBlocking(false);
        //4.打开一个选择器
        //Selector---选择器
        //SelectionKey---绑定通道后返回那个令牌
        //SelectableChannel---可以使用选择器通道
        Selector selector = Selector.open();
        //5.绑定选择器和服务端通道
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        while(true){
            System.out.println("11");
            //选择器会监视客户端通道的状态
            //6.返回值就表示此时有多少个客户端来连接
            int count = selector.select();
            System.out.println("222");
            if(count!=0){
                System.out.println("有客户端来连接了");
                //7.会遍历所有的服务端通道，看谁准备好了，谁准备好了，就让谁去连接
                //获取所有服务端的令牌，并将他们都放到一个集合中，将集合返回
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()){
                    //selectKey 依次表示每一个服务端通道的令牌
                    SelectionKey selectionKey = iterator.next();
                    if(selectionKey.isAcceptable()){
                        //可以通过令牌来获取一个已经就绪的服务端通道
                        ServerSocketChannel ssc = (ServerSocketChannel)selectionKey.channel();
                        //客户端的延伸通道
                        SocketChannel socketChannel = ssc.accept();
                        //将客户端延伸通道设置为非阻塞的
                        socketChannel.configureBlocking(false);
                        socketChannel.register(selector,SelectionKey.OP_READ);
                        //当客户端来连接的时候，所有的步骤已经全部执行完毕
                    }else if(selectionKey.isReadable()){
                        //当前通道已经做好了读取的准备（延伸通道）
                        SocketChannel socketChannel = (SocketChannel)selectionKey.channel();
                        ByteBuffer byteBuffer1 = ByteBuffer.allocate(1024);
                        int len;
                        while((len = socketChannel.read(byteBuffer1))>0){
                            byteBuffer1.flip();
                            System.out.println(new String(byteBuffer1.array(),0,len));
                            byteBuffer1.clear();
                        }
                        //给客户端的回写数据
                        socketChannel.write(ByteBuffer.wrap("哎哟喂好痛啊！！！".getBytes()));
                        socketChannel.close();
                    }
                    iterator.remove();
                }
            }
        }
    }
}

2、HTTP协议

2.1、概述

超文本传输协议（关于超文本的概念javaWeb再进行学习），是建立在TCP/IP协议基础上，是网络应用层的协议。
由请求和响应构成，是一个标准的客户端和服务器模型

2.2、URL

  • 概述
    • 统一资源定位符，常见的如：http://bbs.itheima.com/forum.php
    • 完整的格式：http://bbs.itheima.com:80/forum.php
  • 详解：
    在这里插入图片描述

2.3、抓包工具的使用

  • 使用步骤
    1. 在谷歌浏览器网页中按F12或者网页空白处右键，点击检查，可以调出工具
    2. 点击network,进入到查看网络相关信息界面
    3. 这时在浏览器中发起请求，进行访问，工具中就会显示出请求和响应相关的信息
      在这里插入图片描述

2.4、请求信息

  • 组成
    • 请求行
    • 请求头
    • 请求空行
    • 请求体
  • 请求行
    • 格式
      在这里插入图片描述
    • 请求方式
      • GET,POST,HEAD,PUT,DELETE,CONNECT,OPTIONS,TRACE,PATCH
    • URL
      • 请求资源路径，统一资源表示符
        在这里插入图片描述
  • 请求头
    • 格式
      在这里插入图片描述
    • 请求头名称：
      • Host：用来指定请求的服务端地址
      • Connect：取值为keep-alive表示需要持久连接
      • User-Agent：客户端信息
      • Accept：指定客户端能够接收的内容类型
      • Accept-Encoding：指定浏览器可以支持的服务器返回内容压缩编码类型
      • Accept-Language：浏览器可接受的语言
        在这里插入图片描述
  • 小结
    在这里插入图片描述

2.5、响应信息

  • 组成
    • 响应行
    • 响应头
    • 响应空行
    • 响应体
  • 响应体
    • 格式
      在这里插入图片描述
    • 协议版本
      • HTTP1.0：每次请求和响应都需要建立一个单独的连接
      • HTTP1.1：支持长连接
    • 响应状态码
      • 1xx：指示信息（表示请求已接收，继续处理）
      • 2xx：成功（表示请求已被成功接收、理解、接受）
      • 3xx：请求重定向（要完成请求必须进行更进一步的操作）
      • 4xx：客户端错误（请求有语法错误或请求无法实现）
      • 5xx：服务端错误（服务器未能实现合法的请求）
    • 状态信息
      • 200 OK
      • 404 Not Found
      • 500 Internal Server Error
    • 响应头
      • 响应头名称
        • Content-Type:告诉客户端实际返回内容的网络媒体类型（互联网媒体类型，也叫做MIME类型）
        • 响应头值
          • text/html —> 文本类型
          • image/png —> png格式文件
          • image/jpep—>jpg格式文件
            在这里插入图片描述
  • 小结
    在这里插入图片描述

3、HTTP服务器

3.1、需求

  • 编写服务端代码，实现可以解析浏览器的请求，给浏览器响应数据

3.2、环境搭建

  • 实现步骤
    • 编写HttpServer类，实现可以接收浏览器发出的请求
    • 其中获取连接的代码可以单独抽取到一个类中
  • 代码实现
一人一只猫
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
httpcore-nio-4.4.6-API文档-中文版.zip
03-29
赠送jar包：httpcore-nio-4.4.6.jar 赠送原API文档：httpcore-nio-4.4.6-javadoc.jar 赠送源代码：httpcore-nio-4.4.6-sources.jar 包含翻译后的API文档：httpcore-nio-4.4.6-javadoc-API文档-中文(简体)版.zip ...
使用NIO实现http请求流程
weixin_42107858的博客
07-26 2131
使用NIO实现http请求流程 1 http协议请求流程如下 2 代码实现如下 import java.io.*; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.*; import java.util.*; import java.util.concurrent.ExecutorService; import java.util.concurrent.Exec..
Java nio 建立HTTP Server
博客
02-04 2877
HTTP Server 基于HTTP 的服务器，常见的框架很多，例如说著名的Tomcat，Nginx等。是目前常见的应用的基本部分，也是C/S 架构 或者说B/S架构中重要的部分。 前面的几篇文章使用了BIO创建了HTTP Server，本文就来讲讲使用NIO来创建HTTP Server。 区别 BIO ： Java中常见的ServerSocket和Socket类，应用的十分之多了，但同
nio实现http及https代理
jumprn的博客
05-22 2239
一，回望BIO 上篇博文用了java 阻塞模型socket实现了http及https代理，也简单的说了下其主要缺点是比较耗费资源或者更好的说法是资源利用率不高，为什么呢？一旦客户端和代理服务器每建立一个连接（基本上每请求一个url就会建立一个新的连接）而我们实现的代理服务器为了去监听客户端发给服务器端的消息并转发就建立一个线程去专门的监听相应的流并处理转发这些数据到目标服务...
java使用NIO构造http请求
jianghuihong2012的专栏
09-26 3492
使用java的NIO来构造http请求体，并且取得响应内容。 package com.test.nio; import java.net.InetSocketAddress; import java.nio.ByteBuffer; import java.nio.channels.SocketChannel; import java.nio.charset.Charset; public c
java http nio_用NIO实现http协议
weixin_39940688的博客
02-15 1172
先来看一下本篇博文的目录：一：简介Nio二：Nio的好处三：关于http协议四：代码实现五：总结一：简介Nio我们都知道io流，那么NIO是什么呢？本篇博文将会带你一探NIO，NIO的全称叫做New IO，顾名思义也就是全新的IO流，从Java Api 1.4版本开始发行的，nio提供了完全不同的工作体制，java nio的IO模型是同步非阻塞,也就是当用户发起一个IO操作后，边可等待边可返回，但...
httpcore-nio-4.4.15-API文档-中文版.zip
03-30
赠送jar包：httpcore-nio-4.4.15.jar 赠送原API文档：httpcore-nio-4.4.15-javadoc.jar 赠送源代码：httpcore-nio-4.4.15-sources.jar 包含翻译后的API文档：httpcore-nio-4.4.15-javadoc-API文档-中文(简体)版....
httpcore-nio-4.3.jar包
07-01
用Java实现非阻塞通信 ，用ServerSocket和Socket来编写服务器程序和客户程序，是Java网络编程的最基本的方式。 httpcore-nio-4.3.jar包
httpcore-nio-4.4.15-API文档-中英对照版.zip
03-30
赠送jar包：httpcore-nio-4.4.15.jar 赠送原API文档：httpcore-nio-4.4.15-javadoc.jar 赠送源代码：httpcore-nio-4.4.15-sources.jar 包含翻译后的API文档：httpcore-nio-4.4.15-javadoc-API文档-中文(简体)-...
网络协议(二)：NIO与HTTP与http服务器
weixin_46300935的博客
06-27 797
NIO NIO通道客户端【应用】 客户端实现步骤 打开通道 指定IP和端口号 写出数据 释放资源 示例代码 public class NIOClient { public static void main(String[] args) throws IOException { //1.打开通道 SocketChannel socketChannel = SocketChannel.
FR-TSN4206获得“时间敏感网络产业链名录计划”测试认证证书，TSN交换机助力智能工业发展
fiberroad的博客
04-30 487
TSN技术，即时间敏感网络技术，已成为智能工业、自动驾驶等领域的核心。它通过时钟同步、数据调度等功能，确保低延迟、高可靠性的数据传输。为推动TSN技术在我国的发展，工业互联网产业联盟联合多家单位启动了“时间敏感网络产业链名录计划”。光路科技的FR-TSN4206交换机成功通过该计划认证
java线上问题排查之磁盘和网络查看分析（二）
wayne_youlu的博客
04-30 501
overflowed 标识全连接队列溢出的次数,最前面是0，标识没有队列溢出的情况，网络环境正常。来查看网络是否连接。如果出现下图内容，则证明网络已经连接。
前端调用WebSocket协议接口获取数据
m0_56023096的博客
04-29 496
createWs("测试数据", (res) => {
万兆以太网MAC设计（11）完整UDP协议栈仿真
m0_56222647的博客
04-28 1340
目前除了巨帧处理逻辑之外，所有的准备工作都已经结束了，先进行整体的功能验证。
用 Python 进行渗透测试
黑战士的博客
04-28 1114
编写一个端口扫描器Python 提供了访问 BSD 套接字的接口Web 服务器可能位于 TCP 80 端口、电子邮件服务器在 TCP 25 端口、FTP 服务器在 TCP 21 端口TCP 全连接扫描为了抓取目标主机上应用的 Banner，找到开放的端口后，向它发送一个数据串并等待响应。
网络安全实训Day16
Yisitelz的博客
04-26 2106
网络空间安全第16天学习笔记。漏洞扫描；内网渗透
Linux内核常用调优参数
虫虫的博客
04-30 876
Linux内核常用调优参数
专注 APT 攻击与防御—基于UDP发现内网存活主机
最新发布
weixin_62641226的博客
05-06 349
UDP（User Datagram Protocol）是一种无连接的协议，在第四层-传输层，处于IP协议的上一层。UDP有不提供数据包分组、组装和不能对数据包进行排序的缺点，也就是说，当报文发送之后，是无法得知其是否安全完整到达的。
http-nio-8080-exec-1
06-06
http-nio-808-exec-1是Tomcat服务器中的一个线程，用于处理来自客户端的HTTP请求。它是通过NIO（非阻塞IO）方式处理请求的，可以提高服务器的性能和吞吐量。当客户端发送一个HTTP请求时，Tomcat服务器会为该请求分配一个http-nio-808-exec-1线程来处理请求，并在处理完请求后将响应返回给客户端。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值