Http协议与静态web服务器学习

最新推荐文章于 2024-10-02 02:07:13 发布
最新推荐文章于 2024-10-02 02:07:13 发布
阅读量272 收藏
点赞数 2
分类专栏： 网络编程 文章标签： http web service
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43734041/article/details/119916370
版权

HTTP协议

1.Http协议介绍

HTTP 协议 全程，中文超文本传输协议
超文本是超级文本的缩写，是指超越文本限制或超链接，比如：图片、音乐、视频、超链接等都属于超文本
HTTP （1991）设计的目的：传输网页数据，现在允许传输任意类型的数据
传输HTTP协议（通信数据的格式）格式的数据是基于TCP 传输协议的，发送数据之前先建立连接

  1. HTTP协议的作用
    它规定了浏览器和Web服务器通信数据的格式，也就是说浏览器和web服务器通信需要使用http协议

  2. 浏览器访问web服务器的通信过程
    web服务器程序默认端口号为80

    1. 浏览器输入网址–通过DNS（域名解析服务器）将域名解析成ip地址
    2. 客户端获取到ip地址，端口号（web服务程序默认端口号为80）
    3. 与web服务器程序建立连接（HTTP是基于TCP的）
    4. 发送http请求数据到web服务器程序（http格式的数据）
    5. web服务器根据请求获取本地服务器主机资源
    6. 本地服务器主机返回资源到web服务器
    7. web服务器返回http响应数据到浏览器

2.URL

URL 表达的是统一资源定位符，通俗讲就是网络资源地址，也是常说的网址

  1. URL组成：
    1. 样式：https://news.163.com/18/1122/10/E178J2O.html
    2. 协议部分：https:// (会对http://的数据进行加密 端口号 443) http://（端口号为80） ftg://
    3. 域名部分：news.163.com
    4. 资源路径：18、/34fds3245fs.html
    5. 查询参数部分（可选）
  2. 域名就是ip地址的别名，是用点进行分割使用英文字母和数字组成的名字，使用域名目的就是方便记忆某台ip地址
  3. url https://news.163.com/heellooe.html?page=1&count=10
    1. ? 后面的参数 都 使用& 连接

3.HTTP请求报文

  1. http请求报文（浏览器发送给web服务器程序的http协议数据）
    1. http最常见的请求报文有两种：
      1. GET 方式请求报文 获取web服务器数据 如：新闻列表
      2. POST 方式请求报文 向web服务器提交数据以及获取数据 如：登录
  2. HTTP GET 请求报文
    1. 格式：
      1. 请求行 \r\n
      2. 请求头 、\r\n
      3. 空行 \r\n
      4. 每项信息之间都需要一个 \r\n ，不能有空格，要http协议规定
    2. 请求报文 请求头–请求行–空行
      1. GET/HTTP/1.2 请求方式 请求资源路径 http协议版本
      2. HOST： 服务器主机ip地址和端口号，默认端口号是80
      3. Connection:Keep-alive 和服务端操持长链接，当客户端和服务端有一段时间（3-5）没有进行通信，服务器程序就会主动向客户端断开连接
      4. Upgrade-Insecure-Requests:1 让客户端请求不安全请求，以后会用https
      5. User-Agent 用户代理，客户端程序名称，
      6. Accept 告诉服务端程序可以接受的数据类型
      7. Accept-Encoding: 告诉服务端程序支持的压缩算法
      8. Accept-Language: 告诉服务端程序支持的语言
      9. Cookie 客户端用户身份的标识（唯一的）
  3. HTTP POST 请求报文
    1. GET 请求格式
    2. Form Data 请求体，浏览器发送给服务器的数据（可以没有但很少）
  4. HTTP 响应报文（服务端程序传过来的数据）响应行–响应头–空行–响应体
    1. HTTP/1.1 200 OK HTTP协议版本 状态码 状态描述（响应行）
    2. Server 服务器的名称
    3. Content-Type 服务器发送给浏览器的内容类型及编码格式
    4. Transfer-Encoding 服务器发送给客户端程序（浏览器）的数据不确定数据长度 数据发送结束的接收标识 ：0\r\n Content-Length:200(字段) 服务器发送给客户端程序的数据确定长度
    5. Connection ：Keep-alive 和客户端保持长连接
    6. Data 服务器的时间 （0时区时间 北京是东八区 差8个小时）
    7. 剩下是自定义响应头信息，自己定义响应头的名字和响应头的信息
    8. —空行—
    9. —响应体—
    10. 每一项都有 \r\n
    11. –响应体 就是真正意义上给浏览器解析使用的数据–（Response里的）
    12. 对于请求头和响应头信息程序员都可以自定义，按照客户端和服务器约定好的发方式进行来判定即可
  5. 状态码（用于标识web服务器响应状态的3位数字代码）
    1. 200 请求成功
    2. 307 重定向
    3. 400 错误请求，请求地址或者参数有误
    4. 404 请求资源在服务器不存在
    5. 500 服务器内部资源代码出现错误

4.搭建Python自带静态Web服务器

  1. 静态Web服务器是什么？
    可以为发出请求的浏览器提供静态文档的程序，
    我们平时浏览百度新闻数据的时候，每天的新闻数据都是会发生变化，此访问的页面就是动态的，而我们开发的是静态的，页面的数据不会发生改变
  2. 如何搭建Python自带的静态Web服务器
    1. 搭建Python自带的静态Web服务器 使用 python3 -m http.server 端口号（默认是8000）
    2. -m 表示运行包里面的模块，执行这个命令的时候，需要进入自己指定的静态文件的目录，然后通过浏览器就能访问对应的html 文件了，这样一个静态的Web服务器就搭建好了

5.搭建自己的静态Web服务器

  1. 步骤
    1. 编写一个TCP服务端程序
    2. 获取浏览器发送的http请求报文数据
    3. 读取固定页面的数据，把页面数据组装成HTTP响应报文数据发送给浏览器
    4. HTTP响应报文数据发送完成后，关闭服务于客户端的套接字
  2. 搭建静态Web服务器–返回固定页面数据
    1. 创建服务端套接字对象
    2. 设置服务端套接字复用
    3. 绑定端口号
    4. 设置监听（最大监听数为128）
    5. 等待接收客户端连接请求，拿到客户端传来的通信套接字 （循环等待）
    6. 接收客户端的请求想信息 （数据量大概在4k多）
    7. with open 打开文件 读取数据（文件路径为html 文件路径，encoding=‘utf-8’(可选)）
    8. 响应行 response_line=‘HTTP协议版本 状态码 状态描述 \r\n’
    9. 响应头 response_header=‘Server: 服务器名称(一般为python的) \r\n’
    10. 空行
    11. 响应体 response_body=f_data(读物到的文件中数据)
    12. 把数据封装成http 响应报文的数据格式 response=response_line+response_header+’\r\n’+response_body
    13. 将字符串编码为二进制 response_data=response.encode(‘utf-8’)
    14. 将响应报文数据发送给浏览器 new_socket.send(response_data)
    15. 关闭客户端套接字
import socket
#判断是否主模块
if __name__=='__main__':
    #创建tcp服务端套接字
    tcp_server_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    #设置端口号复用
    tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
    #绑定套接字端口号
    tcp_server_socket.bind(('',8000))
    #设置监听 最大监听数
    tcp_server_socket.listen(128)
    while True:
        #等待连接
        new_socket,iport=tcp_server_socket.accept()
        # print('收到端口号为',iport)
        #接收客户端请求信息
        recv_data=new_socket.recv(4096)
        print(recv_data)
        #打开文件读取数据 with opne 系统榜我们关闭文件
        with open('wenjian/templates/index.html',encoding='utf-8') as f:
            f_data=f.read()
        #把数据封装成http 响应报文格式的数据
       	#响应行
        response_line='HTTP/2 200 OK\r\n'
        #响应头
        response_header='Server: PWS/2.0\r\n'
        #空行
   	 	#响应体
        response_body=f_data
       	#把数据封装成http 响应报文格式的数据
       	response=response_line+response_header+'\r\n'+response_body
        #把字符串编码成二进制
        response_data=response.encode('utf-8')
        #发送给浏览器的响应报文数据
        new_socket.send(response_data)
        #关闭服务于客户端的套接字
        new_socket.close()

6.静态服务器-返回指定页面内容

  1. 创建服务端套接字对象
  2. 设置端口号复用
  3. 绑定端口号
  4. 设置监听
  5. 等待客户端连接请求 得到新的通信套接字 （循环保持服务长启）
  6. 接收客户端的请求信息 并对之解码 （需要判断接收的数据长度是否为0，防止客户端不发送信息，造成服务器奔溃）（请求报文的请求头有页面信息）
  7. 利用空格分割得到指定页面名称
  8. 打开指定文件（为图片能够加载 使用 rb 模式）（判断客户端请求是否为根目录，设置默认值）
  9. 响应行
  10. 响应头
  11. 空行
  12. 响应体=文件读取的数据
  13. 将数据封装成 http 格式 并转换为字节码格式
  14. 发送http协议数据
  15. 关闭客户端套接字
'''返回指定页面数据'''
import socket
def main():
    #1.创建服务端套接字
    tcp_server_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    #设置套接字复印
    tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
    #3.绑定端口号
    tcp_server_socket.bind(('',8000))
    #4.设置监听
    tcp_server_socket.listen(128)
    while True:
        #等待客户端连接请求
        new_socket,iport=tcp_server_socket.accept()
        #接收客户端请求数据
        recv_data_en=new_socket.recv(4096)
        if len(recv_data_en) == 0:
            new_socket.close()
            return
        #将接收的数据解码
        recv_data=recv_data_en.decode('utf-8')
        #将解码的字符串 空格分割 得到请求的指定页面信息
        recv_data_list=recv_data.split(' ',maxsplit=2)
        request_path=recv_data_list[1]
        print(request_path)
        # 判断当亲戚去为 / 默认为index 文件
        if request_path=='/':
            request_path='/index.html'
        #打开相应文件读取信息 使用rb兼容打开图片
        with open('wenjian'+request_path,'rb') as f:
            f_data=f.read()
        #响应行
        response_line='HTTP/2 200 OK\r\n'
        # 响应头
        response_header='Server: PWS/2.0\r\n'
        #空行
        #响应体
        response_body=f_data
        #经数据封装成http 格式数据
        response=(response_line+response_header+'\r\n').encode('utf-8')+response_body
        # 发送数据
        new_socket.send(response)
        #关闭客户端套接字
        new_socket.close()
if __name__ == '__main__':
    main()

7.返回404页面

在原有基础上添加 判断请求页面是否存在

  1. 通过os.path.exits
  2. 通过异常处理
'''返回404'''
import socket
import os
def main():
    #创建服务端套接字对象
    tcp_server_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    #设置端口号复用
    tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
    # 绑定端口号
    tcp_server_socket.bind(('',8000))
    #设置监听
    tcp_server_socket.listen(128)
    while True:
        # 等待客户端连接请求
        new_socket,iport=tcp_server_socket.accept()
        recv_data=new_socket.recv(4096)
        if len(recv_data)==0:
            new_socket.close()
            return
        #解码
        recv_datam=recv_data.decode('utf-8')
        #拿到客户端请求的页面名称
        request_li=recv_datam.split(' ',maxsplit=2)
        request=request_li[1]
        if request=='/':
            request='/index.html'
        print(request)
        #1.os.path.exits
        #2.try-except
        #打开页面文件
        try:
            with open('wenjian'+request,'rb') as f:
                f_data=f.read()
        except Exception as e:
            #找不到页面
            # 响应行
            response_line = 'HTTP/2 404 Not Found\r\n'
            # 响应头
            response_header = 'Server PWS/2.0\r\n'
            # 空行
            # 响应体
            with open('wenjian/error.html',encoding='utf-8') as f:
                f_data=f.read()
            response_body=f_data
            # 封装http 数据
            response = response_line + response_header + '\r\n'+ response_body
            # 发送数据
            new_socket.send(response.encode('utf-8'))
        else:
            #响应行
            response_line='HTTP/2 200 OK\r\n'
            #响应头
            response_header='Server PWS/2.0\r\n'
            #空行
            #响应体
            response_body=f_data
            #封装http 数据
            response=(response_line+response_header+'\r\n').encode('utf-8')+response_body
            #发送数据
            new_socket.send(response)
        finally:
            #关闭客户端套接字
            new_socket.close()
if __name__ == '__main__':
    main()

8.多任务

通过应用线程

'''多任务'''
import socket,os,threading
def th_accept(new_socket):
    # 接收客户端传来的数据
    recv_data = new_socket.recv(4096)
    # 判断数据是否为空
    if len(recv_data) == 0:
        new_socket.close()
        return
    # 解码
    recv_d = recv_data.decode('utf-8')
    # 分割请求报文信息
    recv_li = recv_d.split(' ', 2)
    # 得到请求页名称
    request = recv_li[1]
    if request == '/':
        request = '/index.html'
    # 判断 请求页数据是否存在
    if not os.path.exists('wenjian' + request):
        with open('wenjian/error.html', encoding='utf-8') as f:
            f_data = f.read()
        # 响应行
        response_line = 'HTTP/2 404 Not Found\r\n'
        # 响应头
        response_header = 'Server PWS/2.0\r\n'
        # 空行
        # 响应体
        response_body = f_data
        # 封装数据
        response = response_line + response_header + '\r\n' + response_body
        # 发送编码的数据
        new_socket.send(response.encode('utf-8'))
        new_socket.close()
    else:
        with open('wenjian' + request, 'rb') as f:
            f_data = f.read()
            # 响应行
            response_line = 'HTTP/2 200 OK\r\n'
            # 响应头
            response_header = 'Server PWS/2.0\r\n'
            # 空行
            # 响应体
            response_body = f_data
            # 封装数据
            response = (response_line + response_header + '\r\n').encode('utf-8') + response_body
            # 发送编码的数据
            new_socket.send(response)
            # 关闭客户端套接字
            new_socket.close()
def main():
    #创建服务端套接字对象
    tcp_server_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    #设置端口号复用
    tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
    #绑定端口号
    tcp_server_socket.bind(('',8000))
    #设置监听
    tcp_server_socket.listen(128)
    while True:
        #等待客户端连接请求
        new_socket,iport=tcp_server_socket.accept()
        #创建子线程
        sub_thread=threading.Thread(target=th_accept,args=(new_socket,),daemon=True)
        # 启动子线程
        sub_thread.start()
if __name__ == '__main__':
    main()

9.面向对象开发

  1. 步骤
    1. 把提供服务的web服务器抽象成一个类（HTTPWebServer）
    2. 提供Web服务器的初始化方法，在初始化方法里面创建socket对象
    3. 提供一个开启web服务器的方法，让Web服务器处理客户端请求
'''面向对象的'''
import socket,os,threading
#HTTPWebServer 列
class HttpWebServer(object):
    def __init__(self):
        #创建服务端套接字对象
        tcp_server_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        #设置端口号复用
        tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
        #绑定的端口号
        tcp_server_socket.bind(('',8000))
        #设置监听
        tcp_server_socket.listen(128)
        #把服务器的套接字作为web服务器对象的属性
        self.tcp_server_socket=tcp_server_socket
    @staticmethod
    def th_accept(new_socket):
        # 接收客户端传来的数据
        recv_data = new_socket.recv(4096)
        # 判断数据是否为空
        if len(recv_data) == 0:
            new_socket.close()
            return
        # 解码
        recv_d = recv_data.decode('utf-8')
        # 分割请求报文信息
        recv_li = recv_d.split(' ', 2)
        # 得到请求页名称
        request = recv_li[1]
        if request == '/':
            request = '/index.html'
        # 判断 请求页数据是否存在
        if not os.path.exists('wenjian' + request):
            with open('wenjian/error.html', encoding='utf-8') as f:
                f_data = f.read()
            # 响应行
            response_line = 'HTTP/2 404 Not Found\r\n'
            # 响应头
            response_header = 'Server PWS/2.0\r\n'
            # 空行
            # 响应体
            response_body = f_data
            # 封装数据
            response = response_line + response_header + '\r\n' + response_body
            # 发送编码的数据
            new_socket.send(response.encode('utf-8'))
            new_socket.close()
        else:
            with open('wenjian' + request, 'rb') as f:
                f_data = f.read()
                # 响应行
                response_line = 'HTTP/2 200 OK\r\n'
                # 响应头
                response_header = 'Server PWS/2.0\r\n'
                # 空行
                # 响应体
                response_body = f_data
                # 封装数据
                response = (response_line + response_header + '\r\n').encode('utf-8') + response_body
                # 发送编码的数据
                new_socket.send(response)
                # 关闭客户端套接字
                new_socket.close()

    #启动服务器
    def start(self):
        while True:
            # 等待客户端连接请求
            new_socket, iport = self.tcp_server_socket.accept()
            # 创建子线程
            sub_thread = threading.Thread(target=self.th_accept, args=(new_socket,), daemon=True)
            # 启动子线程
            sub_thread.start()
def main():
    #创建web 防御武器
    web_server=HttpWebServer()
    # 启动服务器
    web_server.start()
if __name__ == '__main__':
    main()

10.获取终端命令行参数及启动动态绑定端口号

使用sys模块
params=sys.argv
print(params) #是列表形式

  1. 步骤
    1. 获取执行python程序的终端命令行参数
    2. 判断参数的类型，设置端口号必须是整形
    3. 给web服务器类初始化方法添加一个动态端口号参数，用于绑定端口号
    4. linux 终端启动 用Python3
    5. windows 终端启动 用Python(在文件目录下)
import sys
import socket,os,threading
#HTTPWebServer 列
class HttpWebServer(object):
    def __init__(self,port):
        #创建服务端套接字对象
        tcp_server_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        #设置端口号复用
        tcp_server_socket.setsockopt(socket.SOL_SOCKET,socket.SO_REUSEADDR,True)
        #绑定的端口号
        tcp_server_socket.bind(('',port))
        #设置监听
        tcp_server_socket.listen(128)
        #把服务器的套接字作为web服务器对象的属性
        self.tcp_server_socket=tcp_server_socket
    @staticmethod
    def th_accept(new_socket):
        # 接收客户端传来的数据
        recv_data = new_socket.recv(4096)
        # 判断数据是否为空
        if len(recv_data) == 0:
            new_socket.close()
            return
        # 解码
        recv_d = recv_data.decode('utf-8')
        # 分割请求报文信息
        recv_li = recv_d.split(' ', 2)
        # 得到请求页名称
        request = recv_li[1]
        if request == '/':
            request = '/index.html'
        # 判断 请求页数据是否存在
        if not os.path.exists('wenjian' + request):
            with open('wenjian/error.html', encoding='utf-8') as f:
                f_data = f.read()
            # 响应行
            response_line = 'HTTP/2 404 Not Found\r\n'
            # 响应头
            response_header = 'Server PWS/2.0\r\n'
            # 空行
            # 响应体
            response_body = f_data
            # 封装数据
            response = response_line + response_header + '\r\n' + response_body
            # 发送编码的数据
            new_socket.send(response.encode('utf-8'))
            new_socket.close()
        else:
            with open('wenjian' + request, 'rb') as f:
                f_data = f.read()
                # 响应行
                response_line = 'HTTP/2 200 OK\r\n'
                # 响应头
                response_header = 'Server PWS/2.0\r\n'
                # 空行
                # 响应体
                response_body = f_data
                # 封装数据
                response = (response_line + response_header + '\r\n').encode('utf-8') + response_body
                # 发送编码的数据
                new_socket.send(response)
                # 关闭客户端套接字
                new_socket.close()

    #启动服务器
    def start(self):
        while True:
            # 等待客户端连接请求
            new_socket, iport = self.tcp_server_socket.accept()
            # 创建子线程
            sub_thread = threading.Thread(target=self.th_accept, args=(new_socket,), daemon=True)
            # 启动子线程
            sub_thread.start()
def main():
    #获取命令行参数
    params=sys.argv
    if len(params)!=2:#只能输入两个参数
        print('执行命令格式：python3 xxx.py 9000')
        return
    if not params[1].isdigit():#不是数字
        print('执行命令格式：python3 xxx.py 9000')
        return
    port=int(params[1])
    print(params)
    #创建web 防御武器
    web_server=HttpWebServer(port)
    # 启动服务器
    web_server.start()
if __name__ == '__main__':
    main()


  • 没有伤痕累累，哪有皮糟肉厚
风姿--惊鸿
关注
专栏目录
HTTP协议和静态Web服务器
R418520的博客
08-02 105
HTTP 协议 1. HTTP 协议的介绍 HTTP 协议的全称是(HyperText Transfer Protocol)，翻译过来就是超文本传输协议。 超文本是超级文本的缩写，是指超越文本限制或者超链接，比如:图片、音乐、视频、超链接等等都属于超文本。 HTTP 协议的制作者是蒂姆·伯纳斯-李，1991年设计出来的，HTTP 协议设计之前目的是传输网页数据的，现在允许传输任意类型的数据。 传输 HTTP 协议格式的数据是基于 TCP 传输协议的，发送数据之前需要先建立连接。 2. HTTP
基于HTTP协议实现的小型web服务器
热门推荐
YANG
04-28 3万+
我们先了解一下这个项目最终能达到的一个目标，然后以这个来进行项目的分析： 1、实现最基本的HTTP/1.0版本的web服务器，客户端能够使用GET、POST方法请求资源 2、服务器将客户请求的资源以html页面的形似呈现，并能够进行差错处理（如：客户请求的资源不存在时，服务器能够返回一个404的页面） 3、服务器能进行简单的cgi运行。比如当客户在表单中输入数据后，服务器能够将运行结果返回个
5-HTTP协议和静态web服务器
lzq812的博客
11-07 253
一、网址 ​ URL，统一资源定位符，俗称网络资源地址 URL组成 协议部分：http://，https://，ftp:// 域名部分：IP地址的别名，点分英文字母和数字组成 资源路径部分 查询参数部分：**？**后的数据，各个参数使用 & 连接 二、HTTP协议介绍 ​ 通过HTTP协议来规定浏览器和Web服务器传输的数据格式 层次结构 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4ExTez3s-1604711779921)(C:\Users\
HTTP长连接、短连接究竟是什么？
rs勿忘初心的博客
03-11 2355
详情请参考：https://www.cnblogs.com/gotodsp/p/6366163.html 1. HTTP协议与TCP/IP协议的关系 HTTP的长连接和短连接本质上是TCP长连接和短连接。HTTP属于应用层协议，在传输层使用TCP协议，在网络层使用IP协议。 IP协议主要解决网络路由和寻址问题，TCP协议主要解决如何在IP层之上可靠地传递数据包，使得网络上接收端收到发送端所发出...
web网页向cgi发送post请求并返回数据_Web服务器工作原理详解（基础篇）
weixin_39759107的博客
12-13 1518
概述：Web服务器概念较为广泛，我们最常说的Web服务器指的是网站服务器，它是建立在Internet之上并且驻留在某种计算机上的程序。Web服务器可以向Web客户端(如浏览器)提供文档或其他服务，只要是遵循HTTP协议而设计的网络应用程序都可以是Web客户端。 Web服务器和HTTP服务器可以说是同一个东西，当然非得细分的话，HTTP服务器是建立在HTTP协议之上的提供文档浏...
python实现静态web服务器
12-31
HTTP协议简介 HTTP请求 1：浏览器首先向服务器发送HTTP请求，请求包括： 方法：GET还是POST，GET仅请求资源，POST会附带用户数据； 路径：/full/url/path； 域名：由Host头指定：Host: www.sina.com以及其他相关的...
静态web服务器
03-16
在静态Web服务器的开发过程中，学习者可以通过分析和修改开源项目，如Tiny HTTPd或Civetweb，来加深对Web服务器工作原理的理解。此外，理解HTTP协议、熟悉Linux系统编程和C语言是入门的关键。 总的来说，静态Web...
机器学习算法-10-搭建python自带的静态web服务器.ev4.rar
04-20
在本资源中，主题聚焦于使用Python搭建一个简单的静态Web服务器。这主要涉及到以下几个关键知识点： 1. **Python基础知识**：Python是一种高级编程语言，以其简洁的语法和强大的功能而闻名。在本教程中，我们将使用...
miniweb服务器一键搭建静态网站
10-29
1. **Web服务器基础**：Web服务器是一种软件，负责接收HTTP（超文本传输协议）请求，并返回HTTP响应，通常包含网页内容。它们是互联网上网页服务的核心组成部分。 2. **静态网站与动态网站**：静态网站由预先编译好...
Web服务器踩坑之旅03:解析HTTP请求报文
weixin_45792310的博客
03-05 2762
项目地址： 本文实现的文件在源码中的SimpleWebServer/http_parser目录下 本文内容 目标：解析HTTP报文，从而获取客户请求的文件的文件名及文件地址 浏览器与服务器间的通信过程 URL与URI HTTP协议 HTTP请求报文 解析HTTP请求报文 浏览器与服务器间的通信过程 URL和URI URL：（Uniform Resource Locator）统一资源定位符 URI：（Uniform Resource Identifier）就是某个协议方案表示的资源的定位标识
HTTP学习与Web服务器编程
codes_first的博客
11-20 5187
这次的主题是查找HTTP协议的相关资料，基于此编写一个简单的Web服务器。 需要完成的几大主要的要求有： 1）编写一个简单的Web服务器； 2）实现的服务器应能与标准的浏览器进行简单的交互； 3）记录浏览器与服务的交互过程； 4）利用HTML语言编写网页浏览器可通过编写的Web服务器正常访问该网页； 5）支持多用户并发访问； 6）扩展编写的简单Web服务器，使浏览器能够浏览Web上存储
Web服务器之搭建返回固定页面的服务器
qq_52262831的博客
12-22 2572
编写一个TCP服务端程序 获取浏览器发送的http请求报文数据 读取固定页面数据，把页面数据组装成HTTP响应报文数据发送给浏览器 HTTP响应报文数据发送完成后，关闭服务于客户端的套接字
http协议和服务器互联,全网分析HTTP协议最全的一篇文章，程序员赶紧收藏-
weixin_40007515的博客
08-09 205
作者：涤生_Woo本篇文章篇幅比较长，先来个思维导图预览一下。一张图带你看完本篇文章一、概述1.计算机网络体系结构分层计算机网络体系结构分层2.TCP/IP 通信传输流利用 TCP/IP 协议族进行网络通信时，会通过分层顺序与对方进行通信。发送端从应用层往下走，接收端则从链路层往上走。如下：TCP/IP 通信传输流首先作为发送端的客户端在应用层(HTTP 协议)发出一个想看某个 Web 页面的 H...
node基础二（服务器）
LFLZBZM的博客
05-10 245
服务器端基础概念 一、网站的组成 网站应用程序主要分为两大部分：客户端和服务器端。 客户端：在浏览器中运行的部分，就是用户看到并与之交互的界面程序。使用HTML、 CSS、JavaScript构建。 服务器端：在服务器中运行的部分,负责存储数据和处理应用逻辑。 二、 Node网站服务器 能够提供网站访问服务的机器就是网站服务器，它能够接收客户端的请求，能够对请求做出响应。 IP地址：互联网协议地址 URL：统一资源定位符，又叫URL (Uniform Resource Locator)，是专为标识Inter
WinHttp异步实现GET, POST, 多线程下载文件
FlameCyclone的博客
09-29 426
基于WinHttp封装, 实现异步多线程文件下载, GET请求, POST请求
HTTP 和 HTTPS 协议的区别？
智通全网络工作室的博客
09-27 1211
HTTP 是一种无状态的、基于请求/响应模型的应用层协议，旨在用于分布式、协作和超媒体信息系统。最常见的用途是查看网页。HTTP 协议在 TCP/IP 上运行，其标准端口是 80。了解 HTTP 和 HTTPS 之间的区别至关重要。HTTPS 是保护用户信息和提升网站信任度的关键因素。在一个安全意识增强的时代，确保你的网站使用 HTTPS 不仅是一个负责任的做法，也是赢得用户信任的基石。希望这篇博客能帮助你更好地理解这两种协议的区别及其重要性。
java8:hutool：httputil.post读取配置项中的url
hongyuxiongji的博客
09-28 506
不过这种方式有潜在的问题，因为在Spring容器初始化Bean的时候构造函数会被调用，但是如果@Value注入还没完成（例如配置文件加载延迟等情况），可能会导致staticUrl的值为null。如果HttpUtil.post是静态方法，无法直接访问非静态的@Value注入的属性。1. 首先将配置项的值通过@Value注入到类的成员变量，然后在构造函数中将这个值传递给一个静态变量。这种方式更符合Spring的依赖注入原则，而且可以确保在需要使用配置值的时候能够正确获取到。通过一个工具类方法获取配置值。
windows C++-使用任务和 XML HTTP 请求进行连接(一)
最新发布
苏洛的博客
10-02 567
当您使用 IXMLHTTPRequest2 接口通过 HTTP 创建 Web 请求时，可以实现 IXMLHTTPRequest2Callback 接口来接收服务器响应并对其他事件做出响应。此示例定义了 HttpRequest 类来创建 Web 请求，并定义了 HttpRequestBuffersCallback 和 HttpRequestStringCallback 类来处理响应。
Java实现简单Web服务器及HTTP协议解析
在本文中，我们将深入探讨一个简单的Web服务器的设计与实现，该服务器是作为课程设计的一部分，旨在理解和实践计算机网络中的Web服务器工作原理。Web服务器的核心在于处理HTTP协议，这是一种应用层协议，用于在Web...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值