A socket understand

socket layer:

So much dirty work we want to do it all to the socket to do, it is a set of interfaces, the complexity of the TCP / IP protocol suite hidden behind the Socket Interface

In fact, standing on your point of view, socket is a module. We establish a connection and communication between two processes by calling a method module has been implemented.

Web-based sockets Family:

All addresses family, AF_INET is the most widely used one, python supports a variety of address family, but because we only care about network programming, so most of the time we only use AF_INET

Second, the socket (socket) early use

1. TCP-based protocol socket

tcp is based link, you must first start the server, and then start the client to the server links

The machine also address 127.0.0.1 back:
　　　　　　to fend for themselves identify themselves one else has access

send and recv both sides of the correspondence:
　　　　　　Do not appear the situation is the same on both sides of

recv is with the memory to the data:

　　　　　　All data is application with its own memory to the data may come from a hard disk or network transmission
　　　　　　

#server end

import socket

server = socket.socket()  # 买手机 不传参数默认用的就是TCP协议
server.bind(('127.0.0.1',8080))  # bind((host,port))  插电话卡  绑定服务端自己的ip和端口
server.listen(5)  # 开机    半连接池

conn, addr = server.accept()  # 接听电话  等着别人给你打电话     阻塞：等待接收请求
data = conn.recv(1024)  # 听别人说话 接收1024个字节数据          阻塞：等待接收数据
print(data)
conn.send(b'hello baby~')  # 给别人回话

conn.close()  # 挂电话
server.close()  # 关机

#client

import socket

client = socket.socket()  # 拿电话
client.connect(('127.0.0.1',8080))  # 拨号
#写的是对方的ip和port

client.send(b'hello world!')  # 对别人说话
data = client.recv(1024)  # 听别人说话
print(data)

client.close()  # 挂电话

#在重启服务端时（特别是mac系统）可能会遇到以下报错，是因为系统还没有回收端口，端口被占用，加入两句代码重用IP和端口即可：

#导入模块 加入一条socket配置，重用ip和端口
import socket
from socket import SOL_SOCKET,SO_REUSEADDR

server = socket.socket()  # 买手机 不传参数默认用的就是TCP协议
server .setsockopt(SOL_SOCKET,SO_REUSEADDR,1) #就是它，在bind前加
server.bind(('127.0.0.1',8080))  # bind((host,port))  插电话卡  绑定服务端自己的ip和端口
server.listen(5)  # 开机    半连接池

conn, addr = server.accept()  # 接听电话  等着别人给你打电话     阻塞：等待接收请求
data = conn.recv(1024)  # 听别人说话 接收1024个字节数据          阻塞：等待接收数据
print(data)
conn.send(b'hello baby~')  # 给别人回话

conn.close()  # 挂电话
server.close()  # 关机

2. 循环通信和连接循环

#让客户端和服务端可以多次通讯

#改进通讯循环和链接循环

import socket

"""
服务端
    固定的ip和port
    24小时不间断提供服务
"""
server = socket.socket()  # 生成一个对象
server.bind(('127.0.0.1',8080))  # 绑定ip和port
server.listen(5)  # 半连接池

while True:
    conn, addr = server.accept()  # 等到别人来  conn就类似于是双向通道
    print(addr)  # ('127.0.0.1', 51323) 客户端的地址
    while True:
        try:
            data = conn.recv(1024)
            print(data)  # b''  针对mac与linux 客户端异常退出服务端不会报错 只会一直收b''
            if len(data) == 0:break
            conn.send(data.upper())
        except ConnectionResetError as e:
            print(e)
            break
    conn.close()

循环通信服务端

import socket

client = socket.socket()
client.connect(('127.0.0.1',8080))

while True:
    msg = input('>>>:').encode('utf-8')
    if len(msg) == 0:continue
    client.send(msg)
    data = client.recv(1024)
    print(data)

循环通信客户端

三、粘包问题

黏包现象只发生在tcp协议中：

1.从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点。

2.实际上，主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的

1.粘包类型

#发送方粘包

TCP特点：

会将数据量比较小的并且时间间隔比较短的数据一次性打包发送给对方

发送方引起的粘包是由TCP协议本身造成的，TCP为提高传输效率，发送方往往要收集到足够多的数据后才发送一个TCP段。

若连续几次需要send的数据都很少，通常TCP会根据优化算法把这些数据合成一个TCP段后一次发送出去，这样接收方就收到了粘包数据。

#指定接收长度

指定接收长度虽然可以解决，但是你怎么能知道客户端出来什么数据呢？

import socket


server = socket.socket()  # 买手机 不传参数默认用的就是TCP协议
server.bind(('127.0.0.1',8080))  # bind((host,port))  插电话卡  绑定ip和端口
server.listen(5)  # 开机    半连接池


conn, addr = server.accept()  # 接听电话  等着别人给你打电话     阻塞
data = conn.recv(5)  # 听别人说话 接收1024个字节数据          阻塞
print(data)
data = conn.recv(5)  # 听别人说话 接收1024个字节数据          阻塞
print(data)
data = conn.recv(4)  # 听别人说话 接收1024个字节数据          阻塞
print(data)



import socket
client = socket.socket()
client.connect(('127.0.0.1',8080))

client.send(b'hello')
client.send(b'world')
client.send(b'baby')

指定接收长度

#接收方造成的

接收方不及时接收缓冲区的包，造成多个包接收（客户端发送了一段数据，服务端只收了一小部分，服务端下次再收的时候还是从缓冲区拿上次遗留的数据，产生粘包）

#_*_coding:utf-8_*_
from socket import *
ip_port=('127.0.0.1',8080)

tcp_socket_server=socket(AF_INET,SOCK_STREAM)
tcp_socket_server.bind(ip_port)
tcp_socket_server.listen(5)


conn,addr=tcp_socket_server.accept()


data1=conn.recv(2) #一次没有收完整
data2=conn.recv(10)#下次收的时候,会先取旧的数据,然后取新的

print('----->',data1.decode('utf-8'))
print('----->',data2.decode('utf-8'))

conn.close()

服务端

#_*_coding:utf-8_*_
import socket
BUFSIZE=1024
ip_port=('127.0.0.1',8080)

s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
res=s.connect_ex(ip_port)


s.send('hello egg'.encode('utf-8'))

客户端

Socket socket network programming