Socket网络编程-TCP编程
作者：尹正杰
版权声明：原创作品，谢绝转载！否则将追究法律责任。
一.socket介绍
1>.TCP/IP协议
2>.跨网络的主机间通讯
在建立通信连接的每一端，进程间的传输要有两个标志：
IP地址和端口号，合称为套接字地址 socket address
客户机套接字地址定义了一个唯一的客户进程
服务器套接字地址定义了一个唯一的服务器进程
3>.什么是socket套接字
套接字（socket）是一个抽象层，应用程序可以通过它发送或接收数据，可对其进行像对文件一样的打开、读写和关闭等操作。套接字允许应用程序将I/O插入到网络中，并与网络中的其他应用程序进行通信。网络套接字是IP地址与端口的组合。 Socket:套接字，进程间通信IPC的一种实现，允许位于不同主机（或同一主机）上不同进程之间进行通信和数据交换，SocketAPI出现于1983年，4.2 BSD实现。 Socket API：封装了内核中所提供的socket通信相关的系统调用。 Python中提供了socket标准库，非常底层的接口库。
4>.协议族(Socket Domain)
AF表示Address Family，用于socket()第一个参数
AF_INET:
对应IPV4
AF_INET6
对应IPV6
AF_UNIX
同一主机不同进程之间通信时使用，对应Unix Domain Socket，windows没有。
5>.socket Type(根据使用的传输层协议)
SOCK_STREAM
可靠的传递，面向连接的流套接字。默认值，TCP协议。
SOCK_DGRAM
不可靠的传递，无连接的数据报文套接字。UDP协议。
SOCK_RAW:
裸套接字,无须tcp或udp,APP直接通过IP包通信
6>.C/S编程
Socket编程，需要两端，一般来说需要一个服务端、一个客户端，服务端称为Server，客户端称为Client。 这种编程模式也称为C/S编程。 套接字相关的系统调用：
socket(): 创建一个套接字
bind()： 绑定IP和端口
listen()： 监听
accept()： 接收请求
connect()： 请求连接建立
write()： 发送
read()： 接收
close(): 关闭连接
7>.python中的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)
python 3.5版本开始，发送一个文件直到EOF，使用高性能的os.sendfile机制，返回发送的字节数。如果win下不支持sendfile， 或者不是普通文件，使用send()发送文件。offset告诉 起始位置。 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)
设置套接字选项的值。比如缓冲区大小。太多了，去看文档。不同系统，不同版本都不尽相同 socket.makefile(mode='r', buffering=None, *, encoding=None, errors=None, newline=None)
创建一个与该套接字相关连的文件对象，将recv方法看做读方法，将send方法看做写方法。
二.TCP服务端编程
1>.服务器端编程步骤
创建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)发送数据 Server端开发
socket对象 --> bind((IP, PORT)) --> listen --> accept --> close
|--> recv or send --> close
2>.实战案例写一个群聊程序的服务端ChatServer
#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie import logging
import socket
import threading
import datetime logging.basicConfig(level=logging.INFO, format="%(asctime)s %(thread)d %(message)s") """
注意，这个代码为实验用，代码中瑕疵还有很多。Socket太底层了，实际开发中很少使用这么底层的接 口。
"""
class ChatServer:
def __init__(self,ip="127.0.0.1",port=6666):
self.conn = socket.socket() #创建socket对象
self.addr = (ip,port)
self.clients = {} #存放客户端连接容器
self.event = threading.Event() #判断服务是否启动
self.lock = threading.Lock() #为了线程安全而引入的 def start(self): #启动服务,会监听IP地址和端口哟～
self.conn.bind(self.addr) #将IP地址和端口绑定到套接字上
self.conn.listen() #监听绑定的套接字 #accept会阻塞主线程，所以开一个新线程
threading.Thread(target=self.accept).start() def accept(self): #处理客户端的链接
while not self.event.is_set():
conn,client = self.conn.accept() #该方法默认会进入阻塞状态
f = conn.makefile("rw") #将socket封装成一个文件对象来操作，支持读写
with self.lock:
self.clients[client] = f,conn #如果有新链接就添加到客户端字典 #准备接收数据，recv是阻塞的，开启新的线程
threading.Thread(target=self.recv,args=(f,client)).start() def recv(self,f,client): #处理客户端数据
print("in recv")
while not self.event.is_set():
try:
data = f.readline()
print(data)
except Exception as e:
logging.error(e)
data = "quit" msg = data.strip()
print(msg, "++++++++++++++++++") #和客户端约定退出命令
if msg == "quit" or msg == "": #主动端口得到空串
with self.lock:
_,conn = self.clients.pop(client)
f.close()
conn.close()
logging.info("{} quit ...".format(client))
break msg = "{:%Y/%m/%d %H:%M:%S} ip:port => {}:{}\n data => {}\n".format(datetime.datetime.now(),*client, data)
logging.info(msg) with self.lock:
for f1,_ in self.clients.values():
f1.write(msg)
f1.flush() def stop(self): #停止服务
self.event.set()
with self.lock:
for f,s in self.clients.values():
f.close()
s.close()
self.conn.close() def main():
server = ChatServer()
server.start() while True:
cmd = input(">>> ").strip()
if cmd == "quit":
server.stop()
threading.Event.wait(3) #关闭服务需要等待时间
break
logging.info(threading.enumerate()) #用来观察断开后线程的变化
logging.info(server.clients) if __name__ == '__main__':
main()
三.TCP客户端编程
1>.客户端编程步骤
创建Socket对象 连接到远端服务端的ip和port，connect()方法 传输数据
使用send、recv方法发送、接收数据 关闭连接，释放资源
2>.实战案例写一个群聊程序的客户端ChatClient
#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie import socket
import threading
import datetime
import logging FORMAT = "%(asctime)s %(threadName)s %(thread)d %(message)s"
logging.basicConfig(format=FORMAT, level=logging.INFO) """
同样，这样的客户端还是有些问题的，仅用于测试。
"""
class ChatClient:
def __init__(self, ip='127.0.0.1', port=6666):
self.sock = socket.socket()
self.addr = (ip, port)
self.event = threading.Event() def start(self): # 启动对远端服务器的连接
self.sock.connect(self.addr)
self.send("I'm ready.")
# 准备接收数据，recv是阻塞的，开启新的线程
threading.Thread(target=self.recv, name="recv").start() def recv(self): # 接收服务端的数据
while not self.event.is_set():
try:
data = self.sock.recv(1024) # 阻塞
except Exception as e:
logging.error(e)
break msg = "{:%Y/%m/%d %H:%M:%S} ip:port => {}:{}\n data => {}\n".format(datetime.datetime.now(),*self.addr, data.strip())
logging.info(msg) def send(self, msg:str):
data = "{}\n".format(msg.strip()).encode() # 服务端需要一个换行符
self.sock.send(data) def stop(self):
self.sock.close()
self.event.wait(3)
self.event.set()
logging.info('Client stops...') def main():
client = ChatClient()
client.start()
while True:
cmd = input('>>>')
if cmd.strip() == 'quit':
client.stop()
break
client.send(cmd) # 发送消息 if __name__ == '__main__':
main()