python中的socket套接字基础 (客户端服务器信息交互)

1 socket概述

  Python中我们利用Socket套接字来实现网络通信可以说套接字是实现网络编程进行数据传输的一种技术手段。Socket用于描述IP地址和端口应用程序通常通过"套接字"向网络发出请求或者应答网络请求。
  Socket主要是基于应用层和传输层之间是一个中间的抽象层功能是将负责的复杂的TCP/IP协议族隐藏在Socket接口后面。
  应用程序通过套接字发送或接收数据socket模块针对服务器端和客户端Socket进行像对文件一样的打开、读写和关闭等操作。套接字允许应用程序将I/O插入到网络中并与网络中的其他应用程序进行通信。网络套接字是IP地址与端口的组合。

2 socket使用

通给指定地址簇和socket类型来进行创建。

地址簇	描述
socket.AF_UNIX	只能够用于单一的Unix系统进程间通信
socket.AF_INET	服务器之间网络通信IPv4
socket.AF_INET6	IPv6

socket类型	描述
socket.SOCK_STREAM	流式socket , for TCP
socket.SOCK_DGRAM	数据报式socket , for UDP
socket.SOCK_RAW	原始套接字普通的套接字无法处理ICMP、IGMP等网络报文而SOCK_RAW可以其次SOCK_RAW也可以处理特殊的IPv4报文此外利用原始套接字可以通过IP_HDRINCL套接字选项由用户构造IP头。

服务器与客户端交互过程

服务器
1 创建socket套接字
2 绑定地址和端口
3 监听客户端socket请求
4 等待客户端连接
5 创建新套接字描述符等待客户端发送请求
客户端
1 创建套接字
2 发送请求连接服务器地址和端口
3 连接成功后发送/接收数据

2.1 socket常用函数

socket常用函数	描述
sk.bind(address)	将socket绑定到地址。address地址的格式取决于地址族。在AF_INET下以元组host,port的形式表示地址。
sk.listen(backlog)	开始监听传入连接。backlog指定在拒绝连接之前可以挂起的最大连接数量。
sk.connect(address)	连接到address处的socket。一般address的格式为元组hostname,port如果连接出错返回socket.error错误。
sk.connect_ex(address)	同上只不过会有返回值连接成功时返回 0 连接失败时候返回编码。
sk.close()	关闭socket。
sk.recv(bufsize)	接受socket的数据。数据以字符串形式返回bufsize指定最多可以接收的数量。
sk.send(string)	将string中的数据发送到连接的socket。
sk.sendall(string)	将string中的数据发送到连接的socket但在返回之前会尝试发送所有数据。成功返回None失败则抛出异常。
sk.settimeout(timeout)	设置socket操作的超时期timeout是一个浮点数单位是秒。超时期应该在刚创建socket时设置.
sk.accept()	接受连接并返回conn,address,其中conn是新的socket对象可以用来接收和发送数据。address是连接客户端的地址。

2.2 简单实现 客户端与服务器 信息交互

服务器

import socket
from loggers import log

# 1 创建socket套接字
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  
# 格式socket.socket地址簇socket类型
# 返回一个通信套接字s为本机向网络通信的接口。

# 2 绑定地址和端口
port = 18080
host = socket.gethostname() 
# 绑定本地地址只有主机上的进程可以连接到服务器如果host传空字符串服务器将接受本机所有可用的 IPv4 地址。
s.bind((host, port))  


# 3 等待客户端连接
s.listen(3)
# 建立最多三个连接监听,在拒绝连接之前操作系统可以挂起的最大连接数量。

# 4 连接成功后发送/接收数据
while True:
    # (阻塞式)等待连接的到来
    conn, addr = s.accept()
    # conn是新的套接字对象可以用来接收和发送数据。address是连接客户端的地址。
    log.info("欢迎{}连接".format(addr))
    while True:
        data = conn.recv(1024)
        dt = data.decode('utf-8')
        log.info("服务器收到{}".format(dt))
        log.info("服务器发送")
        p = input()
        if p == 'quit':
            conn.close()
            s.close()
        else:
            conn.send(p1.encode('utf-8'))

客户端

import sys
import socket
from loggers import log

def client():
    log.info("客户端启动")
    
    # 1 创建套接字
    c = socket.socket()
    port = 18080
    host = socket.gethostname()
    
    # 2 连接地址和端口
    c.connect((host, port))
    
    # 3 连接成功后发送/接收数据
    while True:
        log.info("客户端发送")
        a = input()
        if a == 'quit':
            c.close()
            sys.exit(0)
        else:
            c.send(a.encode('utf-8'))
            data = c.recv(1024)
            log.info("客户端收到{}".format(data))

if __name__ == '__main__':
    client()

注意先运行服务器再运行客户端运行结果如下

2.3 多线程实现服务器和客户端信息交互

  实例一实现了一个客户端与服务器的通信但存在一些问题不能多个客户端同时与服务器通信发送和接收不能同时进行等。通过使用多线程就可以解决一些问题。
服务器

class MyServer(object):
    def __init__(self):
        self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        host = socket.gethostname()
        port = 18080
        self.server.bind((host, port))
        self.server.listen(5)
        # 将客户端连接的socketaddr保存为键值对放在字典中。
        self.socket_mapping = {}
        self.socket_list = []
        self.maxSize = 1024
        self.loc = threading.Lock()

    def run(self):
        """
        创建用户连接线程和发送信息线程
        """
        t2 = threading.Thread(name="client02", target=my_server.creat_client_socket, args=())
        t2.start()
        t1 = threading.Thread(name="client01", target=my_server.send_to_client, args=())
        t1.start()

    def send_to_client(self):
        """
        获取键盘输入并发送给客户端
        :param socket:
        :return:
        """
        while True:
            info = input('输入发送内容\n')
            print("您要发送的内容为%s" % info)
            id = input('请选择需要发送的线程ID0~' + str(len(self.socket_list) - 1) + '\n')
            print('输入的id为', id)
            self.socket_list[int(id)].send(info.encode('utf-8'))

    def create_client_socket(self):
		"""
		连接客户端开启连接客户端线程
		"""
        while True:
            soc, addr = self.server.accept()
            soc.send('success'.encode('utf-8'))
            self.socket_list.append(soc)
            print("新的客户端", soc)
            threading.Thread(target=self.recv_from_client, args=(soc, addr)).start()

    def recv_from_client(self, soc, addr):
        """
        接收客户端信息
        :param socket:
        :return:
        """
        while True:
        	addr = addr
        	recv_info = soc.recv(self.maxSize).decode('utf-8')
        	print('服务器收到客户端{}的信息: {}'.format(addr, recv_info))

客户端

import socket
import threading
from loggers import log

class MyClient:
    def __init__(self):
        self.server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        host = socket.gethostname()
        port = 18080
        self.server.connect((host, port))
        self.maxSize = 1024

# 将收和发分别创建线程可以解决收发不能同时进行的问题
    def run(self):
        """
		同时收发信息
        """
        tr = threading.Thread(target=self.text_recv)
        tr.start()
        ts = threading.Thread(target=self.text_send)
        ts.start()

# 收和发分别封装成函数
    def text_recv(self):
        """
        接收服务端发来的信息
        """
        while True:
            data = self.server.recv(1024)
            dt = data.decode('utf-8')
            log.info("客户端收到{}".format(dt))

    def text_send(self):
        """
        发送信息给服务器
        """
        while True:
            try:
                msg = input()
                self.server.sendall(msg.encode('utf8'))
                if msg == 'quit':
                    self.server.close()
            except Exception as e:
                log.error(e)

运行结果如下

问题记录
  如下是服务器存在问题的一部分连接多个客户端并同时开启发送和接收线程。
  但在发送数据时存在问题。假设有两个客户端0和1同时连接在进行send_to_client时想通过输入来选择发送给哪一个客户端input()阻塞式输入会一直等待输入输入选择第0个客户端后不继续往下执行之后的代码会再执行客户端1的 “选择客户端”然后再切换到客户端0的发送线程继续执行之后的输入信息再切换到客户端1的发送线程继续执行。这样达不到选择客户端并进行信息发送的目的。
  上述正确实现中将发送信息线程单独拿出来连接的多个客户端创建为多个线程发送信息时选择客户端线程发送信息。

    def run(self):
        """
        多线程同时收发信息
        """
       while True:
            socket, addr = self.server.accept()
            log.info("{}连接成功".format(addr))
            socket.send('success'.encode('utf-8'))
            self.socket_mapping[socket] = addr
            threading.Thread(name="client01", target=self.send_to_client, args=(socket,)).start()
            threading.Thread(name="client02", target=self.recv_from_client, args=(socket,)).start()
    
    def send_to_client(self):
        """
        获取键盘输入,发送给客户端
        :param
        :return:
        """
        while True:
            socket_list = list(self.socket_mapping.keys())
            addr_list = list(self.socket_mapping.values())
            log.info("addr_list:{}".format(addr_list))
            print(len(addr_list))
            if len(self.socket_mapping) > 1:
                choose = input("选择客户端")
                for i in range(len(addr_list)):
                    print(i)

#            if self.loc.acquire(True):
#                info = input("输入发送给客户端")
#                if info != "quit" and len(info) > 0:
#                    socket_list[i].send(info.encode("utf-8"))
#                else:
#                    socket_list[i].close()
#                self.loc.release()