Python-TCP编程

1、Socket介绍：

　　socket 套接字

　　Python中提供socket.py标准库，非常底层的接口库。

　　Socket 是一种通用的网络编程接口，和网络底层没有一一对应的关系

　　协议族：

　　　　AF：address family， 用于socket（）第一个参数

　　

　　Socket 类型

　　

2、TCP编程：

　　Socket编程，需要两端，一般来说，需要一个服务器端，一个客户端，服务器端为server，客户端为client

2.1、TCP服务器端编程：

　　服务器端编程步骤：

• • 创建Socket对象
  • 绑定IP 地址 address， 和端口 port，bind() 方法，IPv4地址为一个二元组（‘IP地址字符串’，port）
  • 开始监听，将在指定的ip 端口上监听，listen()方法
  • 获取用于传递数据的socket 对象

　　　　　　socket.accept() ---> (socket.object, address info)

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

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

• • • • 接受数据：recv（ bufsize [, flags]）使用了缓冲区接受数据
      • 发送数据：send(bytes）发送数据

　　

　　　只有一个client 请求的 样例：　　　　　

import socket

# 1、创建套接字
socket = socket.socket()

# 2、绑定ip 和 port
ip = '127.0.0.1'
port = 9999
laddr = (ip, port)

socket.bind(laddr)

# 3、监听 套接字
socket.listen()

# 4、等待接受 客户端数据,并生产新的socket，用于数据交互
data = socket.accept()
newsocket, raddr = data

# 5、接受数据

msg = newsocket.recv() # 收到的是字节类型

# 6、发送数据
newsocket.send(msg) # 发送也得是字节类型

# 7、当前socket 通信结束，可以关闭
newsocket.close()

# 8、关闭资源 ,这里关闭的是 创建连接时的 socket
socket.close()

　　newsocket：　　

<socket.socket fd=212, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9999), raddr=('127.0.0.1', 50287)>

　　raddr：远程套接字　　

('127.0.0.1', 50287)　　

　　recv（1024）：缓冲区大小一般是1024 的整数倍

　　socket.accept()：阻塞直到 和客户端 成功建立连接，返回一个socket对象和客户端地址。

　　newsocket.recv(1024)：连接成功后，没有收到数据，会阻塞在这里。

　　　　注：　　　　

　　　　　　TCP的服务端编程：
   　　　　　　　　 端口是给进程的，线程共享资源。
    　　　　　　　　通过监听来获得端口，对端口进行暴露 ，同时监听
   　　　　　　　　 一个socket 是为了连接，创建新的socket进行资源通信
　　

　　win cmd:
    　　netstat -anp tcp | findstr 9999 (win的管道）
        　　-b:显示进程
　　Linux：
　　　　　一般使用ss

　　测试：
　　　　1、服务器端，主线程是用来做其他工作，所以，不能让accept占据主线程，处于阻塞状态
　　　　2、每个客户端应该都在自己的线程中工作，否则会recv阻塞，影响别人
　　　　3、为了方便的将信息通知给所有的客户端，所以某个人发出的信息，必须都发给其他人一份，所以这里通过字典，将所有newsocket收集起来
　　　　4、提供退出机制，因为使用 sindows上的调试工具，直接退出，会返回一个 b'',所以这里使用 b'quit' 或 b''退出客户端
　　　　5、主线程（server），关闭的时候，线程也依次结束，避免占用资源。
　　　　6、可以提供日志功能，将日志输出到文件
　　

import socket
import logging
import threading

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

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

    def start(self):
        self.socket.bind(self.laddr)
        self.socket.listen()
        threading.Thread(target=self.accept, name='accept').start()

    def accept(self):
        while not self.event.is_set():
            newsocket, raddr = self.socket.accept()
            self.clients[raddr] = newsocket
            threading.Thread(target=self.recv,args=(newsocket, raddr)).start()

    def recv(self, s, raddr):
        while not self.event.is_set():
            data = s.recv(1024)
            logging.info(data)

            if data.strip() == b'quit' or data == b'':
                self.clients.pop(raddr)
                s.close()
                break
            for s in self.clients.values():
                logging.info(data)
                msg = 'msgs is that  {}'.format(data.decode())
                s.send(msg.encode())


    def stop(self):
        for s in self.clients.values():
            s.close()
        self.socket.close()
        self.event.set()


cs = ChatServer()
cs.start()

while True:
    cmd = input('>>')
    if cmd.strip() == 'quit':
        cs.stop()
        break
    logging.info(threading.enumerate())

　　socket常用方法：

　　　

2.2、MakeFile：

　　socket.makefile(mode='r', buffering=None, * , encoding=None, error=None, newline=None)

　　创建一个与该套接子相关联的文件对象，将recv 方法看做读方法，将send 方法看做是写方法。

　　测试：显示读和写

import socket
sock = socket.socket()

ip = '127.0.0.1'
port = 9999

addr = (ip, port)

sock.bind(addr)
sock.listen()


s, _ = sock.accept()
print(s)

# 这儿权限只能 r w a 不能 出现 +
# 创建一个 类文件对象
f = s.makefile(mode='rw')

line = f.read(10) # recv
print(line )

f.write(' -----{}-----'.format(line))
f.flush()# 写完之后 flush一下

import socket
sock = socket.socket()

ip = '127.0.0.1'
port = 9999

addr = (ip, port)

sock.bind(addr)
sock.listen()


s, _ = sock.accept()
print(s)

# 这儿权限只能 r w a 不能 出现 +
# 创建一个 类文件对象
f = s.makefile(mode='rw')

line = f.readline(10) # recv
print(line )

f.write(' -----{}-----'.format(line))
f.flush()# 写完之后 flush一下

　　　readline 是遇到回车换行才 输出，read 是 够了字符数，输出　

　　s   :    <socket.socket fd=212, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9999), raddr=('127.0.0.1', 52129)>
　　f   :     <_io.TextIOWrapper mode='rw' encoding='cp936'>

　　测试：将群聊服务器端 改为makefile

import socket
import logging
import threading

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

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

    def start(self):
        self.socket.bind(self.laddr)
        self.socket.listen()
        threading.Thread(target=self.accept, name='accept').start()

    def accept(self):
        while not self.event.is_set():
            newsocket, raddr = self.socket.accept()

            f  = newsocket.makefile('rw')

            self.clients[raddr] = f
            threading.Thread(target=self.recv,args=(newsocket, f, raddr)).start()

    def recv(self, s,f, raddr):
        while not self.event.is_set():
            data = f.readline(10)
            logging.info(data)

            if data.strip() == 'quit' or data == b'':
                self.clients.pop(raddr)
                f.close() # 只关文件描述符，可能完全断不开，所以把socket也关一下
                s.close()
                break
            for f in self.clients.values():
                logging.info(data)
                f.write(data)
                f.flush()


    def stop(self):
        for s in self.clients.values():
            s.close()
        self.socket.close()
        self.event.set()


cs = ChatServer()
cs.start()

while True:
    cmd = input('>>')
    if cmd.strip() == 'quit':
        cs.stop()
        break
    logging.info(threading.enumerate())

2.2、TCP客户端编程

　　客户端编程步骤：

• • 创建socket对象
  • 连接到远程服务端的IP 和port ，connect()方法
  • 传输数据
    • 使用send， recv方法，发送数据，接受数据

　　　　关闭连接，释放资源

　　

2.3、一个群聊程序：注意：群聊，所以，不发信息，也能recv信息，所以recv放到一个线程中，一直执行

　　服务器端程序：　　

import socket
import logging
import threading

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

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

    def start(self):
        self.socket.bind(self.laddr)
        self.socket.listen()
        threading.Thread(target=self.accept, name='accept').start()

    def accept(self):
        while not self.event.is_set():
            newsocket, raddr = self.socket.accept()

            f  = newsocket.makefile('rw')

            self.clients[raddr] = f
            threading.Thread(target=self.recv,args=(newsocket, f, raddr)).start()

    def recv(self, s,f, raddr):
        while not self.event.is_set():
            data = f.readline(10)
            logging.info(data)

            if data.strip() == 'quit' or data == b'':
                self.clients.pop(raddr)
                f.close() # 只关文件描述符，可能完全断不开，所以把socket也关一下
                # s.close()
                break
            for f in self.clients.values():
                logging.info(data)
                f.write(data)
                f.flush()


    def stop(self):
        for s in self.clients.values():
            s.close()
        self.socket.close()
        self.event.set()


cs = ChatServer()
cs.start()

while True:
    cmd = input('>>')
    if cmd.strip() == 'quit':
        cs.stop()
        break
    logging.info(threading.enumerate())

　　客户端程序：

import socket
import threading

class ChatClient:
    def __init__(self, ip='127.0.0.1', port=9999):
        self.socket = socket.socket()
        self.event = threading.Event()
        self.raddr = (ip, port)

    def start(self):
        self.socket.connect(self.raddr)

        self.send('hello I am client')
        # while not self.event.is_set():
            # data = self.socket.recv(1024)
            # print(data)
        threading.Thread(target=self.recv).start()

    def send(self, msg):
        self.socket.send(msg.encode())

    def recv(self):
        while not self.event.is_set():
            data = self.socket.recv(1024)
            print(data)

    def stop(self):
        self.socket.close()
        self.event.set()

cc = ChatClient()
cc.start()

while True:
    cmd = input('>>')
    if cmd.strip() == 'quit':
        cc.stop()
        break
    cc.send(cmd)

　　server:

　　client 1

　　client 2: