chapter12.1、socket编程，tcp实现通讯

网络编程

Socket编程

socket套接字

端到端编程，建立了一条数据传输的通道

网络编程的基础，所有的操作系统都支持socket

socket是一种通用的网路编程接口，不需要关心协议层，只是打通了一条通道，和网络层次没有一一对应关系。

IPC，RPC，最底层也是socket实现

协议族

名称	含义
AF_INET	IPV4
AF_INET6	IPV6
AF_UNIX	Unix Domain Socket，windows没有

 

 

 

 

socket 类型

名称	含义
SOCK_STREAM	面向连接的流套接字，默认值，TCP协议
SOCK_DGRAM	无连接的数据报文套接字，UDP协议，效率高，易产生乱序，丢包问题

 

 

 

 

 

TCP编程

服务端server，客户端client，cs编程，

服务器编程步骤

1、创建Socket对象

2、绑定IP地址和端口，IP负责地址，端口管应用程序

端口是进程的，不是线程的，只是线程共享进程的资源

3、监听，暴露端口，将指定的IP端口开始监听

4、socket accept 获取传送数据的socket对象

用于阻塞等待客户端建立连接，返回一个新的socket对象和客户端地址的二元组

地址是远程客户端地址，IPv4中是一个二元组（clientaddr，port）

• recv(bufsize[,flags])  使用缓冲区接收数据

• send(bytes)  发送数据

注意：两次绑定同一个端口会报错，操作系统级别的错误

Windows报错：  通常每个套接字地址(协议/网络地址/端口)只允许使用一次。

#1 socket
sevrer = socket.socket()

#2 bind
ip = '127.0.0.1'
port = 9999
addr = (ip,port)
server.bind(addr)

#3 listen
server.listen()

#4 accept
s1, info = server.accept()  #阻塞等待client连接

#5 recv,send
data = server.recv(1024)
s1.send("hello, I'm server")

#6 close
server.close()

netstat Windows使用 b 显示进程，要用管理员权限 windows下

ss -tanl l表示监听，t tcp协议，a全部，n数字显示端口 Linux下

windows下的管道也可以使用，findstr是过滤方法

群聊程序TCP协议服务器端简单实现

TCPChatserver

import socket
import threading
import logging

FORMAT = "%(thread)d %(threadName)s %(asctime)s %(message)s"
logging.basicConfig(format=FORMAT,level=logging.INFO)

class ChatServer:
    def __init__(self,ip="127.0.0.1",port=9999):
        self.sock = socket.socket()
        self.addr = (ip,port)
        self.clients = {}
        self.event = threading.Event()

    def start(self):#开始监听
        self.sock.bind(self.addr)
        self.sock.listen()
        #accept会阻塞主线程，开线程跑
        threading.Thread(target=self.accept,name="accept").start()

    def accept(self):#多人连接
        while not self.event.is_set():
            try:
                sock,raddr = self.sock.accept()#阻塞等待
            except Exception:
                self.stop()
                break
            self.clients[raddr] = sock#记录客户端
            logging.info(raddr)
            #开启新线程，一个新的socket对象处理单个client
            threading.Thread(target=self.recv,args=(sock,raddr),name="r-{}".format(raddr)).start()


    def recv(self,sock,raddr):#接受数据
        while not self.event.is_set():
            try:
                data = sock.recv(1024).strip()#阻塞等待
            except Exception:
                break
            logging.info(":{}".format(data.decode()))
            #client退出机制
            if data.strip() == b"quit" or data ==b"":
                print(data,"~~~~~~~~~~")
                self.clients.pop(raddr)
                sock.close()
                break

            msg = "{}".format(data)
            msg = msg.encode()
            for client in self.clients.values():
                client.sendall(msg)

    def stop(self):#停止服务
        for c in self.clients.values():
            c.close()
        self.sock.close()
        self.event.set()

def main():
    server = ChatServer()
    server.start()

    while True:
        cmd = input(">>>")
        if cmd == "quit":
            server.stop()
            threading.Event().wait(3)
            break
        logging.info(threading.enumerate())#观察线程变化

if __name__ == '__main__':
    main()

只是实现主要功能，且现在不用该方法了

socket 方法

 

名称	含义
socket.recv(bufsize[, flags])	获取数据。默认是阻塞的方式
socket.recvfrom(bufsize[, flags])	获取数据，返回一个二元组(bytes, address)
socket.recv_into(buffer[, nbytes[,flags]])	获取到nbytes的数据后，存储到buffer中。如果nbytes没有指定或0，将buffer大小的数据存入buffer中。返回接收的字节数。
socket.recvfrom_into(buffer[,nbytes[, flags]])	获取数据，返回一个二元组(bytes, address)到buffer中
socket.send(bytes[, flags])	TCP发送数据
socket.sendall(bytes[, flags])	TCP发送全部数据，成功返回None
socket.sendto(string[,flag],address)	UDP发送数据
socket.sendfile(file, offset=0,count=None)	发送一个文件直到EOF，使用高性能的os.sendfile机制，返回发送的字节数。如果win下不支持sendfile，或者不是普通文件，使用send()发送文件。offset告诉起始位置。3.5版本开始
socket.getpeername()	返回连接套接字的远程地址。返回值通常是元组(ipaddr,port)
socket.getsockname()	返回套接字自己的地址。通常是一个元组(ipaddr,port)
socket.setblocking(flag)	如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值)非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常
socket.settimeout(value)	设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()）
socket.setsockopt(level,optname,value)	设置套接字选项的值。比如缓冲区大小。太多了，去看文档。不同系统，不同版本都不尽相同

 

 

makefile方法

类文件对象socket会占文件描述符，不用要归还

import socket
import threading
import logging

FORMAT = "%(asctime)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT,level=logging.INFO)

class ChatTCPServer:
    def __init__(self,ip="127.0.0.1",port=9999):
        self.sock = socket.socket()
        self.addr = ip,port
        self.event = threading.Event()
        self.clients = {}

    def start(self):
        self.sock.bind(self.addr)
        self.sock.listen()
        threading.Thread(target=self.accept,name="accept").start()

    def accept(self):
        while not self.event.is_set():
            try:
                s, client = self.sock.accept()
                f = s.makefile("rw")
            except:
                self.stop()
                break
            self.clients[client] = f

            threading.Thread(target=self.recv,args=(f, client,s),name="client-{}".format(client[1])).start()
            logging.info("{} login".format(client))

    def recv(self,f,raddr,s):

        while not self.event.is_set():
            try:
                msg = f.readline().strip()
            except Exception as e:
                logging.error(e)
                self.clients.pop(raddr)
                f.close()
                break
            logging.info(msg)
            if msg == "quit" or "":
                self.clients.pop(raddr)
                f.close()
                break

            for f1 in self.clients.values():
                f1.write(msg)
                f1.flush()

    def stop(self):
        for client in self.clients.values():
            client.close()
        self.sock.close()
        self.event.set()


def main():
    server = ChatTCPServer()
    server.start()
    while True:
        cmd = input(">>>")
        if cmd =="quit":
            server.stop()
            threading.Event().wait(3)
            break
        logging.info(threading.enumerate())

if __name__ == '__main__':
    main()

 client 客户端实现

 创建socket对象

连接到远程服务端的ip，port，connect方法

传输数据

使用send，recv方法接受，发送数据

 关闭连接，释放资源

import socket
import threading
import logging
import datetime

logging.basicConfig(format="%(asctime)s %(thread)s %(message)s",level=logging.INFO)

class ChatTcpClient:
    def __init__(self,ip="127.0.0.1",port=9999):
        self.sock = socket.socket()
        self.event = threading.Event()
        self.raddr = ip,port

    def start(self):
        self.sock.connect(self.raddr)
        self.sock.send(b"I'm ready")
        threading.Thread(target=self.recv,name='recv').start()

    def recv(self):
        while not self.event.is_set():
            try:
                data = self.sock.recv(1024).decode()
            except Exception as e:
                logging.info(e)
                break
            msg = "{:%Y%m%d %H:%M:%S} {}:{}
{}".format(datetime.datetime.now(),*self.raddr,data.strip())
            logging.info(msg)

    def send(self,msg:str):
        data = "{}
".format(msg.strip()).encode()
        self.sock.send(data)

    def stop(self):
        self.sock.close()
        self.event.wait(3)
        self.event.set()
        logging.info("Client stop")

def main():
    cc = ChatTcpClient()
    cc.start()
    while True:
        cmd = input(">>>")
        if cmd == "quit" or "":
            cc.stop()
            break
        cc.send(cmd)

if __name__ == '__main__':
    main()