TCP

6. [难点]socket介绍

概念：套接字
作用：进程之间网络传输的工具
使用场景：所有网络程序

7.[重点]TCP网络应用程序开发流程

客户端开发的流程：

1.创建socket对象
2.和服务器端socket建立连接 (connect)
3.发送数据
4.接收数据
5.关闭连接

服务端开发的流程：

1.创建socket对象
2.绑定端口
3.设置监听
4.等待客户端连接
5.接收数据
6.发送数据
7.关闭连接

8.[重点]TCP客户端程序开发

客户端开发

"""
1.创建socket对象
2.建立链接
3.发送数据
4.接收数据
5.关闭链接
"""

import socket


if __name__ == '__main__':

    # 1.创建socket对象
    #   AF_INET: ipv4地址类型
    #   SOCK_STREAM: tcp传输协议
    tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 2.与服务器socket建立链接
    #   connect(元组)
    #       元组： （服务器ip地址，端口号）
    tcp_client_socket.connect(("127.0.0.1", 8080))

    # 3.发送数据
    # utf-8: 字符编号，ubuntu的网络调试助手接收数据时的编码方式就是utf-8
    # gbk:字符编号，windows的网络调试助手接收数据时的编码方式就是gbk

    send_str = "你好"
    # 字符串.encode("编码方式") : 字符串转换成二进制
    send_bytes = send_str.encode("utf-8")

    tcp_client_socket.send(send_bytes)

    # 4.接收数据
    #   1024：一次接收到的数据最大大小
    recv_data = tcp_client_socket.recv(1024)
    # 二进制数据.decode("编码方式") : 二进制转化成字符串
    print("接收到来自服务端发送的数据: ", recv_data.decode("utf-8"))

    # 5.关闭socket（关闭链接）
    tcp_client_socket.close()

9.[难点]TCP服务端程序开发

服务端开发

"""
1.创建socket对象
2.绑定端口 (bind)
3.设置监听模式 (listen)
4.等待客户端链接 (accept)
    -> 返回新的socket对象服务客户端, 客户端的地址
5.接收数据
6.发送数据
7.关闭链接 (有两个socket需要关闭)
    --> 新的socket.close() 这次通讯接收 + 服务器socket.close() 不允许新的链接
"""
# 0.导入模块
import socket

if __name__ == '__main__':
    # 1.创建服务器socket
    #   AF_INET: ipv4地址类型
    #   SOCK_STREAM:tcp协议
    tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

    # 设置端口复用：关闭socket时立刻释放端口，无需等待1~2分钟。不是表示一个端口可以给多个程序使用
    #   参数1：设置当前socket
    #   参数2：设置端口复用选项
    #   参数3：设置端口复用选项的值（True表示开启端口复用）
    tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, True)

    # 2.绑定端口
    #   bind(元组)
    #   元组格式: (本地ip，端口号)
    tcp_server_socket.bind(("", 8080))

    # 3.设置监听模式
    #   listen:
    #       1) 设置当前tcp_server_socket为被动链接的socket，这个socket不能收发消息
    #       2) 128 允许最大等待链接的个数(推荐)
    tcp_server_socket.listen(128)

    # 4.等待客户端链接，如果有客户端链接，返回新的socket服务客户端，返回客户端的ip和端口
    #   accept: 返回一个元组类型 (新的服务器客户端的socket, 客户端的ip和端口信息)
    new_socket, ip_port = tcp_server_socket.accept()
    print("客户端链接: ", ip_port)

    # 5.接收数据
    #   1024: 这次recv接收的最大字节个数
    recv_data = new_socket.recv(1024)
    print("接收到客户端发送的数据: ", recv_data.decode("utf-8"))

    # 6.发送数据
    new_socket.send("9527为您服务....".encode("utf-8"))

    # 7.关闭新的socket，关闭服务器socket
    new_socket.close()

    tcp_server_socket.close()

10.[重点]TCP网络应用程序注意点的介绍

1.当 TCP 客户端程序想要和 TCP 服务端程序进行通信的时候必须要先建立连接
2.TCP 客户端程序一般不需要绑定端口号，因为客户端是主动发起建立连接的。
3.TCP 服务端程序必须绑定端口号，否则客户端找不到这个 TCP 服务端程序。
4.listen 后的套接字是被动套接字，只负责接收新的客户端的连接请求，不能收发消息。
5.当 TCP 客户端程序和 TCP 服务端程序连接成功后， TCP 服务器端程序会产生一个新的套接字，收发客户端消息使用该套接字。
6.关闭 accept 返回的套接字意味着和这个客户端已经通信完毕。
7.关闭 listen 后的套接字意味着服务端的套接字关闭了，会导致新的客户端不能连接服务端，但是之前已经接成功的客户端还能正常通信。
8.当客户端的套接字调用 close 后，服务器端的 recv 会解阻塞，返回的数据长度为0，服务端可以通过返回数据的长度来判断客户端是否已经下线，反之服务端关闭套接字，客户端的 recv 也会解阻塞，返回的数据长度也为0。

11.[重点]案例-多任务版TCP服务端程序开发

需求：

目前我们开发的TCP服务端程序只能服务于一个客户端，如何开发一个多任务版的TCP服务端程序能够服务于多个客户端呢?

具体实现步骤：

1.编写一个TCP服务端程序，循环等待接受客户端的连接请求
2.当客户端和服务端建立连接成功，创建子线程，使用子线程专门处理客户端的请求，防止主线程阻塞
3.把创建的子线程设置成为守护主线程，防止主线程无法退出。


    # 1.编写一个TCP服务端程序，循环等待接受客户端的连接请求
    while True:
        new_socket, client_ip_port = tcp_server_socket.accept()
        print("有客户端链接： ", client_ip_port)

        # 2.当客户端和服务端建立连接成功，创建子线程，使用子线程专门处理客户端的请求，防止主线程阻塞
        sub_thread = threading.Thread(target=handler_client, args=(new_socket, client_ip_port))

        # 3.把创建的子线程设置成为守护主线程，防止主线程无法退出。
        sub_thread.setDaemon(True)

        sub_thread.start()

12.[难点]socket之send和recv原理剖析

Send 原理

send() -> 发送缓冲区 -> 网卡->网卡 -> 接收缓冲区 -> recv()

Recv 原理

recv() <- 接收缓冲区 <- 网卡<-网卡 <- 发送缓冲区 <- send()