day7 --socket网络编程基础

socket网路编程基础

Socket又称"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络请求，使主机间或者一台计算机上的进程间可以通讯。　　Socket起源于UNIX，在Unix一切皆文件哲学的思想下，socket是一种"打开—读/写—关闭"模式的实现，服务器和客户端各自维护一个"文件"，在建立连接打开后，可以向自己文件写入内容供对方读取或者读取对方内容，通讯结束时关闭文件。socket的英文原义是“插槽”或“插座”，就像我们家里座机一样，如果没有网线的那个插口，电话是无法通信的。Socket是实现TCP，UDP协议的接口，便于使用TCP,UDP。

# 流程描述：
# 
# 1 服务器根据地址类型（ipv4,ipv6）、socket类型、协议创建socket
# 
# 2 服务器为socket绑定ip地址和端口号
# 
# 3 服务器socket监听端口号请求，随时准备接收客户端发来的连接，这时候服务器的socket并没有被打开
# 
# 4 客户端创建socket
# 
# 5 客户端打开socket，根据服务器ip地址和端口号试图连接服务器socket
# 
# 6 服务器socket接收到客户端socket请求，被动打开，开始接收客户端请求，直到客户端返回连接信息。这时候socket进入阻塞状态，
#   所谓阻塞即accept()方法一直等到客户端返回连接信息后才返回，开始接收下一个客户端连接请求
# 
# 7 客户端连接成功，向服务器发送连接状态信息
# 
# 8 服务器accept方法返回，连接成功
# 
# 9 客户端向socket写入信息(或服务端向socket写入信息)
# 
# 10 服务器读取信息(客户端读取信息)
# 
# 11 客户端关闭
# 
# 12 服务器端关闭

TCP是一种面向连接的可靠地协议，在一方发送数据之前，必须在双方之间建立一个连接，建立的过程需要经过三次握手，通信完成后要拆除连接，需要经过四次握手，这是由TCP的半关闭造成的，一方在完成数据发送后要发送一个FIN来终止这个方向的连接，一个TCP连接在收到一个FIN后仍能发送数据，但应用程序很少这么做，下面是TCP连接建立和拆除的过程：

Socket 对象(内建)方法

服务器端

s.bind()     
# 绑定地址（host,port）到套接字， 在AF_INET下,以元组（host,port）的形式表示地址。
s.listen()     
# 开始TCP监听。backlog指定在拒绝连接之前，操作系统可以挂起的最大连接数量。该值至少为1，大部分应用程序设为5就可以了。
s.accept()     
# 被动接受TCP客户端连接,(阻塞式)等待连接的到来


客户端

s.connect()     
# 主动初始化TCP服务器连接，。一般address的格式为元组（hostname,port），如果连接出错，返回socket.error错误。
s.connect_ex()     
# connect()函数的扩展版本,出错时返回出错码,而不是抛出异常


公共用途的函数

s.recv()     
# 接收TCP数据，数据以字符串形式返回，bufsize指定要接收的最大数据量。flag提供有关消息的其他信息，通常可以忽略。
s.send()     
# 发送TCP数据，将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。
s.sendall()     
# 完整发送TCP数据，完整发送TCP数据。将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。
s.close()
# 关闭套接字


s.recvform()     
# 接收UDP数据，与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。
s.sendto()     
# 发送UDP数据，将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。
s.getpeername()     
# 返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。
s.getsockname()     
# 返回套接字自己的地址。通常是一个元组(ipaddr,port)
s.setsockopt(level,optname,value)     
# 设置给定套接字选项的值。
s.getsockopt(level,optname[.buflen])      
# 返回套接字选项的值。
s.settimeout(timeout)     
# 设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如connect()）
s.gettimeout()     
# 返回当前超时期的值，单位是秒，如果没有设置超时期，则返回None。
s.fileno()     
# 返回套接字的文件描述符。
s.setblocking(flag)     
# 如果flag为0，则将套接字设为非阻塞模式，否则将套接字设为阻塞模式（默认值）。非阻塞模式下，如果调用recv()没有发现任何数据，或send()调用无法立即发送数据，那么将引起socket.error异常。
s.makefile()     
# 创建一个与该套接字相关连的文件

简单实例

服务端

我们使用socket模块的socket函数来创建一个socket对象。socket对象可以通过调用其他函数来设置一个socket服务。

现在我们可以通过调用bind(hostname,port)函数来指定服务器的port（端口）。

接着，我们调用socket对象的accept方法。该方法等待客户端的连接，并返回connection对象，表示已连接到客户端。

import socket  # 导入socket模块

sk = socket.socket()  # 创建socket对象
sk.bind(("127.0.0.1", 8888))  # 绑定端口,“127.0.0.1”代表本机地址，8888为设置链接的端口地址
sk.listen(5)  # 设置监听，最多可有5个客户端进行排队
conn, addr = sk.accept()  # 阻塞状态，被动等待客户端的连接
print(conn)  # conn可以理解客户端的socket对象
# <socket.socket fd=4, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('127.0.0.1', 9005), raddr=('127.0.0.1', 36694)>
print(addr)  # addr为客户端的端口地址
# ('127.0.0.1', 40966)
accept_data = conn.recv(1024)  # conn.recv()接收客户端的内容，接收到的是bytes类型数据，
accept_data2 = str(accept_data, encoding="utf8")  # str(data,encoding="utf8")用“utf8”进行解码
print("".join(("接收内容：", accept_data2, "    客户端口：", str(addr[1]))))
send_data = input("输入发送内容：")
conn.sendall(bytes(send_data, encoding="utf8"))  # 发送内容必须为bytes类型数据，bytes(data, encoding="utf8")用“utf8”格式进行编码
conn.close()

客户端

接下来我们写一个简单的客户端实例连接到以上创建的服务。端口号为8888。

socket.connect(hostname,port)方法打开一个TCP连接到主机为"127.0.0.1"端口为port的服务商。连接后我们就可以从服务器端后期数据，记住，操作完成后需要关闭连接。

import socket

sk = socket.socket()
sk.connect(("127.0.0.1", 8888))  # 主动初始化与服务器端的连接
send_data = input("输入发送内容：")
sk.sendall(bytes(send_data, encoding="utf8"))
accept_data = sk.recv(1024)
print(str(accept_data, encoding="utf8"))
sk.close()

以上只是实现了服务端一次的接收和发送，下面我们进行升级可以一直进行通讯：

服务端

import socket

sk = socket.socket()
sk.bind(("127.0.0.1", 9008))
sk.listen(5)
while True:
    conn, addr = sk.accept()
    while True:
        accept_data = str(conn.recv(1024),
                          encoding="utf8")
        print("".join(["接收内容：", accept_data, "     客户端口：", str(addr[1])]))
        if accept_data == "byebye":  # 如果接收到“byebye”则跳出循环结束和第一个客户端的通讯，开始与下一个客户端进行通讯
            break
        send_data = input("输入发送内p容：")
        conn.sendall(bytes(send_data, encoding="utf8"))
    conn.close()  # 跳出循环时结束通讯

客户端

import socket

sk = socket.socket()
sk.connect(("127.0.0.1", 9008))  # 主动初始化与服务器端的连接
while True:
    send_data = input("输入发送内容:")
    sk.sendall(bytes(send_data, encoding="utf8"))
    if send_data == "byebye":
        break
    accept_data = str(sk.recv(1024), encoding="utf8")
    print("".join(("接收内容：", accept_data)))
sk.close()

以上简单实例中，客户端必须排队与服务器进行通讯，只有当前一个客户端与服务器端通讯完毕后才能与服务端进行通讯，那么有没有办法能让多个客户端同时与服务器端进行通讯呢？那么就要用到socketserver模块了：

简单并发实例

服务端

import socketserver  # 导入socketserver模块


class MyServer(socketserver.BaseRequestHandler):  # 创建一个类，继承自socketserver模块下的BaseRequestHandler类
    def handle(self):  # 要想实现并发效果必须重写父类中的handler方法，在此方法中实现服务端的逻辑代码（不用再写连接准备，包括bind()、listen()、accept()方法）
        while 1:
            conn = self.request
            addr = self.client_address
            # 上面两行代码，等于 conn,addr = socket.accept()，只不过在socketserver模块中已经替我们包装好了，还替我们包装了包括bind()、listen()、accept()方法
            while 1:
                accept_data = str(conn.recv(1024), encoding="utf8")
                print(accept_data)
                if accept_data == "byebye":
                    break
                send_data = bytes(input(">>>>>"), encoding="utf8")
                conn.sendall(send_data)
            conn.close()


if __name__ == '__main__':
    sever = socketserver.ThreadingTCPServer(("127.0.0.1", 8888),
                                            MyServer)  # 传入 端口地址 和 我们新建的继承自socketserver模块下的BaseRequestHandler类  实例化对象

    sever.serve_forever()  # 通过调用对象的serve_forever()方法来激活服务端

客户端（http://www.cnblogs.com/idontknowthisperson/p/5958536.html）

import socket

sk = socket.socket()
sk.connect(("127.0.0.1", 8888))  # 主动初始化与服务器端的连接
while True:
    send_data = input("输入发送内容:")
    sk.sendall(bytes(send_data, encoding="utf8"))
    if send_data == "byebye":
        break
    accept_data = str(sk.recv(1024), encoding="utf8")
    print("".join(("接收内容：", accept_data)))
sk.close()

套接字对象方法

下面是最常用的套接字对象方法：

服务器端套接字函数

socket类型	描述
s.bind()	绑定地址（主机号端口号对）到套接字
s.listen()	开始TCP监听
s.accept()	被动接受TCP客户端连接，（阻塞式）等待连续的到来

客户端套接字函数

socket类型	描述
s.connect()	主动初始化TCP服务器连接
s.connect_ex()	connect()函数扩展版本，出错时返回出错码而不是跑出异常

公共用途的套接字函数

socket类型	描述
s.recv()	接受TCP数据
s.send()	发送TCP数据
s.sendall()	完整发送TCP数据
s.recvfrom()	接受UDP数据
s.sendto()	发送UDP数据
s.getpeername()	连接到当前套接字的远端地址（TCP连接）
s.getsockname()	获取当前套接字的地址
s.getsockopt()	返回指定套接字的参数
s.setsockopt()	设置指定套接字的参数
s.close()	关闭套接字

面向模块的套接字函数

socket类型	描述
s.setblocking()	设置套接字的阻塞与非阻塞模式
s.settimeout()	设置阻塞套接字操作的超时时间
s.gettimeout()	得到阻塞套接字操作的超时时间

面向文件的套接字函数

socket类型	描述
s.fileno()	套接字的文件描述符
s.makefile()	创建一个与套接字关联的文件对象

TCP通信实例

1.服务器 tcpSerSock.py

核心操作如下：

　　　ss = socket() # 创建服务器套接字
　　ss.bind() 　　 # 地址绑定到套接字上
　　ss.listen() # 监听连接
inf_loop:   # 服务器无限循环
cs = ss.accept()   # 接受客户端连接阻塞式:程序连接之前处于挂起状态
comm_loop:   # 通信循环
cs.recv()/cs.send()   # 对话接受与发送数据
cs.close() # 关闭客户端套接字
ss.close() # 关闭服务器套接字 (可选)

代码来源：http://blog.csdn.net/ziyouhahaze/article/details/48914731

文章来源：http://www.cnblogs.com/nulige/p/6235531.html?utm_source=itdadao&utm_medium=referral