python網絡編程-socket編程

時間 2019-12-08

標籤 python 網絡編程 socket 欄目 Python 简体版

原文原文鏈接

1、服務端和客戶端html

BS架構（騰訊通軟件：server+client）python

CS架構（web網站）linux

C/S架構與socket的關係：web

咱們學習socket就是爲了完成C/S架構的開發算法

2、OSI七層模型shell

互聯網協議按照功能不一樣分爲osi七層或tcp/ip五層或tcp/ip四層編程

每層運行常見物理設備windows

詳細參考：設計模式

http://www.cnblogs.com/linhaifeng/articles/5937962.html#_label4緩存

學習socket必定要先學習互聯網協議：

1.首先：本節課程的目標就是教會你如何基於socket編程，來開發一款本身的C/S架構軟件

2.其次：C/S架構的軟件（軟件屬於應用層）是基於網絡進行通訊的

3.而後：網絡的核心即一堆協議，協議即標準，你想開發一款基於網絡通訊的軟件，就必須遵循這些標準。

4.最後：就讓咱們從這些標準開始研究，開啓咱們的socket編程之旅

TCP/IP協議族包括運輸層、網絡層、鏈路層。

3、socket層，不懂看圖就明白了。

Socket是介於應用層和傳輸層之間。

4、socket是什麼

　　Socket是應用層與TCP/IP協議族通訊的中間軟件抽象層，它是一組接口。在設計模式中，Socket其實就是一個門面模式，它把複雜的TCP/IP協議族隱藏在Socket接口後面，對用戶來講，一組簡單的接口就是所有，讓Socket去組織數據，以符合指定的協議。

因此，咱們無需深刻理解tcp/udp協議，socket已經爲咱們封裝好了，咱們只須要遵循socket的規定去編程，寫出的程序天然就是遵循tcp/udp標準的。

掃盲篇：

1 將socket說成ip+port，ip是用來標識互聯網中的一臺主機的位置，而port是用來標識這臺機器上的一個應用程序，ip地址是配置到網卡上的，而port是應用程序開啓的，ip與port的綁定就標識了互聯網中獨一無二的一個應用程序
2 
3 而程序的pid是同一臺機器上不一樣進程或者線程的標識（Google Chrome會有多個PID）

5、套接字發展史及分類

套接字起源於 20 世紀 70 年代加利福尼亞大學伯克利分校版本的 Unix,即人們所說的 BSD Unix。所以,有時人們也把套接字稱爲「伯克利套接字」或「BSD 套接字」。一開始,套接字被設計用在同一臺主機上多個應用程序之間的通信。這也被稱進程間通信,或 IPC。套接字有兩種（或者稱爲有兩個種族）,分別是基於文件型的和基於網絡型的。

一、基於文件類型的套接字家族

套接字家族的名字：AF_UNIX

unix一切皆文件，基於文件的套接字調用的就是底層的文件系統來取數據，兩個套接字進程運行在同一機器，能夠經過訪問同一個文件系統間接完成通訊

二、基於網絡類型的套接字家族

套接字家族的名字：AF_INET

(還有AF_INET6被用於ipv6，還有一些其餘的地址家族，不過，他們要麼是隻用於某個平臺，要麼就是已經被廢棄，或者是不多被使用，或者是根本沒有實現，全部地址家族中，AF_INET是使用最普遍的一個，python支持不少種地址家族，可是因爲咱們只關心網絡編程，因此大部分時候我麼只使用AF_INET)

6、套接字工做流程

生活中的場景，你要打電話給一個朋友，先撥號，朋友聽到電話鈴聲後提起電話，這時你和你的朋友就創建起了鏈接，就能夠講話了。等交流結束，掛斷電話結束這次交談。

生活中的場景就解釋了這工做原理，也許TCP/IP協議族就是誕生於生活中，這也不必定。

　　先從服務器端提及。服務器端先初始化Socket，而後與端口綁定(bind)，對端口進行監聽(listen)，調用accept阻塞，等待客戶端鏈接。在這時若是有個客戶端初始化一個Socket，而後鏈接服務器(connect)，若是鏈接成功，這時客戶端與服務器端的鏈接就創建了。客戶端發送數據請求，服務器端接收請求並處理請求，而後把迴應數據發送給客戶端，客戶端讀取數據，最後關閉鏈接，一次交互結束。

一、socket模塊發送和接收消息

示例：模擬發送消息和接收消息的過程

tcp服務端（server）

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
import socket
                             
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)  #買手機
phone.bind(('127.0.0.1',8000))  #綁定手機卡   #改爲服務端網卡IP地址和端口
phone.listen(5)  #開機  5的做用是最大掛起鏈接數   #backlog鏈接池（也叫半連接）
print('------------->')
conn,addr=phone.accept()  #等電話

msg=conn.recv(1024)  #收消息
print('客戶端發來的消息是：',msg)
conn.send(msg.upper())  #發消息

conn.close()
phone.close()

View Code

執行結果：

------------->

tcp客戶端(client)

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

import socket

phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

phone.connect(('127.0.0.1',8000)) #拔通電話   #改爲服務端網卡IP地址和端口

phone.send('hello'.encode('utf-8'))  #發消息
data=phone.recv(1024)
print('收到服務端的發來的消息: ',data)

phone.close()

View Code

執行結果：

收到服務端的發來的消息:  b'HELLO'

二、tcp三次握手和四次揮手

主動斷開鏈接：FIN_WAIT_1
被動斷開鏈接： FIN_WAIT_2
立刻斷開鏈接： TIME_WAIT

socket中TCP的三次握手創建鏈接詳解

流程以下：

客戶端向服務器發送一個SYN J
服務器向客戶端響應一個SYN K，並對SYN J進行確認ACK J+1
客戶端再向服務器發一個確認ACK K+1

只有就完了三次握手，可是這個三次握手發生在socket的那幾個函數中呢？請看下圖：

圖一、socket中發送的TCP三次握手

從圖中能夠看出，當客戶端調用connect時，觸發了鏈接請求，向服務器發送了SYN J包，這時connect進入阻塞狀態；服務器監聽到鏈接請求，即收到SYN J包，調用accept函數接收請求向客戶端發送SYN K ，ACK J+1，這時accept進入阻塞狀態；客戶端收到服務器的SYN K ，ACK J+1以後，這時connect返回，並對SYN K進行確認；服務器收到ACK K+1時，accept返回，至此三次握手完畢，鏈接創建。

總結：客戶端的connect在三次握手的第二個次返回，而服務器端的accept在三次握手的第三次返回。

socket中TCP的四次握手釋放鏈接詳解

上面介紹了socket中TCP的三次握手創建過程，及其涉及的socket函數。如今咱們介紹socket中的四次握手釋放鏈接的過程，請看下圖：

圖二、socket中發送的TCP四次握手

圖示過程以下：

某個應用進程首先調用close主動關閉鏈接，這時TCP發送一個FIN M；
另外一端接收到FIN M以後，執行被動關閉，對這個FIN進行確認。它的接收也做爲文件結束符傳遞給應用進程，由於FIN的接收意味着應用進程在相應的鏈接上再也接收不到額外數據；
一段時間以後，接收到文件結束符的應用進程調用close關閉它的socket。這致使它的TCP也發送一個FIN N；
接收到這個FIN的源發送端TCP對它進行確認。

這樣每一個方向上都有一個FIN和ACK。

總結：

四次揮手斷開鏈接原則：

記住一條原則：誰先發起客戶端請求，誰先斷開鏈接
可是在大併發狀況下，大部分都是服務端先斷開鏈接，不會保留鏈接。由於每一分鐘都有不少人在訪問網站。

三、socket()模塊函數用法

import socket
socket.socket(socket_family,socket_type,protocal=0)
socket_family 能夠是 AF_UNIX 或 AF_INET。socket_type 能夠是 SOCK_STREAM 或 SOCK_DGRAM。protocol 通常不填,默認值爲 0。

獲取tcp/ip套接字
tcpSock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

獲取udp/ip套接字
udpSock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

因爲 socket 模塊中有太多的屬性。咱們在這裏破例使用了'from module import *'語句。使用 'from socket import *',咱們就把 socket 模塊裏的全部屬性都帶到咱們的命名空間裏了,這樣能 大幅減短咱們的代碼。
例如tcpSock = socket(AF_INET, SOCK_STREAM)

View Code

服務端套接字函數

s.bind() 綁定(主機,端口號)到套接字
s.listen() 開始TCP監聽
s.accept() 被動接受TCP客戶的鏈接,(阻塞式)等待鏈接的到來

客戶端套接字函數
s.connect() 主動初始化TCP服務器鏈接
s.connect_ex() connect() 函數的擴展版本,出錯時返回出錯碼,而不是拋出異常

公共用途的套接字函數
s.recv() 接收TCP數據
s.send() 發送TCP數據(send在待發送數據量大於己端緩存區剩餘空間時,數據丟失,不會發完)
s.sendall() 發送完整的TCP數據(本質就是循環調用send,sendall在待發送數據量大於己端緩存區剩餘空間時,數據不丟失,循環調用send直到發完)
s.recvfrom() 接收UDP數據
s.sendto() 發送UDP數據
s.getpeername() 鏈接到當前套接字的遠端的地址
s.getsockname() 當前套接字的地址
s.getsockopt() 返回指定套接字的參數
s.setsockopt() 設置指定套接字的參數
s.close() 關閉套接字

面向鎖的套接字方法
s.setblocking() 設置套接字的阻塞與非阻塞模式
s.settimeout() 設置阻塞套接字操做的超時時間
s.gettimeout() 獲得阻塞套接字操做的超時時間

面向文件的套接字的函數
s.fileno() 套接字的文件描述符
s.makefile() 建立一個與該套接字相關的文件

7、基於TCP的套接字

tcp語法格式：

tcp服務端

ss = socket()  #建立服務器套接字
ss.bind()      #把地址綁定到套接字
ss.listen()    #監聽連接
inf_loop:      #服務器無限循環
    cs = ss.accept()  #接受客戶端連接
    comm_loop:        #通信循環
        cs.recv()/cs.send()  #對話(接收與發送)
    cs.close()    #關閉客戶端套接字
ss.close()        #關閉服務器套接字(可選)

View Code

tcp客戶端

cs = socket()    #建立客戶套接字
cs.connect()     #嘗試鏈接服務器
comm_loop:       #通信循環
    cs.send()/cs.recv()  #對話(發送/接收)
cs.close()               #關閉客戶套接字

View Code

一、基於tcp實現：客戶端發送空格，服務端也會接收

示例：

tcp_server端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
 
ip_port = ('127.0.0.1', 8080)
back_log = 5
buffer_size = 1024
 
tcp_server = socket(AF_INET, SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)
 
print('服務端開始運行了')
conn, addr = tcp_server.accept()  #服務器阻塞
print('雙向連接是', conn)
print('客戶端地址', addr)
 
while True:
    data = conn.recv(buffer_size)    #收緩存爲空，則阻塞
    print('客戶端發來的消息是', data.decode('utf-8'))
    conn.send(data.upper())
conn.close()
 
tcp_server.close()

View Code

tcp_client端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

from socket import *

ip_port = ('127.0.0.1', 8080)
back_log = 5
buffer_size = 1024
 
tcp_client = socket(AF_INET, SOCK_STREAM)
tcp_client.connect(ip_port)
 
while True:
    msg = input('>>:')          #發送空格到本身的發送緩存中
    # msg=input('>>:').strip()  #去掉空格
    tcp_client.send(msg.encode('utf-8'))
    print('客戶端已經發送消息')
    data = tcp_client.recv(buffer_size)  #收緩存爲空則阻塞
    print('收到服務端發來的消息是', data.decode('utf-8'))
 
tcp_client.close()

View Code

執行結果：

View Code

實驗過程當中遇到的問題：

在重啓服務端時可能會遇到以下報錯：

　　這個是因爲你的服務端仍然存在四次揮手的time_wait狀態在佔用地址（若是不懂，請深刻研究1.tcp三次握手，四次揮手 2.syn洪水攻擊 3.服務器高併發狀況下會有大量的time_wait狀態的優化方法）。

解決方法：

法一：在程序中處理

1 #加入一條socket配置，重用ip和端口
2 
3 phone=socket(AF_INET,SOCK_STREAM)
4 phone.setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
5 phone.bind(('127.0.0.1',8080))

法二：在linux系統中，經過調整系統內核參數的方式來解決

發現系統存在大量TIME_WAIT狀態的鏈接，經過調整linux內核參數解決，系統優化的一個優化點）
 
vi /etc/sysctl.conf

編輯文件，加入如下內容：
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_tw_recycle = 1
net.ipv4.tcp_fin_timeout = 30
  
而後執行 /sbin/sysctl -p 讓參數生效。
  
net.ipv4.tcp_syncookies = 1   表示開啓SYN Cookies。當出現SYN等待隊列溢出時，啓用cookies來處理，可防範少許SYN攻擊，默認爲0，表示關閉；
 
net.ipv4.tcp_tw_reuse = 1     表示開啓重用。容許將TIME-WAIT sockets從新用於新的TCP鏈接，默認爲0，表示關閉；
 
net.ipv4.tcp_tw_recycle = 1   表示開啓TCP鏈接中TIME-WAIT sockets的快速回收，默認爲0，表示關閉。
 
net.ipv4.tcp_fin_timeout = 30 修改系統默認的 TIMEOUT 時間

View Code

8、基於UDP的套接字

udp語法格式：

udp服務端

1 ss = socket()   #建立一個服務器的套接字
2 ss.bind()       #綁定服務器套接字
3 inf_loop:       #服務器無限循環
4     cs = ss.recvfrom()/ss.sendto() # 對話(接收與發送)
5 ss.close()

udp客戶端

1 cs = socket()   # 建立客戶套接字
2 comm_loop:      # 通信循環
3     cs.sendto()/cs.recvfrom()   # 對話(發送/接收)
4 cs.close()                      # 關閉客戶套接字

一、基於upd實現方法

示例：

udp_server端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
ip_port=('127.0.0.1',8080)
buffer_size = 1024
 
udp_server = socket(AF_INET,SOCK_DGRAM)  #數據報套接字
udp_server.bind(ip_port)
 
while True:
    data,addr=udp_server.recvfrom(buffer_size)
    print(data)

    udp_server.sendto(data.upper(),addr)  #upper() 小寫變大寫

View Code

udp_client端：

from socket import *
ip_port=('127.0.0.1',8080)  #服務端IP+端口
buffer_size = 1024

udp_client=socket(AF_INET,SOCK_DGRAM) #udp數據報套接字
 
while True:
    msg=input('>>:').strip()
    udp_client.sendto(msg.encode('utf-8'),ip_port)
    #數據，ip地址+端口
    data,addr=udp_client.recvfrom(buffer_size)
    print(data.decode('utf-8'))

View Code

執行結果：

先運行udp_server，再運行udp_client。

服務端返回結果：

1 b'sfdsfds'  #bytes類型
2 b'fdsfds'
3 b'fsdfds'
4 b'sdfdsf'

在客戶端輸入：

1 >>:sfdsfds  #在客戶端輸入
2 SFDSFDS     #服務端返回的結果，把客戶端輸入的字符變大寫
3 
4 >>:fdsfds
5 FDSFDS
6 
7 >>:fsdfds
8 FSDFDS

2、實現ntp時間服務器

示例：

tup_server端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
#實現ntp時間服務器
import time
from socket import *
ip_port=('127.0.0.1',8080)
buffer_size = 1024

udp_server = socket(AF_INET,SOCK_DGRAM)  #數據報套接字
udp_server.bind(ip_port)
 
while True:
    data,addr=udp_server.recvfrom(buffer_size)
    print(data)

    if not data:
        fmt='%Y-%m-%d %X'   #若是用戶沒有輸入時間，就返回默認格式
    else:
        fmt=data.decode('utf-8')
        back_time=time.strftime(fmt)

    udp_server.sendto(back_time.encode('utf-8'),addr)

View Code

udp_client端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
ip_port=('127.0.0.1',8080)  #服務端IP+端口
buffer_size = 1024

udp_client=socket(AF_INET,SOCK_DGRAM) #數據報套接字

while True:
    msg=input('>>:').strip()
    udp_client.sendto(msg.encode('utf-8'),ip_port)

    data,addr=udp_client.recvfrom(buffer_size)
    print('ntp服務器的標準時間是',data.decode('utf-8'))

View Code

執行結果：

運行udp_server,再運行udp_client,而後在udp_client裏輸入：

1 >>:%Y   #在客戶端輸入%Y
2 ntp服務器的標準時間是 2017  #就會返回服務端的時間
3 >>:%m-%d-%Y
4 ntp服務器的標準時間是 01-03-2017
5 >>:

三、基於tcp實現遠程執行命令

備註：因系統差別，請儘可能把程序放在linux服務器上面運行，windows上面可能會報錯。

socket_server_tcp服務端 (在linux上面運行）

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
import subprocess

ip_port = ('192.168.1.135', 8000)
back_log = 5
buffer_size = 1024

tcp_server = socket(AF_INET, SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

while True:
    conn,addr=tcp_server.accept()
    print('新的客戶端連接',addr)
    while True:
        #收
        try:
            cmd=conn.recv(buffer_size)
            #if not cmd:break  MAC筆記本處理方法
            print('收到客戶端的命令',cmd)

            #執行命令，獲得命令的運行結果cmd_res
            res=subprocess.Popen(cmd.decode('utf-8'),shell=True,
                                 stderr=subprocess.PIPE,
                                 stdout=subprocess.PIPE,
                                 stdin=subprocess.PIPE)
            err=res.stderr.read()
            if err:
                cmd_res=err
            else:
                cmd_res=res.stdout.read()
            #發
            conn.send(cmd_res)
        except Exception as e:
            print(e)
            break
conn.close()

View Code

socket_client_tcp客戶端（windows系統上面運行）

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *

# ip_port = ('127.0.0.1', 8082)
ip_port = ('192.168.1.135', 8000)
back_log = 5
buffer_size = 1024

tcp_client = socket(AF_INET, SOCK_STREAM)
tcp_client.connect(ip_port)

while True:
    cmd=input('>>:').strip()
    if not cmd:continue
    if cmd == 'quit':break

    tcp_client.send(cmd.encode('utf-8'))
    cmd_res=tcp_client.recv(buffer_size)
    # print('命令的執行結果是 ',cmd_res.decode('gbk'))
    print('命令的執行結果是 ',cmd_res.decode('utf-8'))
tcp_client.close()

View Code

執行結果：

在客戶端執行命令：

 >>:df -h
 命令的執行結果是  Filesystem      Size  Used Avail Use% Mounted on
 /dev/sda3       9.6G  1.8G  7.3G  20% /
 tmpfs           931M     0  931M   0% /dev/shm
 /dev/sda1       190M   32M  149M  18% /boot
 /dev/sr0        4.4G  4.4G     0 100% /opt
 
 >>:dir
 命令的執行結果是  s3.py       server_ssh.py     socket_server.py
server.py  socket_clinet_udp.py  socket_server_udp.py
 
服務端返回結果：
[root@python3 scripts]# python socket_server.py
新的客戶端連接 ('192.168.1.115', 53569)
收到客戶端的命令 b'df -h'
收到客戶端的命令 b'dir'

View Code

四、基於udp實現遠程執行命令

socket_server_udp服務端：

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
import subprocess

ip_port = ('192.168.1.135', 8000)
back_log = 5
buffer_size = 1024

udp_server = socket(AF_INET, SOCK_DGRAM)
udp_server.bind(ip_port)
 
while True:
    cmd,addr=udp_server.recvfrom(buffer_size)
    print(cmd)

    #執行命令，獲得命令的運行結果cmd_res
    res = subprocess.Popen(cmd.decode('utf-8'), shell=True,
                           stderr=subprocess.PIPE,
                           stdout=subprocess.PIPE,
                           stdin=subprocess.PIPE)
    err = res.stderr.read()
    if err:
        cmd_res = err
    else:
        cmd_res = res.stdout.read()

    if not cmd_res:  # 判斷爲空的狀況
        cmd_res = '執行成功'.encode('gbk')  #linux改爲utf-8
    print(cmd_res)
    #發
    udp_server.sendto(cmd_res,addr)

View Code

socket_clinet_udp客戶端：

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
  
from socket import *

ip_port = ('192.168.1.135', 8000)
# ip_port = ('192.168.12.63', 8000)
back_log = 5
buffer_size = 10240

udp_client = socket(AF_INET, SOCK_DGRAM)

while True:
    cmd=input('>>:').strip()
    if not cmd:continue
    if cmd == 'quit':break
 
    udp_client.sendto(cmd.encode('utf-8'),ip_port)
    cmd_res,addr=udp_client.recvfrom(buffer_size)
    print('命令的執行結果是 ',cmd_res.decode('gbk'))  #若是在linux上面運行，把gbk改爲utf-8
udp_client.close()

View Code

執行結果：

View Code

9、recv與recvfrom的區別

一、收發原理詳解：

發消息：都是將數據發送到己端的發送緩衝中

收消息：都是從己端的緩衝區中收

二、發消息兩者相似，收消息確實有區別的？

tcp協議：send發消息，recv收消息

（1）若是收消息緩衝區裏的數據爲空，那麼recv就會阻塞

（2）tcp基於連接通訊，若是一端斷開了連接，那另一端的連接也跟着完蛋recv將不會阻塞，收到的是空

udp協議：sendto發消息，recvfrom收消息

（1）若是若是收消息緩衝區裏的數據爲「空」，recvfrom不會阻塞

（2）recvfrom收的數據小於sendinto發送的數據時，數據丟失

（3）只有sendinto發送數據沒有recvfrom收數據，數據丟失

注意：

1.你單獨運行上面的udp的客戶端，你發現並不會報錯，相反tcp卻會報錯，由於udp協議只負責把包發出去，對方收不收，我根本無論，而tcp是基於連接的，必須有一個服務端先運行着，客戶端去跟服務端創建連接而後依託於連接才能傳遞消息，任何一方試圖把連接摧毀都會致使對方程序的崩潰。

2.上面的udp程序，你註釋任何一條客戶端的sendinto，服務端都會卡住，爲何？由於服務端有幾個recvfrom就要對應幾個sendinto，哪怕是sendinto(b'')那也要有。

3.總結：

1.udp的sendinto不用管是否有一個正在運行的服務端，能夠己端一個勁的發消息

2.udp的recvfrom是阻塞的，一個recvfrom(x)必須對一個一個sendinto(y),收完了x個字節的數據就算完成,如果y>x數據就丟失，這意味着udp根本不會粘包，可是會丟數據，不可靠

3.tcp的協議數據不會丟，己端老是在收到ack時纔會清除緩衝區內容。數據是可靠的，可是會粘包。

10、粘包

須知：只有TCP有粘包現象，UDP永遠不會粘包。（緣由詳見第3點）

一、socket收發消息的原理

socket發送原理圖

二、爲何會出現所謂的粘包

緣由：接收方不知道消息之間的界限，不知道一次性提取多少字節的數據所形成的。

　　此外，發送方引發的粘包是由TCP協議自己形成的，TCP爲提升傳輸效率，發送方每每要收集到足夠多的數據後才發送一個TCP段。若連續幾回須要send的數據都不多，一般TCP會根據優化算法把這些數據合成一個TCP段後一次發送出去，這樣接收方就收到了粘包數據。

TCP（transport control protocol，傳輸控制協議）是面向鏈接的，面向流的，提供高可靠性服務。收發兩端（客戶端和服務器端）都要有一一成對的socket，所以，發送端爲了將多個發往接收端的包，更有效的發到對方，使用了優化方法（Nagle算法），將屢次間隔較小且數據量小的數據，合併成一個大的數據塊，而後進行封包。這樣，接收端，就難於分辨出來了，必須提供科學的拆包機制。即面向流的通訊是無消息保護邊界的。
UDP（user datagram protocol，用戶數據報協議）是無鏈接的，面向消息的，提供高效率服務。不會使用塊的合併優化算法，, 因爲UDP支持的是一對多的模式，因此接收端的skbuff(套接字緩衝區）採用了鏈式結構來記錄每個到達的UDP包，在每一個UDP包中就有了消息頭（消息來源地址，端口等信息），這樣，對於接收端來講，就容易進行區分處理了。 即面向消息的通訊是有消息保護邊界的。
tcp是基於數據流的，因而收發的消息不能爲空，這就須要在客戶端和服務端都添加空消息的處理機制，防止程序卡住，而udp是基於數據報的，即使是你輸入的是空內容（直接回車），那也不是空消息，udp協議會幫你封裝上消息頭。

三、tcp會發生粘包的兩種狀況以下：

一、發送端屢次send間隔較短，而且數據量較小，tcp會經過Nagls算法，封裝成一個包，發送到接收端，接收端不知道這個包由幾部分組成，因此就會產生粘包。

二、數據量發送的大，接收端接收的小，再接一次，還會出現上次沒有接收完成的數據。就會出現粘包。

示例1：發送端屢次send間隔較短，而且數據量較小，tcp會經過Nagls算法，封裝成一個包，發送到接收端，接收端不知道這個包由幾部分組成，因此就會產生粘包。

server服務端：

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
ip_port=('127.0.0.1',8082)
back_log=5
buffer_size=1024

tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

conn,addr=tcp_server.accept()

data1=conn.recv(buffer_size)  #指定buffer_size ,獲得的結果就是經過Nagle算法，隨機接收次數。
print('第1次數據',data1)

data2=conn.recv(buffer_size)
print('第2次數據',data2)

data3=conn.recv(buffer_size)
print('第3次數據',data3)

View Code

client客戶端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

from socket import *
import time

ip_port=('127.0.0.1',8082)
back_log=5
buffer_size=1024

tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

tcp_client.send('hello'.encode('utf-8'))
tcp_client.send('world'.encode('utf-8'))
tcp_client.send('egon'.encode('utf-8'))

time.sleep(1000)

View Code

執行結果：

第1次數據 b'helloworldegon'  #不肯定接收次數。

示例2：指定接收字節數，至關於服務端知道接收長度，就不會出現粘包現象

粘包服務端

from socket import *
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024

tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

conn,addr=tcp_server.accept()

data1=conn.recv(5)  #指定每次接收字節數，就不會出現粘包現象
print('第一次數據',data1)

data2=conn.recv(5)
print('第2次數據',data2)

data3=conn.recv(5)
print('第3次數據',data3)

View Code

粘包客戶端

from socket import *
import time
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024

tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

tcp_client.send('hello'.encode('utf-8'))
tcp_client.send('world'.encode('utf-8'))
tcp_client.send('egon'.encode('utf-8'))


time.sleep(1000)

View Code

執行結果：

1 第1次數據 b'hello'   #不會出現粘包現象，發送三次，就接收三次
2 第2次數據 b'world'
3 第3次數據 b'egon'

示例3：數據量發送的大，接收端接收的小，再接一次，還會出現上次沒有接收完成的數據。就會出現粘包。

粘包服務端

from socket import *
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024

tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

conn,addr=tcp_server.accept()

data1=conn.recv(1)
print('第1次數據',data1)

# data2=conn.recv(5)
# print('第2次數據',data2)
#
# data3=conn.recv(1)
# print('第3次數據',data3)

View Code

粘包客戶端

from socket import *
import time
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024  #接收的數據只有1024

tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

tcp_client.send('helloworldegon'.encode('utf-8'))

time.sleep(1000)

View Code

執行結果：

1 第1次數據 b'h'
2 第2次數據 b'ellow'  #發送的數據過大，接收的數據設置的較小，就會出現致使粘包 
3 第3次數據 b'o'

四、udp永遠不會粘包

示例：

udp不粘包服務端

from socket import *
ip_port=('127.0.0.1',8080)
buffer_size=1024

udp_server=socket(AF_INET,SOCK_DGRAM) #數據報
udp_server.bind(ip_port)

data1=udp_server.recvfrom(10)
print('第1次',data1)

data2=udp_server.recvfrom(10)
print('第2次',data2)

data3=udp_server.recvfrom(10)
print('第3次',data3)

data4=udp_server.recvfrom(2)
print('第4次',data4)

View Code

udp不粘包客戶端

from socket import *
ip_port=('127.0.0.1',8080)
buffer_size=1024

udp_client=socket(AF_INET,SOCK_DGRAM) #udp叫數據報

udp_client.sendto(b'hello',ip_port)
udp_client.sendto(b'world',ip_port)
udp_client.sendto(b'egon',ip_port)

View Code

執行結果：

1 第1次 (b'hello', ('127.0.0.1', 57813))  #udp沒有Nagle優化算法
2 第2次 (b'world', ('127.0.0.1', 57813))  #每次都是一次獨立的包，因此不會出現粘包現象
3 第3次 (b'egon', ('127.0.0.1', 57813))

五、qq聊天(因爲udp無鏈接，因此能夠同時多個客戶端去跟服務端通訊)

udp_socket_server服務端代碼：

#實現相似於QQ聊天功能

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

import socket
ip_port=('127.0.0.1',8081)
udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
udp_server_sock.bind(ip_port)

while True:
    qq_msg,addr=udp_server_sock.recvfrom(1024)
    print('來自[%s:%s]的一條消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))
    back_msg=input('回覆消息: ').strip()

    udp_server_sock.sendto(back_msg.encode('utf-8'),addr)

View Code

udp_socket_client客戶端：

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

import socket
BUFSIZE=1024
udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

qq_name_dic={
    '努力哥':('127.0.0.1',8081),
    '劉哥':('127.0.0.1',8081),
    '李哥':('127.0.0.1',8081),
    '王哥':('127.0.0.1',8081),
}

while True:
    qq_name=input('請選擇聊天對象: ').strip()   #選擇字典中的聊天對象，再發送消息
    while True:
        msg=input('請輸入消息,回車發送: ').strip()
        if msg == 'quit':break
        if not msg or not qq_name or qq_name not in qq_name_dic:continue
        udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])

        back_msg,addr=udp_client_socket.recvfrom(BUFSIZE)
        print('來自[%s:%s]的一條消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))

udp_client_socket.close()

View Code

執行結果：

先啓動服務端,再啓動客戶端向服務端發送消息：

#客戶端發送消息

請選擇聊天對象: 努力哥
請輸入消息,回車發送: 吃飯沒有
來自[127.0.0.1:8081]的一條消息:還沒吃呢
請輸入消息,回車發送: 

#服務端接收消息

來自[127.0.0.1:62642]的一條消息:吃飯沒有
回覆消息: 還沒吃呢

補充知識：

一、tcp是可靠傳輸

　　tcp在數據傳輸時，發送端先把數據發送到本身的緩存中，而後協議控制將緩存中的數據發往對端，對端返回一個ack=1，發送端則清理緩存中的數據，對端返回ack=0，則從新發送數據，因此tcp是可靠的。

二、udp是不可靠傳輸

　 udp發送數據，對端是不會返回確認信息的，所以不可靠。

11、解決粘包的辦法

法一：比較(LOW)版本

示例：

low_socket_server服務端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

#low版解決粘包版本服務端
from socket import *
import subprocess
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024

tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

while True:
    conn,addr=tcp_server.accept()
    print('新的客戶端連接',addr)
    while True:
        #收消息
        try:
            cmd=conn.recv(buffer_size)
            if not cmd:break
            print('收到客戶端的命令',cmd)

            #執行命令，獲得命令的運行結果cmd_res
            res=subprocess.Popen(cmd.decode('utf-8'),shell=True,
                                 stderr=subprocess.PIPE,
                                 stdout=subprocess.PIPE,
                                 stdin=subprocess.PIPE)
            err=res.stderr.read()
            if err:
                cmd_res=err
            else:
                cmd_res=res.stdout.read()

            #發送消息
            if not cmd_res:
                cmd_res='執行成功'.encode('gbk')

            length=len(cmd_res)  #計算長度
            conn.send(str(length).encode('utf-8')) #把長度發給客戶端
            client_ready=conn.recv(buffer_size)    #卡着一個recv
            if client_ready == b'ready':  #若是收到客戶端的ready消息，就說明準備好了。
                conn.send(cmd_res)        #就能夠send給客戶端發送消息啦！
        except Exception as e:
            print(e)
            break

View Code

low_socket_client客戶端

執行結果：

View Code

總結：

（爲什麼low): 程序的運行速度遠快於網絡傳輸速度，因此在發送一段字節前，先用send去發送該字節流長度，這種方式會放大網絡延遲帶來的性能損耗。

法二：節省網絡傳輸版本（牛逼版本）

　　爲字節流加上自定義固定長度報頭，報頭中包含字節流長度，而後一次send到對端，對端在接收時，先從緩存中取出定長的報頭，而後再取真實數據。

示例：(沒實現多客戶端併發）

tcp_socket_server服務端：

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
import subprocess
import struct
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024

tcp_server=socket(AF_INET,SOCK_STREAM)
tcp_server.bind(ip_port)
tcp_server.listen(back_log)

while True:
    conn,addr=tcp_server.accept()
    print('新的客戶端連接',addr)
    while True:
        #收
        try:
            cmd=conn.recv(buffer_size)
            if not cmd:break
            print('收到客戶端的命令',cmd)

            #執行命令，獲得命令的運行結果cmd_res
            res=subprocess.Popen(cmd.decode('utf-8'),shell=True,
                                 stderr=subprocess.PIPE,
                                 stdout=subprocess.PIPE,
                                 stdin=subprocess.PIPE)
            err=res.stderr.read()
            if err:
                cmd_res=err
            else:
                cmd_res=res.stdout.read()
            #發
            if not cmd_res:
                cmd_res='執行成功'.encode('gbk')

            length=len(cmd_res)

            data_length=struct.pack('i',length)
            conn.send(data_length)
            conn.send(cmd_res)
        except Exception as e:
            print(e)
            break

View Code

tcp_socket_client客戶端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

from socket import *
import struct
from functools import partial
ip_port=('127.0.0.1',8080)
back_log=5
buffer_size=1024

tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

while True:
    cmd=input('>>: ').strip()
    if not cmd:continue
    if cmd == 'quit':break

    tcp_client.send(cmd.encode('utf-8'))
 
 
    #解決粘包
    length_data=tcp_client.recv(4)
    length=struct.unpack('i',length_data)[0]

    recv_size=0
    recv_data=b''
    while recv_size < length:
        recv_data+=tcp_client.recv(buffer_size)
        recv_size=len(recv_data)
    print('命令的執行結果是 ',recv_data.decode('gbk'))
tcp_client.close()

View Code

執行結果：

View Code

12、用到的相關模塊知識講解

一、subprocess模塊

subprocess 做用：啓動一個新的進程並與之通訊

語法：

subprocess.Popen(args, bufsize=0, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=False, shell=False, cwd=None, env=None, universal_newlines=False, startupinfo=None, creationflags=0)

參數：

Popen類：用Popen來建立進程，並與進程進行復雜的交互
shell=True: 指定的命令行會經過shell來執行
stdin : 標準輸入
stdout : 標準輸出
stderr : 標準錯誤的文件句柄
PIPE : 管道 ,默認值爲: None, 表示不作重定向，管道能夠用來接收數據。

示例1：執行dir命令，就會交給shell解釋器執行

import subprocess  #導入模塊

命令：
>>> subprocess.Popen("dir", shell=True)    #執行dir命令，交給shell解釋器執行

執行結果：
<subprocess.Popen object at 0x00A7B950>
 Directory of C:\Python3.5
2016/11/21  14:14    <DIR>          .
2016/11/21  14:14    <DIR>          ..
2016/11/21  14:14    <DIR>          DLLs
2016/11/21  14:14    <DIR>          Doc
2016/11/21  14:14    <DIR>          include
2016/11/21  14:14    <DIR>          Lib
2016/11/21  14:14    <DIR>          libs
2016/06/25  22:08            30,345 LICENSE.txt
2016/06/25  21:48           340,667 NEWS.txt
2016/06/25  22:02            39,576 python.exe
2016/06/25  22:02            51,864 python3.dll
2016/06/25  22:02         3,127,960 python35.dll
2016/06/25  22:02            39,576 pythonw.exe
2016/06/25  21:48             8,282 README.txt
2016/11/21  14:14    <DIR>          Scripts
2016/11/21  14:14    <DIR>          tcl
2016/11/21  14:14    <DIR>          Tools
2016/03/17  22:48            85,840 vcruntime140.dll
               8 File(s)      3,724,110 bytes
              10 Dir(s)  211,565,547,520 bytes free

View Code

示例2：subprocess 把標準輸出放入管道中，屏幕上就不會輸出內容

示例2：把標準輸出放入管道中，屏幕上就不會輸出內容。
res=subprocess.Popen("dir", shell=True,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)   #執行dir命令，交給shell解釋器執行，經過標準類型和subprocess.PIPE放入管道中。

>>> res.stdout.read()  #讀取管道里面的數據，在程序中，讀取也不會輸出到屏幕上。

執行結果：
b' Volume in drive C has no label.\r\n Volume Serial Number is 4C49-9FA8\r\n\r\n Directory of C:\\Python3.5\r\n\r\n2016/11/21  14:14    <DIR>          .\r\n2016/11/21  14:14    <DIR>          ..\r\n2016/11/21  14:14    <DIR>          DLLs\r\n2016/11/21  14:14    <DIR>          Doc\r\n2016/11/21  14:14    <DIR>          include\r\n2016/11/21  14:14    <DIR>          Lib\r\n2016/11/21  14:14    <DIR>          libs\r\n2016/06/25  22:08            30,345 LICENSE.txt\r\n2016/06/25  21:48           340,667 NEWS.txt\r\n2016/06/25  22:02            39,576 python.exe\r\n2016/06/25  22:02            51,864 python3.dll\r\n2016/06/25  22:02         3,127,960 python35.dll\r\n2016/06/25  22:02            39,576 pythonw.exe\r\n2016/06/25  21:48             8,282 README.txt\r\n2016/11/21  14:14    <DIR>          Scripts\r\n2016/11/21  14:14    <DIR>          tcl\r\n2016/11/21  14:14    <DIR>          Tools\r\n2016/03/17  22:48            85,840 vcruntime140.dll\r\n               8 File(s)      3,724,110 bytes\r\n              10 Dir(s)  211,560,914,944 bytes free\r\n'

>>> res.stdout.read()   #再read一次，內容就爲空，說明讀取完成啦！
b''  #顯示爲：bytes類型

View Code

示例3：subprocess 執行一個系統沒有的命令，就會產生正常的輸出

#執行一個系統沒有的命令，就會產生正常的輸出

>>> res=subprocess.Popen("sfsfdsfdsfs", shell=True,stdout=subprocess.PIPE,stdin=subprocess.PIPE,stderr=subprocess.PIPE)

>>> res.stdout.read()  #讀取沒有內容
b''

>>> res.stderr.read()  #有正常的輸出
b"'sfsfdsfdsfs' is not recognized as an internal or external command,\r\noperable program or batch file.\r\n"

View Code

二、struct模塊

struct模塊做用：解決bytes和其餘二進制數據類型的轉換

示例用法：
struct.pack('i',12)

參數說明：

pack函數做用：把任意數據類型變成bytes

i 表示4字節無符號整數。

示例1：

>>> import struct
>>> struct.pack('i',12) #把後面的整形數據，封裝成一個bytes類型
b'\x0c\x00\x00\x00' #長度就是4

>>> l=struct.pack('i',12313123)
>>> len(l)
4 #長度就是4

View Code

示例2：

>>> struct.pack('i',1)
b'\x01\x00\x00\x00'

#反解
>>> struct.unpack('i',l)
(12313123,)

#查看類型
>>> l=struct.pack('i',1)
>>> type(l)
<class 'bytes'>  #bytes類型

View Code

Format Characters(格式化字符)：

Format	C Type	Python type	Standard size	Notes
`x`	pad byte	no value
`c`	`char`	bytes of length 1	1
`b`	`signed char`	integer	1	(1),(3)
`B`	`unsigned char`	integer	1	(3)
`?`	`_Bool`	bool	1	(1)
`h`	`short`	integer	2	(3)
`H`	`unsigned short`	integer	2	(3)
`i`	`int`	integer	4	(3)
`I`	`unsigned int`	integer	4	(3)
`l`	`long`	integer	4	(3)
`L`	`unsigned long`	integer	4	(3)
`q`	`long long`	integer	8	(2), (3)
`Q`	`unsigned long long`	integer	8	(2), (3)
`n`	`ssize_t`	integer		(4)
`N`	`size_t`	integer		(4)
`e`	(7)	float	2	(5)
`f`	`float`	float	4	(5)
`d`	`double`	float	8	(5)
`s`	`char[]`	bytes
`p`	`char[]`	bytes
`P`	`void *`	integer		(6)

詳細用法參考：

http://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000/001431955007656a66f831e208e4c189b8a9e9f3f25ba53000

官方文檔參考：(英文文檔）
https://docs.python.org/3/library/struct.html#format-characters

三、urandom模塊

做用：產生隨機數

>>> import os
>>> os.urandom(32)  #產生32位字節隨機數
b'=\xbcC\xa3\xe0\xd5\x12\xe4CZ?\xd9Q{\x97\x89g7lvD\xd4\xed\xd8\xeau\xc1\x9c\xb6\xd8fR'

示例：使用md5 + os.urandom(n) 產生隨機字符串

import os
from hashlib import md5

for i in range(5):  #循環幾回就產生幾回隨機數
   print(md5(os.urandom(32)).hexdigest())

執行結果：

1fc70d335903283e1ac8165a28fbdddb
7a1305507f485e4d3c03f4e0c200ab6d
824db1b1076302f46166bbd93c41f0dd
a350c246781d5a6139d18df267e50485
f38fb315a24e33d1703df81fe6b7a4e2

十3、socket 實現併發

SocketServer是基於socket寫成的一個更強大的模塊。

SocketServer簡化了網絡服務器的編寫。它有4個類：TCPServer，UDPServer，UnixStreamServer，UnixDatagramServer。這4個類是同步進行處理的，另外經過ForkingMixIn和ThreadingMixIn類來支持異步。

在python3中該模塊是socketserver

在python2中該模塊是Socketserver

分狀況導入導入模塊
try:
   import socketserver      #Python 3
except ImportError:
   import SocketServer      #Python 2

服務器

　　服務器要使用處理程序，必須將其出入到服務器對象，定義了5個基本的服務器類型(就是「類」)。BaseServer，TCPServer，UnixStreamServer，UDPServer，UnixDatagramServer。注意：BaseServer不直接對外服務。

關係以下：

服務器：

　　要使用處理程序，必須將其傳入到服務器的對象，定義了四個基本的服務器類。

（1）TCPServer(address,handler) 支持使用IPv4的TCP協議的服務器，address是一個（host,port）元組。Handler是BaseRequestHandler或StreamRequestHandler類的子類的實例。

（2）UDPServer(address,handler) 支持使用IPv4的UDP協議的服務器，address和handler與TCPServer中相似。

（3）UnixStreamServer(address,handler) 使用UNIX域套接字實現面向數據流協議的服務器，繼承自TCPServer。

（4）UnixDatagramServer(address,handler) 使用UNIX域套接字實現數據報協議的服務器，繼承自UDPServer。

這四個類的實例都有如下方法。

一、s.socket 用於傳入請求的套接字對象。

二、s.sever_address 監聽服務器的地址。如元組（"127.0.0.1",80）

三、s.RequestHandlerClass 傳遞給服務器構造函數並由用戶提供的請求處理程序類。

四、s.serve_forever() 處理無限的請求 #無限處理client鏈接請求

五、s.shutdown() 中止serve_forever()循環

SocketServer模塊中主要的有如下幾個類：

一、BaseServer 包含服務器的核心功能與混合類（mix-in）的鉤子功能。這個類主要用於派生，不要直接生成這個類的類對象，能夠考慮使用TCPServer和UDPServer類。

二、TCPServer 基本的網絡同步TCP服務器

三、UDPServer 基本的網絡同步UDP服務器

四、ForkingTCPServer 　　是ForkingMixIn與TCPServer的組合

五、ForkingUDPServer　　　是ForkingMixIn與UDPServer的組合

六、ThreadingUDPServer　　是ThreadingMixIn和UDPserver的組合

七、ThreadingTCPServer　　是ThreadingMixIn和TCPserver的組合

八、BaseRequestHandler　　必須建立一個請求處理類，它是BaseRequestHandler的子類並重載其handle()方法。

九、StreamRequestHandler　　實現TCP請求處理類的

十、DatagramRequestHandler　　實現UDP請求處理類的

十一、ThreadingMixIn　　實現了核心的線程化功能，用於與服務器類進行混合(mix-in)，以提供一些異步特性。不要直接生成這個類的對象。

十二、ForkingMixIn　　實現了核心的進程化功能，用於與服務器類進行混合(mix-in)，以提供一些異步特性。不要直接生成這個類的對象。

關係圖以下：

建立服務器的步驟：

1：首先必須建立一個請求處理類

2：它是BaseRequestHandler的子類

3：該請求處理類是BaseRequestHandler的子類並從新寫其handle()方法

實例化請求處理類傳入服務器地址和請求處理程序類

最後實例化調用serve_forever() #無限處理client請求

記住一個原則：對tcp來講：self.request=conn

示例：

一、tcp_socket_server服務端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

#服務端已經實現併發，處理客戶端請求

import socketserver

class MyServer(socketserver.BaseRequestHandler):   #基本的通訊循環
    def handle(self):
        print('conn is: ',self.request)  #與client的連接請求信息
        print('addr is: ',self.client_address)  #獲取client的地址和端口號
        #通訊循環
        while True:
            #收消息
            data=self.request.recv(1024)
            print('收到客戶端的消息是',data)

            #發消息
            self.request.sendall(data.upper())

if __name__ == '__main__':
    s=socketserver.ThreadingTCPServer(('127.0.0.1',8000),MyServer) #開啓多線程，綁定地址，和處理通訊的類
    s.serve_forever() #鏈接循環

View Code

tcp_socket_client客戶端

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
ip_port=('127.0.0.1',8000)
back_log=5
buffer_size=1024

tcp_client=socket(AF_INET,SOCK_STREAM)
tcp_client.connect(ip_port)

while True:
    msg=input('>>: ').strip()
    if not msg:continue
    if msg == 'quit':break

    tcp_client.send(msg.encode('utf-8'))

    data=tcp_client.recv(buffer_size)
    print('收到服務端發來的消息: ',data.decode('utf-8'))
 
tcp_client.close()

View Code

執行結果：

開啓一個服務端程序，再開多個客戶端，向服務器發送命令：

#客戶端1
>>: hello   #輸入要發送的消息
收到服務端發來的消息:  HELLO

#客戶端2
>>: word
收到服務端發來的消息:  WORD

#服務端
conn is:  <socket.socket fd=412, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8000), raddr=('127.0.0.1', 62813)>
addr is:  ('127.0.0.1', 62813)
收到客戶端的消息是 b'hello'  #客戶端收到的消息

conn is:  <socket.socket fd=256, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 8000), raddr=('127.0.0.1', 62816)>
addr is:  ('127.0.0.1', 62816)
收到客戶端的消息是 b'word'

View Code

二、udp實現併發

記住一個原則：對udp來講：self.request=(client_data_bytes,udp的套接字對象)

實例：

udp_socket_server服務端：

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
import socketserver

class MyServer(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.request)
        print('收到客戶端的消息是',self.request[0])
        self.request[1].sendto(self.request[0].upper(),self.client_address) #發送的是第1個消息，第2個地址


if __name__ == '__main__':
    s=socketserver.ThreadingUDPServer(('127.0.0.1',8080),MyServer) #多線程
    s.serve_forever()

View Code

udp_socket_client客戶端：

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige
 
from socket import *
ip_port=('127.0.0.1',8080)
buffer_size=1024

udp_client=socket(AF_INET,SOCK_DGRAM) #數據報

while True:
    msg=input('>>: ').strip()
    udp_client.sendto(msg.encode('utf-8'),ip_port)

    data,addr=udp_client.recvfrom(buffer_size)
    # print(data.decode('utf-8'))
    print(data)

View Code

執行結果：

先啓動服務端，再開多個客戶端，向服務端發送消息。

#客戶端
>>: welcome  #輸入要發送的消息
b'WELCOME'

>>: hello
b'HELLO'
>>: 

#服務端
(b'welcome', <socket.socket fd=388, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)
收到客戶端的消息是 b'welcome'   #服務端接收到的消息

(b'hello', <socket.socket fd=388, family=AddressFamily.AF_INET, type=SocketKind.SOCK_DGRAM, proto=0, laddr=('127.0.0.1', 8080)>)
收到客戶端的消息是 b'hello'

View Code

十4、認證客戶端的連接合法性

若是你想在分佈式系統中實現一個簡單的客戶端連接認證功能，又不像SSL那麼複雜，那麼利用hmac+加鹽的方式來實現

tcp_socket_server服務端：

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige


from socket import *
import hmac,os

secret_key=b'linhaifeng bang bang bang'  #加段代碼（加鹽）
def conn_auth(conn):
    '''
    認證客戶端連接
    :param conn:
    :return:
    '''
    print('開始驗證新連接的合法性')
    msg=os.urandom(32)
    conn.sendall(msg)
    h=hmac.new(secret_key,msg)
    digest=h.digest()
    respone=conn.recv(len(digest))
    return hmac.compare_digest(respone,digest)

def data_handler(conn,bufsize=1024):
    if not conn_auth(conn):
        print('該連接不合法,關閉')
        conn.close()
        return
    print('連接合法,開始通訊')
    while True:
        data=conn.recv(bufsize)
        if not data:break
        conn.sendall(data.upper())

def server_handler(ip_port,bufsize,backlog=5):
    '''
    只處理連接
    :param ip_port:
    :return:
    '''
    tcp_socket_server=socket(AF_INET,SOCK_STREAM)
    tcp_socket_server.bind(ip_port)
    tcp_socket_server.listen(backlog)
    while True:
        conn,addr=tcp_socket_server.accept()
        print('新鏈接[%s:%s]' %(addr[0],addr[1]))
        data_handler(conn,bufsize)

if __name__ == '__main__':
    ip_port=('127.0.0.1',9999)
    bufsize=1024
    server_handler(ip_port,bufsize)

View Code

tcp_socket_client客戶端：

#!/usr/bin/env python
# -*- coding:utf-8 -*-      
#Author: nulige

from socket import *
import hmac,os

secret_key=b'linhaifeng bang bang bang'  #加鹽
def conn_auth(conn):
    '''
    驗證客戶端到服務器的連接
    :param conn:
    :return:
    '''
    msg=conn.recv(32)
    h=hmac.new(secret_key,msg)
    digest=h.digest()
    conn.sendall(digest)

def client_handler(ip_port,bufsize=1024):
    tcp_socket_client=socket(AF_INET,SOCK_STREAM)
    tcp_socket_client.connect(ip_port)

    conn_auth(tcp_socket_client)

    while True:
        data=input('>>: ').strip()
        if not data:continue
        if data == 'quit':break

        tcp_socket_client.sendall(data.encode('utf-8'))
        respone=tcp_socket_client.recv(bufsize)
        print(respone.decode('utf-8'))
    tcp_socket_client.close()

if __name__ == '__main__':
    ip_port=('127.0.0.1',9999)
    bufsize=1024
    client_handler(ip_port,bufsize)